summaryrefslogtreecommitdiffstats
diff options
authorfche <fche>2019-11-18 23:01:46 +0000
committerfche <fche>2019-11-18 23:01:46 +0000
commit59b5442c181f78643b8910fb872ba9a16c3d9942 (patch)
treedd0a6422d3610f1f67f3a8ae03817c700104efde
parentadded new man pages (diff)
removed langref/*.html
Diffstat
-rw-r--r--langref.pdfbin278973 -> 279363 bytes
-rw-r--r--langref/10_Tapset_defined_functions.html72
-rw-r--r--langref/11_Further_Reference.html96
-rw-r--r--langref/1_SystemTap_overview.html452
-rw-r--r--langref/2_Types_SystemTap_scripts.html99
-rw-r--r--langref/3_Components_SystemTap_scri.html882
-rw-r--r--langref/4_Probe_points.html1516
-rw-r--r--langref/5_Language_elements.html905
-rw-r--r--langref/6_Statement_types.html430
-rw-r--r--langref/7_Associative_arrays.html262
-rw-r--r--langref/8_Statistics_aggregates.html376
-rw-r--r--langref/9_Formatted_output.html479
-rw-r--r--langref/About_this_document.html64
-rw-r--r--langref/Contents.html251
-rw-r--r--langref/Index.html299
-rw-r--r--langref/index.html435
-rw-r--r--langref/langref.html435
17 files changed, 0 insertions, 7053 deletions
diff --git a/langref.pdf b/langref.pdf
index a1842795..044d0d95 100644
--- a/langref.pdf
+++ b/langref.pdf
Binary files differ
diff --git a/langref/10_Tapset_defined_functions.html b/langref/10_Tapset_defined_functions.html
deleted file mode 100644
index 12bec38a..00000000
--- a/langref/10_Tapset_defined_functions.html
+++ /dev/null
@@ -1,72 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>10 Tapset-defined functions</TITLE>
7<META NAME="description" CONTENT="10 Tapset-defined functions">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="11_Further_Reference.html">
19<LINK REL="previous" HREF="9_Formatted_output.html">
20<LINK REL="next" HREF="11_Further_Reference.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="11_Further_Reference.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="9_Formatted_output.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html411"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html413"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="11_Further_Reference.html">11 For Further Reference</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="9_Formatted_output.html">9 Formatted output</A>
48 &nbsp; <B> <A ID="tex2html412"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html414"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55
56<H1><A ID="SECTION000110000000000000000"></A><A ID="sec:Predefined-Functions"></A>
57<BR>
58<SPAN CLASS="arabic">10</SPAN> Tapset-defined functions
59</H1>
60
61<P>
62Unlike built-in functions, tapset-defined functions are implemented in tapset scripts.
63These are individually documented in the in <SPAN CLASS="texttt">tapset::*(3stap)</SPAN>,
64<SPAN CLASS="texttt">function::*(3stap)</SPAN>,
65and <SPAN CLASS="texttt">probe::*(3stap)</SPAN> man pages, and implemented under
66<SPAN CLASS="texttt">/usr/share/systemtap/tapset</SPAN>.
67
68<P>
69<BR><HR>
70
71</BODY>
72</HTML>
diff --git a/langref/11_Further_Reference.html b/langref/11_Further_Reference.html
deleted file mode 100644
index 198317aa..00000000
--- a/langref/11_Further_Reference.html
+++ /dev/null
@@ -1,96 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>11 For Further Reference</TITLE>
7<META NAME="description" CONTENT="11 For Further Reference">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="Index.html">
19<LINK REL="previous" HREF="10_Tapset_defined_functions.html">
20<LINK REL="next" HREF="Index.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="Index.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="10_Tapset_defined_functions.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html415"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html417"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="Index.html">Index</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="10_Tapset_defined_functions.html">10 Tapset-defined functions</A>
48 &nbsp; <B> <A ID="tex2html416"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html418"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55
56<H1><A ID="SECTION000120000000000000000"></A><A ID="sec:For-Further-Reference"></A>
57<BR>
58<SPAN CLASS="arabic">11</SPAN> For Further Reference
59</H1>
60
61<P>
62For more information, see:
63
64<UL>
65<LI>The SystemTap tutorial at <kbd><A ID="tex2html9"
66 HREF="http://sourceware.org/systemtap/tutorial/">http://sourceware.org/systemtap/tutorial/</A></kbd>
67</LI>
68<LI>The SystemTap wiki at <kbd><A ID="tex2html10"
69 HREF="http://sourceware.org/systemtap/wiki">http://sourceware.org/systemtap/wiki</A></kbd>
70</LI>
71<LI>The SystemTap documentation page at <kbd><A ID="tex2html11"
72 HREF="http://sourceware.org/systemtap/documentation.html">http://sourceware.org/systemtap/documentation.html</A></kbd>
73</LI>
74<LI>From an unpacked source tarball or GIT directory, the examples in in the
75src/examples directory, the tapsets in the src/tapset directory, and the
76test scripts in the src/testsuite directory.
77</LI>
78<LI>The man pages for tapsets.
79For a list, run the command <SPAN CLASS="texttt">&ldquo;man -k tapset::</SPAN>&rdquo;.
80</LI>
81<LI>The man pages for individual probe points.
82For a list, run the command <SPAN CLASS="texttt">&ldquo;man -k probe::</SPAN>&rdquo;.
83</LI>
84<LI>The man pages for individual systemtap functions.
85For a list, run the command <SPAN CLASS="texttt">&ldquo;man -k function::</SPAN>&rdquo;.
86</LI>
87</UL>
88
89<P>
90
91
92
93<BR><HR>
94
95</BODY>
96</HTML>
diff --git a/langref/1_SystemTap_overview.html b/langref/1_SystemTap_overview.html
deleted file mode 100644
index dfc9ee69..00000000
--- a/langref/1_SystemTap_overview.html
+++ /dev/null
@@ -1,452 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>1 SystemTap overview</TITLE>
7<META NAME="description" CONTENT="1 SystemTap overview">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="2_Types_SystemTap_scripts.html">
19<LINK REL="previous" HREF="Contents.html">
20<LINK REL="next" HREF="2_Types_SystemTap_scripts.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="2_Types_SystemTap_scripts.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="Contents.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html243"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html245"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="2_Types_SystemTap_scripts.html">2 Types of SystemTap</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="Contents.html">Contents</A>
48 &nbsp; <B> <A ID="tex2html244"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html246"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html247"
60 HREF="1_SystemTap_overview.html#SECTION00021000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN> About this guide</A>
61<LI><A ID="tex2html248"
62 HREF="1_SystemTap_overview.html#SECTION00022000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN> Reasons to use SystemTap</A>
63<LI><A ID="tex2html249"
64 HREF="1_SystemTap_overview.html#SECTION00023000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN> Event-action language</A>
65<LI><A ID="tex2html250"
66 HREF="1_SystemTap_overview.html#SECTION00024000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN> Sample SystemTap scripts</A>
67<UL>
68<LI><A ID="tex2html251"
69 HREF="1_SystemTap_overview.html#SECTION00024100000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> Basic SystemTap syntax and control structures</A>
70<LI><A ID="tex2html252"
71 HREF="1_SystemTap_overview.html#SECTION00024200000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> Primes between 0 and 49</A>
72<LI><A ID="tex2html253"
73 HREF="1_SystemTap_overview.html#SECTION00024300000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN> Recursive functions</A>
74</UL>
75<BR>
76<LI><A ID="tex2html254"
77 HREF="1_SystemTap_overview.html#SECTION00025000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN> The stap command</A>
78<LI><A ID="tex2html255"
79 HREF="1_SystemTap_overview.html#SECTION00026000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">6</SPAN> Safety and security</A>
80</UL>
81<!--End of Table of Child-Links-->
82<HR>
83
84<H1><A ID="SECTION00020000000000000000"></A><A ID="sec:SystemTap-Overview"></A>
85<BR>
86<SPAN CLASS="arabic">1</SPAN> SystemTap overview
87</H1>
88
89<P>
90
91<H2><A ID="SECTION00021000000000000000">
92<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN> About this guide</A>
93</H2>
94
95<P>
96This guide is a comprehensive reference of SystemTap's language constructs
97and syntax. The contents borrow heavily from existing SystemTap documentation
98found in manual pages and the tutorial. The presentation of information here
99provides the reader with a single place to find language syntax and recommended
100usage. In order to successfully use this guide, you should be familiar with
101the general theory and operation of SystemTap. If you are new to SystemTap,
102you will find the tutorial to be an excellent place to start learning. For
103detailed information about tapsets, see the manual pages provided with the
104distribution. For information about the entire collection of SystemTap reference
105material, see Section&nbsp;<A HREF="11_Further_Reference.html#sec:For-Further-Reference"><IMG ALT="[*]" SRC="crossref.png"></A>
106
107<P>
108
109<H2><A ID="SECTION00022000000000000000">
110<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN> Reasons to use SystemTap</A>
111</H2>
112
113<P>
114SystemTap provides infrastructure to simplify the gathering of information
115about a running Linux kernel so that it may be further analyzed. This analysis
116assists in identifying the underlying cause of a performance or functional
117problem. SystemTap was designed to eliminate the need for a developer to
118go through the tedious instrument, recompile, install, and reboot sequence
119normally required to collect this kind of data. To do this, it provides a
120simple command-line interface and scripting language for writing
121instrumentation for both kernel and user space.
122With SystemTap, developers, system administrators, and users can easily write
123scripts that gather and manipulate system data that is otherwise unavailable
124from standard Linux tools. Users of SystemTap will find it to be a significant
125improvement over older methods.
126
127<P>
128
129<H2><A ID="SECTION00023000000000000000"></A>
130<A NAME="48"></A>
131<BR>
132<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN> Event-action language
133</H2>
134SystemTap's language is strictly typed, declaration free, procedural, and
135inspired by dtrace and awk. Source code points or events in the kernel are
136associated with handlers, which are subroutines that are executed synchronously.
137These probes are conceptually similar to &#34;breakpoint command lists&#34;
138in the GDB debugger.
139
140<P>
141There are two main outermost constructs: probes and functions. Within these,
142statements and expressions use C-like operator syntax and precedence.
143
144<P>
145
146<H2><A ID="SECTION00024000000000000000"></A>
147<A NAME="52"></A>
148<BR>
149<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN> Sample SystemTap scripts
150</H2>
151Following are some example scripts that illustrate the basic operation of
152SystemTap. For more examples, see the examples/small_demos/ directory in
153the source directory, the SystemTap wiki at <kbd><A ID="tex2html2"
154 HREF="http://sourceware.org/systemtap/wiki/HomePage">http://sourceware.org/systemtap/wiki/HomePage</A></kbd>,
155or the SystemTap War Stories at <kbd><A ID="tex2html3"
156 HREF="http://sourceware.org/systemtap/wiki/WarStories">http://sourceware.org/systemtap/wiki/WarStories</A></kbd> page.
157
158<P>
159
160<H3><A ID="SECTION00024100000000000000">
161<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> Basic SystemTap syntax and control structures</A>
162</H3>
163
164<P>
165The following code examples demonstrate SystemTap syntax and control structures.
166
167<P>
168
169<DL COMPACT>
170<DT>
171<DD><PRE>
172global odds, evens
173
174probe begin {
175 # "no" and "ne" are local integers
176 for (i = 0; i &lt; 10; i++) {
177 if (i % 2) odds [no++] = i
178 else evens [ne++] = i
179 }
180
181 delete odds[2]
182 delete evens[3]
183 exit()
184}
185
186probe end {
187 foreach (x+ in odds)
188 printf ("odds[%d] = %d", x, odds[x])
189
190 foreach (x in evens-)
191 printf ("evens[%d] = %d", x, evens[x])
192}
193</PRE>
194</DD>
195</DL>This prints:
196
197<P>
198
199<DL COMPACT>
200<DT>
201<DD><PRE>
202odds[0] = 1
203odds[1] = 3
204odds[3] = 7
205odds[4] = 9
206evens[4] = 8
207evens[2] = 4
208evens[1] = 2
209evens[0] = 0
210</PRE>
211</DD>
212</DL>Note that all variable types are inferred, and that all locals and
213globals are initialized. Integers are set to 0 and strings are set to
214the empty string.
215
216<P>
217
218<H3><A ID="SECTION00024200000000000000">
219<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> Primes between 0 and 49</A>
220</H3>
221
222<P>
223
224<DL COMPACT>
225<DT>
226<DD><PRE>
227function isprime (x) {
228 if (x &lt; 2) return 0
229 for (i = 2; i &lt; x; i++) {
230 if (x % i == 0) return 0
231 if (i * i &gt; x) break
232 }
233 return 1
234}
235
236probe begin {
237 for (i = 0; i &lt; 50; i++)
238 if (isprime (i)) printf("%d\n", i)
239 exit()
240}
241</PRE>
242</DD>
243</DL>This prints:
244
245<P>
246
247<DL COMPACT>
248<DT>
249<DD><PRE>
2502
2513
2525
2537
25411
25513
25617
25719
25823
25929
26031
26137
26241
26343
26447
265</PRE>
266</DD>
267</DL>
268<P>
269
270<H3><A ID="SECTION00024300000000000000"></A>
271<A NAME="74"></A>
272<BR>
273<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN> Recursive functions
274</H3>
275
276<DL COMPACT>
277<DT>
278<DD><PRE>
279function fibonacci(i) {
280 if (i &lt; 1) error ("bad number")
281 if (i == 1) return 1
282 if (i == 2) return 2
283 return fibonacci (i-1) + fibonacci (i-2)
284}
285
286probe begin {
287 printf ("11th fibonacci number: %d", fibonacci (11))
288 exit ()
289}
290</PRE>
291</DD>
292</DL>This prints:
293
294<P>
295
296<DL COMPACT>
297<DT>
298<DD><PRE>
29911th fibonacci number: 118
300</PRE>
301</DD>
302</DL>Any larger number input to the function may exceed the MAXACTION or MAXNESTING
303limits, which will be caught at run time and result in an error. For more
304about limits see Section&nbsp;<A HREF="#sub:SystemTap-safety"><IMG ALT="[*]" SRC="crossref.png"></A>.
305
306
307<H2><A ID="SECTION00025000000000000000"></A>
308<A NAME="86"></A>
309<BR>
310<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN> The stap command
311</H2>
312The stap program is the front-end to the SystemTap tool. It accepts probing
313instructions written in its scripting language, translates those instructions
314into C code, compiles this C code, and loads the resulting kernel module
315into a running Linux kernel to perform the requested system trace or probe
316functions. You can supply the script in a named file, from standard input,
317or from the command line. The SystemTap script runs until one of the following
318conditions occurs:
319
320<P>
321
322<UL>
323<LI>The user interrupts the script with a CTRL-C.
324</LI>
325<LI>The script executes the exit() function.
326</LI>
327<LI>The script encounters a sufficient number of soft errors.
328</LI>
329<LI>The monitored command started with the stap program's
330<SPAN CLASS="texttt"><SPAN CLASS="textbf">-c</SPAN></SPAN> option exits.
331</LI>
332</UL>
333
334<P>
335The stap command does the following:
336
337<P>
338
339<UL>
340<LI>Translates the script
341</LI>
342<LI>Generates and compiles a kernel module
343</LI>
344<LI>Inserts the module; output to stap's stdout
345</LI>
346<LI>CTRL-C unloads the module and terminates stap
347</LI>
348</UL>
349
350<P>
351For a full list of options to the stap command, see the stap(1) manual page.
352
353<P>
354
355<H2><A ID="SECTION00026000000000000000"></A><A ID="sub:SystemTap-safety"></A>
356<A NAME="93"></A>
357<BR>
358<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">6</SPAN> Safety and security
359</H2>
360SystemTap is an administrative tool. It exposes kernel internal data structures
361and potentially private user information. It requires root privileges to
362actually run the kernel objects it builds using the <SPAN CLASS="textbf">sudo</SPAN> command,
363applied to the <SPAN CLASS="textbf">staprun</SPAN> program.
364
365<P>
366staprun is a part of the SystemTap package, dedicated to module loading and
367unloading and kernel-to-user data transfer. Since staprun does not perform
368any additional security checks on the kernel objects it is given, do not
369give elevated privileges via sudo to untrusted users.
370
371<P>
372The translator asserts certain safety constraints. <A NAME="96"></A>It
373ensures that no handler routine can run for too long, allocate memory, perform
374unsafe operations, or unintentionally interfere with the kernel. Use of script
375global variables is locked to protect against manipulation by concurrent
376probe handlers. Use of <SPAN CLASS="textit">guru mode</SPAN> constructs such as embedded C (see
377Section&nbsp;<A HREF="3_Components_SystemTap_scri.html#sub:Embedded-C"><IMG ALT="[*]" SRC="crossref.png"></A>) can violate these constraints, leading to
378a kernel crash or data corruption.
379
380<P>
381The resource use limits are set by macros in the generated C code. These
382may be overridden with the -D flag. The following list describes a selection
383of these macros:
384
385<P>
386<SPAN CLASS="textbf">MAXNESTING</SPAN> - The maximum number of recursive function call levels. The default is 10.
387
388<P>
389<SPAN CLASS="textbf">MAXSTRINGLEN</SPAN> - The maximum length of strings. The default is 256 bytes
390for 32 bit machines and 512 bytes for all other machines.
391
392<P>
393<SPAN CLASS="textbf">MAXTRYLOCK</SPAN> - The maximum number of iterations to wait for locks on global variables before
394declaring possible deadlock and skipping the probe. The default is 1000.
395
396<P>
397<SPAN CLASS="textbf">MAXACTION</SPAN> - The maximum number of statements to execute during any single probe hit. The default is 1000.
398
399<P>
400<SPAN CLASS="textbf">MAXMAPENTRIES</SPAN> - The maximum number of rows in an array if the array size is not specified
401explicitly when declared. The default is 2048.
402
403<P>
404<SPAN CLASS="textbf">MAXERRORS</SPAN> - The maximum number of soft errors before an exit is triggered. The default is 0.
405
406<P>
407<SPAN CLASS="textbf">MAXSKIPPED</SPAN> - The maximum number of skipped reentrant probes before an exit is triggered. The default is 100.
408
409<P>
410<SPAN CLASS="textbf">MINSTACKSPACE</SPAN> - The minimum number of free kernel stack bytes required in order to run a
411probe handler. This number should be large enough for the probe handler's
412own needs, plus a safety margin. The default is 1024.
413
414<P>
415If something goes wrong with stap or staprun after a probe has started running,
416you may safely kill both user processes, and remove the active probe kernel
417module with the rmmod command. Any pending trace messages may be lost.
418
419<P>
420
421<DIV CLASS="navigation"><HR>
422<!--Navigation Panel-->
423<A
424 HREF="2_Types_SystemTap_scripts.html">
425<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
426<A
427 HREF="langref.html">
428<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
429<A
430 HREF="Contents.html">
431<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
432<A ID="tex2html243"
433 HREF="Contents.html">
434<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
435<A ID="tex2html245"
436 HREF="Index.html">
437<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
438<BR>
439<B> Next:</B> <A
440 HREF="2_Types_SystemTap_scripts.html">2 Types of SystemTap</A>
441<B> Up:</B> <A
442 HREF="langref.html">SystemTap Language Reference</A>
443<B> Previous:</B> <A
444 HREF="Contents.html">Contents</A>
445 &nbsp; <B> <A ID="tex2html244"
446 HREF="Contents.html">Contents</A></B>
447 &nbsp; <B> <A ID="tex2html246"
448 HREF="Index.html">Index</A></B> </DIV>
449<!--End of Navigation Panel-->
450
451</BODY>
452</HTML>
diff --git a/langref/2_Types_SystemTap_scripts.html b/langref/2_Types_SystemTap_scripts.html
deleted file mode 100644
index fcc2d0e8..00000000
--- a/langref/2_Types_SystemTap_scripts.html
+++ /dev/null
@@ -1,99 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>2 Types of SystemTap scripts</TITLE>
7<META NAME="description" CONTENT="2 Types of SystemTap scripts">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="3_Components_SystemTap_scri.html">
19<LINK REL="previous" HREF="1_SystemTap_overview.html">
20<LINK REL="next" HREF="3_Components_SystemTap_scri.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="3_Components_SystemTap_scri.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="1_SystemTap_overview.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html256"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html258"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="3_Components_SystemTap_scri.html">3 Components of a</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="1_SystemTap_overview.html">1 SystemTap overview</A>
48 &nbsp; <B> <A ID="tex2html257"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html259"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html260"
60 HREF="2_Types_SystemTap_scripts.html#SECTION00031000000000000000"><SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Probe scripts</A>
61<LI><A ID="tex2html261"
62 HREF="2_Types_SystemTap_scripts.html#SECTION00032000000000000000"><SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Tapset scripts</A>
63</UL>
64<!--End of Table of Child-Links-->
65<HR>
66
67<H1><A ID="SECTION00030000000000000000"></A><A ID="sec:Types-of-SystemTap"></A>
68<BR>
69<SPAN CLASS="arabic">2</SPAN> Types of SystemTap scripts
70</H1>
71
72<P>
73
74<H2><A ID="SECTION00031000000000000000">
75<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Probe scripts</A>
76</H2>
77
78<P>
79Probe scripts are analogous to programs; these scripts identify probe points
80and associated handlers.
81
82<P>
83
84<H2><A ID="SECTION00032000000000000000">
85<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Tapset scripts</A>
86</H2>
87
88<P>
89Tapset scripts are libraries of probe aliases and auxiliary functions.
90
91<P>
92The /usr/share/systemtap/tapset directory contains tapset scripts. While
93these scripts look like regular SystemTap scripts, they cannot be run directly.
94
95<P>
96<BR><HR>
97
98</BODY>
99</HTML>
diff --git a/langref/3_Components_SystemTap_scri.html b/langref/3_Components_SystemTap_scri.html
deleted file mode 100644
index 1970ebe6..00000000
--- a/langref/3_Components_SystemTap_scri.html
+++ /dev/null
@@ -1,882 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>3 Components of a SystemTap script</TITLE>
7<META NAME="description" CONTENT="3 Components of a SystemTap script">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="4_Probe_points.html">
19<LINK REL="previous" HREF="2_Types_SystemTap_scripts.html">
20<LINK REL="next" HREF="4_Probe_points.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="4_Probe_points.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="2_Types_SystemTap_scripts.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html262"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html264"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="4_Probe_points.html">4 Probe points</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="2_Types_SystemTap_scripts.html">2 Types of SystemTap</A>
48 &nbsp; <B> <A ID="tex2html263"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html265"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html266"
60 HREF="3_Components_SystemTap_scri.html#SECTION00041000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> Probe definitions</A>
61<LI><A ID="tex2html267"
62 HREF="3_Components_SystemTap_scri.html#SECTION00042000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN> Probe aliases</A>
63<UL>
64<LI><A ID="tex2html268"
65 HREF="3_Components_SystemTap_scri.html#SECTION00042100000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Prologue-style aliases (=)</A>
66<LI><A ID="tex2html269"
67 HREF="3_Components_SystemTap_scri.html#SECTION00042200000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Epilogue-style aliases (+=)</A>
68<LI><A ID="tex2html270"
69 HREF="3_Components_SystemTap_scri.html#SECTION00042300000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN> Probe alias usage</A>
70<LI><A ID="tex2html271"
71 HREF="3_Components_SystemTap_scri.html#SECTION00042400000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">4</SPAN> Alias suffixes</A>
72<LI><A ID="tex2html272"
73 HREF="3_Components_SystemTap_scri.html#SECTION00042500000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">5</SPAN> Alias suffixes and wildcards</A>
74</UL>
75<BR>
76<LI><A ID="tex2html273"
77 HREF="3_Components_SystemTap_scri.html#SECTION00043000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN> Variables</A>
78<UL>
79<LI><A ID="tex2html274"
80 HREF="3_Components_SystemTap_scri.html#SECTION00043100000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> Unused variables</A>
81</UL>
82<BR>
83<LI><A ID="tex2html275"
84 HREF="3_Components_SystemTap_scri.html#SECTION00044000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN> Auxiliary functions</A>
85<LI><A ID="tex2html276"
86 HREF="3_Components_SystemTap_scri.html#SECTION00045000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN> Embedded C</A>
87<LI><A ID="tex2html277"
88 HREF="3_Components_SystemTap_scri.html#SECTION00046000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">6</SPAN> Embedded C functions</A>
89<LI><A ID="tex2html278"
90 HREF="3_Components_SystemTap_scri.html#SECTION00047000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">7</SPAN> Embedded C pragma comments</A>
91<LI><A ID="tex2html279"
92 HREF="3_Components_SystemTap_scri.html#SECTION00048000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">8</SPAN> Accessing script level global variables</A>
93</UL>
94<!--End of Table of Child-Links-->
95<HR>
96
97<H1><A ID="SECTION00040000000000000000">
98<SPAN CLASS="arabic">3</SPAN> Components of a SystemTap script</A>
99</H1>
100
101<P>
102The main construct in the scripting language identifies probes. Probes associate
103abstract events with a statement block, or probe handler, that is to be executed
104when any of those events occur.
105
106<P>
107The following example shows how to trace entry and exit from a function using
108two probes.
109
110<P>
111
112<DL COMPACT>
113<DT>
114<DD><PRE>
115probe kernel.function("sys_mkdir").call { log ("enter") }
116probe kernel.function("sys_mkdir").return { log ("exit") }
117</PRE>
118</DD>
119</DL>
120<P>
121To list the probe-able functions in the kernel, use the listing option
122(<SPAN CLASS="texttt"><SPAN CLASS="textbf">-l</SPAN></SPAN>). For example:
123
124<P>
125
126<DL COMPACT>
127<DT>
128<DD><PRE>
129$ stap -l 'kernel.function("*")' | sort
130</PRE>
131</DD>
132</DL>
133<P>
134
135<H2><A ID="SECTION00041000000000000000">
136<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> Probe definitions</A>
137</H2>
138
139<P>
140The general syntax is as follows.
141
142<P>
143
144<DL COMPACT>
145<DT>
146<DD><PRE>
147probe PROBEPOINT [, PROBEPOINT] { [STMT ...] }
148</PRE>
149</DD>
150</DL>Events are specified in a special syntax called <SPAN CLASS="textit">probe points</SPAN>. There
151are several varieties of probe points defined by the translator, and tapset
152scripts may define others using aliases. The provided probe points are listed
153in the <SPAN CLASS="texttt">stapprobes(3)</SPAN>, <SPAN CLASS="texttt">tapset::*(3stap)</SPAN>, and
154<SPAN CLASS="texttt">probe::*(3stap)</SPAN> man pages. The STMT statement block is executed
155whenever &#305;any of the named PROBEPOINT events occurs.
156
157<P>
158The probe handler is interpreted relative to the context of each event. For
159events associated with kernel code, this context may include variables defined
160in the source code at that location. These <SPAN CLASS="textit">target variables</SPAN><A NAME="131"></A> (or &ldquo;context variables&rdquo;)
161are presented to the script as variables whose names are prefixed with a
162dollar sign ($). They may be accessed only if the compiler used to compile
163the kernel preserved them, despite optimization. This is the same constraint
164imposed by a debugger when working with optimized code. Other events may
165have very little context.
166
167<P>
168
169<H2><A ID="SECTION00042000000000000000"></A><A ID="sub:Probe-aliases"></A>
170<A NAME="133"></A>
171<BR>
172<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN> Probe aliases
173</H2>
174The general syntax is as follows.
175
176<P>
177
178<DL COMPACT>
179<DT>
180<DD><PRE>
181probe &lt;alias&gt; = &lt;probepoint&gt; { &lt;prologue_stmts&gt; }
182probe &lt;alias&gt; += &lt;probepoint&gt; { &lt;epilogue_stmts&gt; }
183</PRE>
184</DD>
185</DL>
186<P>
187New probe points may be defined using <SPAN CLASS="textit">aliases</SPAN>. A probe point alias
188looks similar to probe definitions, but instead of activating a probe at
189the given point, it defines a new probe point name as an alias to an existing
190one. New probe aliases may refer to one or more existing probe aliases.
191Multiple aliases may share the same underlying probe points.
192The following is an example.
193
194<P>
195
196<DL COMPACT>
197<DT>
198<DD><PRE>
199probe socket.sendmsg = kernel.function ("sock_sendmsg") { ... }
200probe socket.do_write = kernel.function ("do_sock_write") { ... }
201probe socket.send = socket.sendmsg, socket.do_write { ... }
202</PRE>
203</DD>
204</DL>
205<P>
206There are two types of aliases, the prologue style and the epilogue style
207which are identified by the equal sign (<SPAN CLASS="texttt"><SPAN CLASS="textbf">=</SPAN></SPAN>) and &#34;<SPAN CLASS="texttt"><SPAN CLASS="textbf">+=</SPAN></SPAN>&#34;
208respectively.
209
210<P>
211A probe that uses a probe point alias will create an actual probe, with
212the handler of the alias <SPAN CLASS="textit">pre-pended</SPAN>.
213
214<P>
215This pre-pending behavior serves several purposes. It allows the alias definition
216to pre-process the context of the probe before passing control to the handler
217specified by the user. This has several possible uses, demonstrated as follows.
218
219<P>
220
221<DL COMPACT>
222<DT>
223<DD><PRE>
224# Skip probe unless given condition is met:
225if ($flag1 != $flag2) next
226
227# Supply values describing probes:
228name = "foo"
229
230# Extract the target variable to a plain local variable:
231var = $var
232</PRE>
233</DD>
234</DL>
235<P>
236
237<H3><A ID="SECTION00042100000000000000"></A>
238<A NAME="153"></A>
239<A NAME="154"></A>
240<BR>
241<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Prologue-style aliases (=)
242</H3>
243For a prologue style alias, the statement block that follows an alias definition
244is implicitly added as a prologue to any probe that refers to the alias.
245The following is an example.
246
247<P>
248
249<DL COMPACT>
250<DT>
251<DD><PRE>
252# Defines a new probe point syscall.read, which expands to
253# kernel.function("sys_read"), with the given statement as
254# a prologue.
255#
256probe syscall.read = kernel.function("sys_read") {
257 fildes = $fd
258}
259</PRE>
260</DD>
261</DL>
262<P>
263
264<H3><A ID="SECTION00042200000000000000"></A>
265<A NAME="160"></A>
266<A NAME="161"></A>
267<BR>
268<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Epilogue-style aliases (+=)
269</H3>
270The statement block that follows an alias definition is implicitly added
271as an epilogue to any probe that refers to the alias. It is not useful
272to define new variables there (since no subsequent code will see them), but
273rather the code can take action based upon variables set by the
274prologue or by the user code. The following is an example:
275
276<P>
277
278<DL COMPACT>
279<DT>
280<DD><PRE>
281# Defines a new probe point with the given statement as an
282# epilogue.
283#
284probe syscall.read += kernel.function("sys_read") {
285 if (traceme) println ("tracing me")
286}
287</PRE>
288</DD>
289</DL>
290<P>
291
292<H3><A ID="SECTION00042300000000000000">
293<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN> Probe alias usage</A>
294</H3>
295
296<P>
297A probe alias is used the same way as any built-in probe type, by
298naming it:
299
300<P>
301
302<DL COMPACT>
303<DT>
304<DD><PRE>
305probe syscall.read {
306 printf("reading fd=%d\n", fildes)
307}
308</PRE>
309</DD>
310</DL>
311<P>
312
313<H3><A ID="SECTION00042400000000000000">
314<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">4</SPAN> Alias suffixes</A>
315</H3>
316
317<P>
318It is possible to include a suffix with a probe alias invocation. If
319only the initial part of a probe point matches an alias, the remainder
320is treated as a suffix and attached to the underlying probe point(s) when
321the alias is expanded. For example:
322
323<P>
324
325<DL COMPACT>
326<DT>
327<DD><PRE>
328/* Define an alias: */
329probe sendrecv = tcp.sendmsg, tcp.recvmsg { ... }
330
331/* Use the alias in its basic form: */
332probe sendrecv { ... }
333
334/* Use the alias with an additional suffix: */
335probe sendrecv.return { ... }
336</PRE>
337</DD>
338</DL>
339<P>
340Here, the second use of the probe alias is equivalent to writing <code>probe tcp.sendmsg.return, tcp.recvmsg.return</code>.
341
342<P>
343As another example, the probe points <code>tcp.sendmsg.return</code> and <code>tcp.recvmsg.return</code> are actually defined as aliases in the tapset <code>tcp.stp</code>. They expand to a probe point of the form <code>kernel.function("...").return</code>, so they can also be suffixed:
344
345<P>
346
347<DL COMPACT>
348<DT>
349<DD><PRE>
350probe tcp.sendmsg.return.maxactive(10) {
351 printf("returning from sending %d bytes\n", size)
352}
353</PRE>
354</DD>
355</DL>
356<P>
357Here, the probe point expands to
358<code>kernel.function("tcp_sendmsg").return.maxactive(10)</code>.
359
360<P>
361
362<H3><A ID="SECTION00042500000000000000">
363<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">5</SPAN> Alias suffixes and wildcards</A>
364</H3>
365
366<P>
367When expanding wildcards, SystemTap generally avoids considering alias
368suffixes in the expansion. The exception is when a wildcard element is
369encountered that does not have any ordinary expansions. Consider the
370following example:
371
372<P>
373
374<DL COMPACT>
375<DT>
376<DD><PRE>
377probe some_unrelated_probe = ... { ... }
378
379probe myprobe = syscall.read { ... }
380
381probe myprobe.test = some_unrelated_probe { ... }
382
383probe myprobe.* { ... }
384
385probe myprobe.ret* { ... }
386</PRE>
387</DD>
388</DL>
389<P>
390Here, <code>return</code> would be a valid suffix for <code>myprobe</code>. The
391wildcard <code>myprobe.*</code> matches the ordinary alias
392<code>myprobe.test</code>, and hence the suffix expansion
393<code>myprobe.return</code> is not included. Conversely, <code>myprobe.ret*</code>
394does not match any ordinary aliases, so the suffix
395<code>myprobe.return</code> is included as an expansion.
396
397<P>
398
399<H2><A ID="SECTION00043000000000000000"></A><A ID="sub:Variables"></A>
400<A NAME="186"></A>
401<BR>
402<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN> Variables
403</H2>
404Identifiers for variables and functions are alphanumeric sequences, and may
405include the underscore (_) and the dollar sign ($) characters. They may
406not start with a plain digit. Each variable is by default local to the probe
407or function statement block where it is mentioned, and therefore its scope
408and lifetime is limited to a particular probe or function invocation. Scalar
409variables are implicitly typed as either string or integer. Associative arrays
410also have a string or integer value, and a tuple of strings or integers serves
411as a key. Arrays must be declared as global. Local arrays<A NAME="187"></A>
412are not allowed.
413
414<P>
415The translator performs <SPAN CLASS="textit">type inference</SPAN> on all identifiers, including
416array indexes and function parameters. Inconsistent type-related use of identifiers
417results in an error.
418
419<P>
420Variables may be declared global. Global variables are shared among all probes
421and remain instantiated as long as the SystemTap session. There is one namespace
422for all global variables, regardless of the script file in which they are
423found. Because of possible concurrency limits, such as multiple probe handlers,
424each global variable used by a probe is automatically read- or write-locked
425while the handler is running. A global declaration may be written at the
426outermost level anywhere in a script file, not just within a block of code.
427Global variables which are written but never read will be displayed
428automatically at session shutdown. The following declaration marks
429<SPAN CLASS="texttt">var1</SPAN> and <SPAN CLASS="texttt">var2</SPAN> as global.
430The translator will infer a value type for each, and if the variable is used
431as an array, its key types.
432
433<P>
434
435<DL COMPACT>
436<DT>
437<DD><PRE>
438global var1[=&lt;value&gt;], var2[=&lt;value&gt;]
439</PRE>
440</DD>
441</DL>
442<P>
443The scope of a global variable may be limited to a tapset or
444user script file using private keyword. The global keyword is optional when
445defining a private global variable. Following declaration marks var1 and var2
446private globals.
447
448<P>
449
450<DL COMPACT>
451<DT>
452<DD><PRE>
453private global var1[=&lt;value&gt;]
454private var2[=&lt;value&gt;]
455</PRE>
456</DD>
457</DL>
458<P>
459
460<H3><A ID="SECTION00043100000000000000"></A>
461<A NAME="200"></A>
462<BR>
463<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> Unused variables
464</H3>
465
466<P>
467The SystemTap translator removes unused variables. Global variable
468that are never written or read are discarded. Every local variables
469where the variable is only written but never read are also
470discarded. This optimization prunes unused variables defined
471in the probe aliases, but never used in the probe handler.
472If desired, this optimization can disabled with the <SPAN CLASS="texttt">-u</SPAN> option.
473
474<P>
475
476<H2><A ID="SECTION00044000000000000000"></A><A ID="sub:Auxiliary-functions"></A>
477<A NAME="203"></A>
478<BR>
479<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN> Auxiliary functions
480</H2>
481General syntax:
482
483<P>
484
485<DL COMPACT>
486<DT>
487<DD><PRE>
488function &lt;name&gt;[:&lt;type&gt;] ( &lt;arg1&gt;[:&lt;type&gt;], ... )[:&lt;priority&gt;] { &lt;stmts&gt; }
489</PRE>
490</DD>
491</DL>SystemTap scripts may define subroutines to factor out common work. Functions
492may take any number of scalar arguments, and must return a single scalar
493value. Scalars in this context are integers or strings. For more information
494on scalars, see Section&nbsp;<A HREF="#sub:Variables"><IMG ALT="[*]" SRC="crossref.png"></A> and Section&nbsp;<A HREF="5_Language_elements.html#sub:Data-types"><IMG ALT="[*]" SRC="crossref.png"></A><SPAN CLASS="texttt">.</SPAN>
495The following is an example function declaration.
496
497<P>
498
499<DL COMPACT>
500<DT>
501<DD><PRE>
502function thisfn (arg1, arg2) {
503 return arg1 + arg2
504}
505</PRE>
506</DD>
507</DL>
508<P>
509Note the general absence of type declarations, which are inferred by the
510translator. If desired, a function definition may include explicit type declarations
511for its return value, its arguments, or both. This is helpful for embedded-C
512functions. In the following example, the type inference engine need only
513infer the type of arg2, a string.
514
515<P>
516
517<DL COMPACT>
518<DT>
519<DD><PRE>
520function thatfn:string(arg1:long, arg2) {
521 return sprintf("%d%s", arg1, arg2)
522}
523</PRE>
524</DD>
525</DL>
526<P>
527Functions may call others or themselves recursively, up to a fixed nesting
528limit. See Section&nbsp;<A HREF="1_SystemTap_overview.html#sub:SystemTap-safety"><IMG ALT="[*]" SRC="crossref.png"></A>.
529
530<P>
531Functions may be marked private using the private keyword to limit their scope
532to the tapset or user script file they are defined in. An example definition of
533a private function follows:
534
535<P>
536
537<DL COMPACT>
538<DT>
539<DD><PRE>
540private function three:long () { return 3 }
541</PRE>
542</DD>
543</DL>
544<P>
545Functions terminating without reaching an explicit return statement will
546return an implicit 0 or <code>""</code>, determined by type inference.
547
548<P>
549Functions may be overloaded during both runtime and compile time.
550
551<P>
552Runtime overloading allows the executed function to be selected while the
553module is running based on runtime conditions and is achieved using the
554"next" statement in script functions and <SPAN CLASS="texttt">STAP_NEXT</SPAN> macro for embedded-C
555functions. For example,
556
557<P>
558
559<DL COMPACT>
560<DT>
561<DD><PRE>
562function f() { if (condition) next; print("first function") }
563function f() %{ STAP_NEXT; print("second function") %}
564function f() { print("third function") }
565</PRE>
566</DD>
567</DL>
568<P>
569During a functioncall f(), the execution will transfer to the third function
570if condition evaluates to true and print "third function". Note that the second
571function is unconditionally nexted.
572
573<P>
574Parameter overloading allows the function to be executed to be selected
575at compile time based on the number of arguments provided to the
576functioncall. For example,
577
578<P>
579
580<DL COMPACT>
581<DT>
582<DD><PRE>
583function g() { print("first function") }
584function g(x) { print("second function") }
585g() -&gt; "first function"
586g(1) -&gt; "second function"
587</PRE>
588</DD>
589</DL>
590<P>
591Note that runtime overloading does not occur in the above example, as exactly
592one function will be resolved for the functioncall. The use of a next statement
593inside a function while no more overloads remain will trigger a runtime exception
594Runtime overloading will only occur if the functions have the same arity,
595functions with the same name but different number of parameters are completely
596unrelated.
597
598<P>
599Execution order is determined by a priority value which may be specified.
600If no explicit priority is specified, user script functions are given a
601higher priority than library functions. User script functions and library
602functions are assigned a default priority value of 0 and 1 respectively.
603Functions with the same priority are executed in declaration order. For example,
604
605<P>
606
607<DL COMPACT>
608<DT>
609<DD><PRE>
610function f():3 { if (condition) next; print("first function") }
611function f():1 { if (condition) next; print("second function") }
612function f():2 { print("third function") }
613</PRE>
614</DD>
615</DL>
616<P>
617
618<H2><A ID="SECTION00045000000000000000"></A><A ID="sub:Embedded-C"></A>
619<A NAME="238"></A>
620<BR>
621<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN> Embedded C
622</H2>
623SystemTap supports a <SPAN CLASS="textit">guru<A NAME="239"></A> mode</SPAN> where script
624safety features such as code and data memory reference protection are
625removed. Guru mode is set by passing the <SPAN CLASS="textbf">-g</SPAN> option to the
626stap command. When in guru mode, the translator accepts C code
627enclosed between &ldquo;%{&rdquo; and &ldquo;%}&rdquo; markers in the top level of
628the script file. The embedded C code is transcribed verbatim, without
629analysis, in sequence, into the top level of the generated C
630code. Thus, guru mode may be useful for adding #include instructions
631at the top level of the generated module, or providing auxiliary
632definitions for use by other embedded code.
633
634<P>
635When in guru mode, embedded C code blocks are also allowed as the body
636of a SystemTap function (as described in
637Section&nbsp;<A HREF="#sub:Embedded-C-Functions"><IMG ALT="[*]" SRC="crossref.png"></A>), and in place of any SystemTap
638expression. In the latter case, the code block must contain a valid
639expression according to C syntax.
640
641<P>
642Here is an example of the various permitted methods of embedded C code inclusion:
643
644<P>
645
646<DL COMPACT>
647<DT>
648<DD><PRE>
649%{
650#include &lt;linux/in.h&gt;
651#include &lt;linux/ip.h&gt;
652%} /* &lt;-- top level */
653
654/* Reads the char value stored at a given address: */
655function __read_char:long(addr:long) %{ /* pure */
656 STAP_RETURN(kderef(sizeof(char), STAP_ARG_addr));
657 CATCH_DEREF_FAULT ();
658%} /* &lt;-- function body */
659
660/* Determines whether an IP packet is TCP, based on the iphdr: */
661function is_tcp_packet:long(iphdr) {
662 protocol = @cast(iphdr, "iphdr")-&gt;protocol
663 return (protocol == %{ IPPROTO_TCP %}) /* &lt;-- expression */
664}
665</PRE>
666</DD>
667</DL>
668<P>
669
670<H2><A ID="SECTION00046000000000000000"></A><A ID="sub:Embedded-C-Functions"></A>
671<BR>
672<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">6</SPAN> Embedded C functions
673</H2>
674
675<P>
676General syntax:
677
678<P>
679
680<DL COMPACT>
681<DT>
682<DD><PRE>
683function &lt;name&gt;:&lt;type&gt; ( &lt;arg1&gt;:&lt;type&gt;, ... )[:&lt;priority&gt;] %{ &lt;C_stmts&gt; %}
684</PRE>
685</DD>
686</DL>Embedded C code is permitted in a function body.
687In that case, the script language
688body is replaced entirely by a piece of C code enclosed between
689&ldquo;%{&rdquo; and &ldquo;%}&rdquo; markers.
690The enclosed code may do anything reasonable and safe as allowed
691by the C parser.
692
693<P>
694There are a number of undocumented but complex safety constraints on concurrency,
695resource consumption and runtime limits that are applied to code written
696in the SystemTap language. These constraints are not applied to embedded
697C code, so use embedded C code with extreme caution. Be especially
698careful when dereferencing pointers. Use the kread() macro to dereference
699any pointers that could potentially be invalid or dangerous. If you are unsure,
700err on the side of caution and use kread(). The kread() macro is one of the
701safety mechanisms used in code generated by embedded C. It protects against
702pointer accesses that could crash the system.
703
704<P>
705For example, to access the pointer chain <SPAN CLASS="texttt">name = skb-&gt;dev-&gt;name</SPAN> in
706embedded C, use the following code.
707
708<P>
709
710<DL COMPACT>
711<DT>
712<DD><PRE>
713struct net_device *dev;
714char *name;
715dev = kread(&amp;(skb-&gt;dev));
716name = kread(&amp;(dev-&gt;name));
717</PRE>
718</DD>
719</DL>
720<P>
721The memory locations reserved for input and output values are provided
722to a function using macros named
723<SPAN CLASS="texttt">STAP_ARG_foo</SPAN><A NAME="261"></A> (for arguments named
724<SPAN CLASS="texttt">foo</SPAN>) and <SPAN CLASS="texttt">STAP_RETVALUE</SPAN><A NAME="264"></A>.
725Errors may be signalled with <SPAN CLASS="texttt">STAP_ERROR</SPAN>. Output may be written
726with <SPAN CLASS="texttt">STAP_PRINTF</SPAN>. The function may return early with <SPAN CLASS="texttt">STAP_RETURN</SPAN>. Here are some examples:
727
728<P>
729
730<DL COMPACT>
731<DT>
732<DD><PRE>
733function integer_ops:long (val) %{
734 STAP_PRINTF("%d\n", STAP_ARG_val);
735 STAP_RETVALUE = STAP_ARG_val + 1;
736 if (STAP_RETVALUE == 4)
737 STAP_ERROR("wrong guess: %d", (int) STAP_RETVALUE);
738 if (STAP_RETVALUE == 3)
739 STAP_RETURN(0);
740 STAP_RETVALUE ++;
741%}
742function string_ops:string (val) %{
743 strlcpy (STAP_RETVALUE, STAP_ARG_val, MAXSTRINGLEN);
744 strlcat (STAP_RETVALUE, "one", MAXSTRINGLEN);
745 if (strcmp (STAP_RETVALUE, "three-two-one"))
746 STAP_RETURN("parameter should be three-two-");
747%}
748function no_ops () %{
749 STAP_RETURN(); /* function inferred with no return value */
750%}
751</PRE>
752</DD>
753</DL>
754<P>
755The function argument and return value types should be stated if the
756translator cannot infer them from usage. The translator does not
757analyze the embedded C code within the function.
758
759<P>
760You should examine C code generated for ordinary script language
761functions to write compatible embedded-C. Usually, all SystemTap
762functions and probes run with interrupts disabled, thus you cannot
763call functions that might sleep within the embedded C.
764
765<P>
766
767<H2><A ID="SECTION00047000000000000000">
768<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">7</SPAN> Embedded C pragma comments</A>
769</H2>
770
771<P>
772Embedded C blocks may contain various markers to assert optimization
773and safety properties.
774
775<P>
776
777<UL>
778<LI><code>/* pure */</code> means that the C code has no side effects and
779 may be elided entirely if its value is not used by script code.
780</LI>
781<LI><code>/* stable */</code> means that the C code always has the same value
782 (in any given probe handler invocation), so repeated calls may be
783 automatically replaced by memoized values. Such functions must take
784 no parameters, and also be <code>/* pure */</code>.
785</LI>
786<LI><code>/* unprivileged */</code> means that the C code is so safe that
787 even unprivileged users are permitted to use it. (This is useful, in
788 particular, to define an embedded-C function inside a tapset that
789 may be used by unprivileged code.)
790</LI>
791<LI><code>/* myproc-unprivileged */</code> means that the C code is so
792 safe that even unprivileged users are permitted to use it, provided
793 that the target of the current probe is within the user's own
794 process.
795</LI>
796<LI><code>/* guru */</code> means that the C code is so unsafe that a
797 systemtap user must specify <code>-g</code> (guru mode) to use this, even
798 if the C code is being exported from a tapset.
799</LI>
800<LI><code>/* unmangled */</code>, used in an embedded-C function, means
801 that the legacy (pre-1.8) argument access syntax should be made
802 available inside the function. Hence, in addition to
803 <code>STAP_ARG_foo</code> and <code>STAP_RETVALUE</code> one can use
804 <code>THIS-&gt;foo</code> and <code>THIS-&gt;__retvalue</code> respectively inside the
805 function. This is useful for quickly migrating code written for
806 SystemTap version 1.7 and earlier.
807</LI>
808<LI><code>/* unmodified-fnargs */</code> in an embedded-C function, means
809 that the function arguments are not modified inside the function body.
810</LI>
811<LI><code>/* string */</code> in embedded-C expressions only, means that
812 the expression has <code>const char *</code> type and should be treated as
813 a string value, instead of the default long numeric.
814</LI>
815</UL>
816
817<P>
818
819<H2><A ID="SECTION00048000000000000000">
820<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">8</SPAN> Accessing script level global variables</A>
821</H2>
822
823<P>
824Script level global variables may be accessed in embedded-C functions and
825blocks. To read or write the global variable <SPAN CLASS="textbf">var</SPAN>, the
826<code>/* pragma:read:var */</code> or <code>/* pragma:write:var */</code>
827marker must be first placed in the embedded-C function or block. This provides
828the macros <code>STAP_GLOBAL_GET_*</code> and <code>STAP_GLOBAL_SET_*</code>
829macros to allow reading and writing, respectively. For example:
830
831<DL COMPACT>
832<DT>
833<DD><PRE>
834global var
835global var2[100]
836function increment() %{
837 /* pragma:read:var */ /* pragma:write:var */
838 /* pragma:read:var2 */ /* pragma:write:var2 */
839 STAP_GLOBAL_SET_var(STAP_GLOBAL_GET_var()+1); //var++
840 STAP_GLOBAL_SET_var2(1, 1, STAP_GLOBAL_GET_var2(1, 1)+1); //var2[1,1]++
841%}
842</PRE>
843</DD>
844</DL>Variables may be read and set in both embedded-C functions and expressions.
845Strings returned from embedded-C code are decayed to pointers. Variables must
846also be assigned at script level to allow for type inference. Map assignment
847does not return the value written, so chaining does not work.
848
849<P>
850
851<DIV CLASS="navigation"><HR>
852<!--Navigation Panel-->
853<A
854 HREF="4_Probe_points.html">
855<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
856<A
857 HREF="langref.html">
858<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
859<A
860 HREF="2_Types_SystemTap_scripts.html">
861<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
862<A ID="tex2html262"
863 HREF="Contents.html">
864<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
865<A ID="tex2html264"
866 HREF="Index.html">
867<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
868<BR>
869<B> Next:</B> <A
870 HREF="4_Probe_points.html">4 Probe points</A>
871<B> Up:</B> <A
872 HREF="langref.html">SystemTap Language Reference</A>
873<B> Previous:</B> <A
874 HREF="2_Types_SystemTap_scripts.html">2 Types of SystemTap</A>
875 &nbsp; <B> <A ID="tex2html263"
876 HREF="Contents.html">Contents</A></B>
877 &nbsp; <B> <A ID="tex2html265"
878 HREF="Index.html">Index</A></B> </DIV>
879<!--End of Navigation Panel-->
880
881</BODY>
882</HTML>
diff --git a/langref/4_Probe_points.html b/langref/4_Probe_points.html
deleted file mode 100644
index da73e914..00000000
--- a/langref/4_Probe_points.html
+++ /dev/null
@@ -1,1516 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>4 Probe points</TITLE>
7<META NAME="description" CONTENT="4 Probe points">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="5_Language_elements.html">
19<LINK REL="previous" HREF="3_Components_SystemTap_scri.html">
20<LINK REL="next" HREF="5_Language_elements.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="5_Language_elements.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="3_Components_SystemTap_scri.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html280"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html282"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="5_Language_elements.html">5 Language elements</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="3_Components_SystemTap_scri.html">3 Components of a</A>
48 &nbsp; <B> <A ID="tex2html281"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html283"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html284"
60 HREF="4_Probe_points.html#SECTION00051000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> General syntax</A>
61<UL>
62<LI><A ID="tex2html285"
63 HREF="4_Probe_points.html#SECTION00051100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN> Prefixes</A>
64<LI><A ID="tex2html286"
65 HREF="4_Probe_points.html#SECTION00051200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN> Suffixes</A>
66<LI><A ID="tex2html287"
67 HREF="4_Probe_points.html#SECTION00051300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN> Wildcarded file names, function names</A>
68<LI><A ID="tex2html288"
69 HREF="4_Probe_points.html#SECTION00051400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN> Optional probe points</A>
70<LI><A ID="tex2html289"
71 HREF="4_Probe_points.html#SECTION00051500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN> Brace expansion</A>
72</UL>
73<BR>
74<LI><A ID="tex2html290"
75 HREF="4_Probe_points.html#SECTION00052000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> Built-in probe point types (DWARF probes)</A>
76<UL>
77<LI><A ID="tex2html291"
78 HREF="4_Probe_points.html#SECTION00052100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> kernel.function, module().function</A>
79<LI><A ID="tex2html292"
80 HREF="4_Probe_points.html#SECTION00052200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> kernel.statement, module().statement</A>
81</UL>
82<BR>
83<LI><A ID="tex2html293"
84 HREF="4_Probe_points.html#SECTION00053000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN> Function return probes</A>
85<LI><A ID="tex2html294"
86 HREF="4_Probe_points.html#SECTION00054000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">4</SPAN> DWARF-less probing</A>
87<LI><A ID="tex2html295"
88 HREF="4_Probe_points.html#SECTION00055000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN> Userspace probing</A>
89<UL>
90<LI><A ID="tex2html296"
91 HREF="4_Probe_points.html#SECTION00055100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN> Begin/end variants</A>
92<LI><A ID="tex2html297"
93 HREF="4_Probe_points.html#SECTION00055200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN> Syscall variants</A>
94<LI><A ID="tex2html298"
95 HREF="4_Probe_points.html#SECTION00055300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN> Function/statement variants</A>
96<LI><A ID="tex2html299"
97 HREF="4_Probe_points.html#SECTION00055400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN> Absolute variant</A>
98<LI><A ID="tex2html300"
99 HREF="4_Probe_points.html#SECTION00055500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN> Process probe paths</A>
100<LI><A ID="tex2html301"
101 HREF="4_Probe_points.html#SECTION00055600000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN> Target process mode</A>
102<LI><A ID="tex2html302"
103 HREF="4_Probe_points.html#SECTION00055700000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN> Instruction probes</A>
104<LI><A ID="tex2html303"
105 HREF="4_Probe_points.html#SECTION00055800000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN> Static userspace probing</A>
106</UL>
107<BR>
108<LI><A ID="tex2html304"
109 HREF="4_Probe_points.html#SECTION00056000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">6</SPAN> Java probes</A>
110<LI><A ID="tex2html305"
111 HREF="4_Probe_points.html#SECTION00057000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">7</SPAN> PROCFS probes</A>
112<LI><A ID="tex2html306"
113 HREF="4_Probe_points.html#SECTION00058000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">8</SPAN> Marker probes</A>
114<LI><A ID="tex2html307"
115 HREF="4_Probe_points.html#SECTION00059000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">9</SPAN> Tracepoints</A>
116<LI><A ID="tex2html308"
117 HREF="4_Probe_points.html#SECTION000510000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">10</SPAN> Syscall probes</A>
118<LI><A ID="tex2html309"
119 HREF="4_Probe_points.html#SECTION000511000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">11</SPAN> Timer probes</A>
120<LI><A ID="tex2html310"
121 HREF="4_Probe_points.html#SECTION000512000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN> Special probe points</A>
122<UL>
123<LI><A ID="tex2html311"
124 HREF="4_Probe_points.html#SECTION000512100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">1</SPAN> begin</A>
125<LI><A ID="tex2html312"
126 HREF="4_Probe_points.html#SECTION000512200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">2</SPAN> end</A>
127<LI><A ID="tex2html313"
128 HREF="4_Probe_points.html#SECTION000512300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">3</SPAN> error</A>
129<LI><A ID="tex2html314"
130 HREF="4_Probe_points.html#SECTION000512400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">4</SPAN> begin, end, and error probe sequence</A>
131<LI><A ID="tex2html315"
132 HREF="4_Probe_points.html#SECTION000512500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">5</SPAN> never</A>
133</UL></UL>
134<!--End of Table of Child-Links-->
135<HR>
136
137<H1><A ID="SECTION00050000000000000000"></A><A ID="sec:Probe-Points"></A>
138<A NAME="282"></A>
139<BR>
140<SPAN CLASS="arabic">4</SPAN> Probe points
141</H1>
142
143<H2><A ID="SECTION00051000000000000000"></A>
144<A NAME="284"></A>
145<BR>
146<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> General syntax
147</H2>
148The general probe point syntax is a dotted-symbol sequence. This divides
149the event namespace into parts, analogous to the style of the Domain Name
150System. Each component identifier is parameterized by a string or number
151literal, with a syntax analogous to a function call.
152
153<P>
154The following are all syntactically valid probe points.
155
156<P>
157
158<DL COMPACT>
159<DT>
160<DD><PRE>
161kernel.function("foo")
162kernel.function("foo").return
163module{"ext3"}.function("ext3_*")
164kernel.function("no_such_function") ?
165syscall.*
166end
167timer.ms(5000)
168</PRE>
169</DD>
170</DL>
171<P>
172Probes may be broadly classified into <SPAN CLASS="textit">synchronous</SPAN><A NAME="290"></A>
173or <SPAN CLASS="textit">asynchronous</SPAN>.<A NAME="292"></A> A synchronous event occurs when
174any processor executes an instruction matched by the specification. This
175gives these probes a reference point (instruction address) from which more
176contextual data may be available. Other families of probe points refer to
177asynchronous events such as timers, where no fixed reference point is related.
178Each probe point specification may match multiple locations, such as by using
179wildcards or aliases, and all are probed. A probe declaration may contain
180several specifications separated by commas, which are all probed.
181
182<P>
183
184<H3><A ID="SECTION00051100000000000000"></A>
185<A NAME="294"></A>
186<BR>
187<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN> Prefixes
188</H3>
189Prefixes specify the probe target, such as <SPAN CLASS="textbf">kernel</SPAN>, <SPAN CLASS="textbf">module</SPAN>,
190<SPAN CLASS="textbf">timer</SPAN>, and so on.
191
192<P>
193
194<H3><A ID="SECTION00051200000000000000"></A>
195<A NAME="299"></A>
196<BR>
197<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN> Suffixes
198</H3>
199Suffixes further qualify the point to probe, such as <SPAN CLASS="textbf">.return</SPAN> for the
200exit point of a probed function. The absence of a suffix implies the function
201entry point.
202
203<P>
204
205<H3><A ID="SECTION00051300000000000000"></A>
206<A NAME="302"></A>
207<BR>
208<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN> Wildcarded file names, function names
209</H3>
210A component may include an asterisk (*) character, which expands to other
211matching probe points. An example follows.
212
213<P>
214
215<DL COMPACT>
216<DT>
217<DD><PRE>
218kernel.syscall.*
219kernel.function("sys_*)
220</PRE>
221</DD>
222</DL>
223<P>
224
225<H3><A ID="SECTION00051400000000000000"></A><A ID="sub:Optional-probe-points"></A>
226<A NAME="309"></A>
227<BR>
228<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN> Optional probe points
229</H3>
230A probe point may be followed by a question mark (?) character, to indicate
231that it is optional, and that no error should result if it fails to expand.
232This effect passes down through all levels of alias or wildcard expansion.
233
234<P>
235The following is the general syntax.
236
237<P>
238
239<DL COMPACT>
240<DT>
241<DD><PRE>
242kernel.function("no_such_function") ?
243</PRE>
244</DD>
245</DL>
246<P>
247
248<H3><A ID="SECTION00051500000000000000"></A>
249<A NAME="315"></A>
250<BR>
251<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN> Brace expansion
252</H3>
253Brace expansion is a mechanism which allows a list of probe points to be
254generated. It is very similar to shell expansion. A component may be surrounded
255by a pair of curly braces to indicate that the comma-separated sequence of
256one or more subcomponents will each constitute a new probe point. The braces
257may be arbitrarily nested. The ordering of expanded results is based on
258product order.
259
260<P>
261The question mark (?), exclamation mark (!) indicators and probe point conditions
262may not be placed in any expansions that are before the last component.
263
264<P>
265The following is an example of brace expansion.
266
267<P>
268
269<DL COMPACT>
270<DT>
271<DD><PRE>
272syscall.{write,read}
273# Expands to
274syscall.write, syscall.read
275
276{kernel,module("nfs")}.function("nfs*")!
277# Expands to
278kernel.function("nfs*")!, module("nfs").function("nfs*")!
279</PRE>
280</DD>
281</DL>
282<P>
283
284<H2><A ID="SECTION00052000000000000000"></A>
285<A NAME="321"></A>
286<A NAME="322"></A>
287<A ID="dwarfprobes"></A>
288<BR>
289<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> Built-in probe point types (DWARF probes)
290</H2>
291This family of probe points uses symbolic debugging information for the target
292kernel or module, as may be found in executables that have not
293been stripped, or in the separate <SPAN CLASS="textbf">debuginfo</SPAN> packages. They allow
294logical placement of probes into the execution path of the target
295by specifying a set of points in the source or object code. When a matching
296statement executes on any processor, the probe handler is run in that context.
297
298<P>
299Points in a kernel are identified by module, source file, line number, function
300name or some combination of these.
301
302<P>
303Here is a list of probe point specifications currently supported:
304
305<P>
306
307<DL COMPACT>
308<DT>
309<DD><PRE>
310kernel.function(PATTERN)
311kernel.function(PATTERN).call
312kernel.function(PATTERN).return
313kernel.function(PATTERN).return.maxactive(VALUE)
314kernel.function(PATTERN).inline
315kernel.function(PATTERN).label(LPATTERN)
316module(MPATTERN).function(PATTERN)
317module(MPATTERN).function(PATTERN).call
318module(MPATTERN).function(PATTERN).return.maxactive(VALUE)
319module(MPATTERN).function(PATTERN).inline
320kernel.statement(PATTERN)
321kernel.statement(ADDRESS).absolute
322module(MPATTERN).statement(PATTERN)
323</PRE>
324</DD>
325</DL>
326<P>
327The <SPAN CLASS="textbf">.function</SPAN> variant places a probe near the beginning of the named
328function, so that parameters are available as context variables.
329
330<P>
331The <SPAN CLASS="textbf">.return</SPAN> variant places a probe at the moment of return from the named
332function, so the return value is available as the $return context variable.
333The entry parameters are also available, though the function may have changed
334their values. Return probes may be further qualified with <SPAN CLASS="textbf">.maxactive</SPAN>,
335which specifies how many instances of the specified function can be probed simultaneously.
336You can leave off <SPAN CLASS="textbf">.maxactive</SPAN> in most cases, as the default
337(<SPAN CLASS="textbf">KRETACTIVE</SPAN>) should be sufficient.
338However, if you notice an excessive number of skipped probes, try setting <SPAN CLASS="textbf">.maxactive</SPAN>
339to incrementally higher values to see if the number of skipped probes decreases.
340
341<P>
342The <SPAN CLASS="textbf">.inline</SPAN> modifier for <SPAN CLASS="textbf">.function</SPAN> filters the results to include only
343instances of inlined functions. The <SPAN CLASS="textbf">.call</SPAN> modifier selects the opposite subset.
344The <SPAN CLASS="textbf">.exported</SPAN> modifier filters the results to include only exported functions.
345Inline functions do not have an identifiable return point, so <SPAN CLASS="textbf">.return</SPAN>
346is not supported on <SPAN CLASS="textbf">.inline</SPAN> probes.
347
348<P>
349The <SPAN CLASS="textbf">.statement</SPAN> variant places a probe at the exact spot, exposing those local
350variables that are visible there.
351
352<P>
353In the above probe descriptions, MPATTERN stands for a string literal
354that identifies the loaded kernel module of interest and LPATTERN
355stands for a source program label. Both MPATTERN and LPATTERN may
356include asterisk (*), square brackets &#34;[]&#34;, and
357question mark (?) wildcards.
358
359<P>
360PATTERN stands for a string literal that identifies a point in the program.
361It is composed of three parts:
362
363<P>
364
365<OL>
366<LI>The first part is the name of a function, as would appear in the nm program's
367output. This part may use the asterisk and question mark wildcard operators
368to match multiple names.
369</LI>
370<LI>The second part is optional, and begins with the ampersand (@) character.
371It is followed by the path to the source file containing the function,
372which may include a wildcard pattern, such as mm/slab*.
373In most cases, the path should be relative to the top of the
374linux source directory, although an absolute path may be necessary for some kernels.
375If a relative pathname doesn't work, try absolute.
376</LI>
377<LI>The third part is optional if the file name part was given. It identifies
378the line number in the source file, preceded by a &ldquo;:&rdquo; or &ldquo;+&rdquo;.
379The line number is assumed to be an
380absolute line number if preceded by a &ldquo;:&rdquo;, or relative to the entry of
381the function if preceded by a &ldquo;+&rdquo;.
382All the lines in the function can be matched with &ldquo;:*&rdquo;.
383A range of lines x through y can be matched with &ldquo;:x-y&rdquo;.
384
385<P>
386</LI>
387</OL>
388Alternately, specify PATTERN as a numeric constant to indicate a relative
389module address or an absolute kernel address.
390
391<P>
392Some of the source-level variables, such as function parameters, locals,
393or globals visible in the compilation unit, are visible to probe handlers.
394Refer to these variables by prefixing their name with a dollar sign within
395the scripts. In addition, a special syntax allows limited traversal of
396structures, pointers, arrays, taking the address of a variable or pretty
397printing a whole structure.
398
399<P>
400<SPAN CLASS="texttt">$var</SPAN> refers to an in-scope variable var. If it is a type similar
401to an integer, it will be cast to a 64-bit integer for script use. Pointers
402similar to a string (char *) are copied to SystemTap string values by the
403<SPAN CLASS="texttt">kernel_string()</SPAN> or <SPAN CLASS="texttt">user_string()</SPAN> functions.
404
405<P>
406<SPAN CLASS="texttt">@var("varname")</SPAN> is an alternative syntax for <SPAN CLASS="texttt">$varname</SPAN>.
407It can also be used to access global variables in a particular compile
408unit (CU). <SPAN CLASS="texttt">@var("varname@src/file.c")</SPAN> refers to the global
409(either file local or external) variable varname defined when the file
410src/file.c was compiled. The CU in which the variable is resolved is
411the first CU in the module of the probe point which matches the given
412file name at the end and has the shortest file name path (e.g. given
413<SPAN CLASS="texttt">@var("foo@bar/baz.c")</SPAN> and CUs with file name paths
414<SPAN CLASS="texttt">src/sub/module/bar/baz.c</SPAN> and <SPAN CLASS="texttt">src/bar/baz.c</SPAN> the second
415CU will be chosen to resolve <SPAN CLASS="texttt">foo</SPAN>).
416
417<P>
418<SPAN CLASS="texttt">$var-&gt;field</SPAN> or <SPAN CLASS="texttt">@var("var@file.c")-&gt;field</SPAN> traverses a
419structure's field. The indirection operator may be repeated to follow
420additional levels of pointers.
421
422<P>
423<SPAN CLASS="texttt">$var[N]</SPAN> or <SPAN CLASS="texttt">@var("var@file.c")[N]</SPAN> indexes into an
424array. The index is given with a literal number.
425
426<P>
427<SPAN CLASS="texttt">&amp;$var</SPAN> or <SPAN CLASS="texttt">&amp;@var("var@file.c")</SPAN> provides the address of
428a variable as a long. It can also be used in combination with field access
429or array indexing to provide the address of a particular field or an
430element in an array with <SPAN CLASS="texttt">&amp;var-&gt;field</SPAN>,
431<SPAN CLASS="texttt">&amp;@var("var@file.c")[N]</SPAN> or a combination of those accessors.
432
433<P>
434Using a single <SPAN CLASS="texttt">$</SPAN> or a double <SPAN CLASS="texttt">$$</SPAN> suffix provides a
435swallow or deep string representation of the variable data type. Using
436a single <SPAN CLASS="texttt">$</SPAN>, as in <SPAN CLASS="texttt">$var$</SPAN>, will provide a string that
437only includes the values of all basic type values of fields of the variable
438structure type but not any nested complex type values (which will be
439represented with <SPAN CLASS="texttt">{...}</SPAN>). Using a double <SPAN CLASS="texttt">$$</SPAN>,
440as in <SPAN CLASS="texttt">@var("var")$$</SPAN> will provide a string that also includes
441all values of nested data types.
442
443<P>
444<SPAN CLASS="texttt">$$vars</SPAN> expands to a character string that is equivalent to
445<SPAN CLASS="texttt">sprintf("parm1=%x ... parmN=%x var1=%x ... varN=%x", $parm1, ..., $parmN,
446$var1, ..., $varN)</SPAN>
447
448<P>
449<SPAN CLASS="texttt">$$locals</SPAN> expands to a character string that is equivalent to
450<SPAN CLASS="texttt">sprintf("var1=%x ... varN=%x", $var1, ..., $varN)</SPAN>
451
452<P>
453<SPAN CLASS="texttt">$$parms</SPAN> expands to a character string that is equivalent to
454<SPAN CLASS="texttt">sprintf("parm1=%x ... parmN=%x", $parm1, ..., $parmN)</SPAN>
455
456<P>
457
458<H3><A ID="SECTION00052100000000000000"></A>
459<A NAME="382"></A>
460<A NAME="383"></A>
461<BR>
462<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> kernel.function, module().function
463</H3>
464The <SPAN CLASS="textbf">.function</SPAN> variant places a probe near the beginning of the named function,
465so that parameters are available as context variables.
466
467<P>
468General syntax:
469
470<P>
471
472<DL COMPACT>
473<DT>
474<DD><PRE>
475kernel.function("func[@file]")
476module("modname").function("func[@file]")
477</PRE>
478</DD>
479</DL>Examples:
480
481<P>
482
483<DL COMPACT>
484<DT>
485<DD><PRE>
486# Refers to all kernel functions with "init" or "exit"
487# in the name:
488kernel.function("*init*"), kernel.function("*exit*")
489
490# Refers to any functions within the "kernel/time.c"
491# file that span line 240:
492kernel.function("*@kernel/time.c:240")
493
494# Refers to all functions in the ext3 module:
495module("ext3").function("*")
496</PRE>
497</DD>
498</DL>
499<P>
500
501<H3><A ID="SECTION00052200000000000000"></A>
502<A NAME="394"></A>
503<A NAME="395"></A>
504<BR>
505<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> kernel.statement, module().statement
506</H3>
507The <SPAN CLASS="textbf">.statement</SPAN> variant places a probe at the exact spot, exposing those local
508variables that are visible there.
509
510<P>
511General syntax:
512
513<P>
514
515<DL COMPACT>
516<DT>
517<DD><PRE>
518kernel.statement("func@file:linenumber")
519module("modname").statement("func@file:linenumber")
520</PRE>
521</DD>
522</DL>Example:
523
524<P>
525
526<DL COMPACT>
527<DT>
528<DD><PRE>
529# Refers to the statement at line 296 within the
530# kernel/time.c file:
531kernel.statement("*@kernel/time.c:296")
532# Refers to the statement at line bio_init+3 within the fs/bio.c file:
533kernel.statement("bio_init@fs/bio.c+3")
534</PRE>
535</DD>
536</DL>
537<P>
538
539<H2><A ID="SECTION00053000000000000000"></A>
540<A NAME="406"></A>
541<BR>
542<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN> Function return probes
543</H2>
544The <SPAN CLASS="texttt">.return</SPAN> variant places a probe at the moment of return from
545the named function, so that the return value is available as the $return
546context variable. The entry parameters are also accessible in the context
547of the return probe, though their values may have been changed by the function.
548Inline functions do not have an identifiable return point, so <SPAN CLASS="texttt">.return</SPAN>
549is not supported on <SPAN CLASS="texttt">.inline</SPAN> probes.
550
551<P>
552
553<H2><A ID="SECTION00054000000000000000"></A>
554<A NAME="411"></A>
555<BR>
556<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">4</SPAN> DWARF-less probing
557</H2>
558
559<P>
560In the absence of debugging information, you can still use the
561<SPAN CLASS="textit">kprobe</SPAN> family of probes to examine the entry and exit points of
562kernel and module functions. You cannot look up the arguments or local
563variables of a function using these probes. However, you can access
564the parameters by following this procedure:
565
566<P>
567When you're stopped at the entry to a function, you can refer to the
568function's arguments by number. For example, when probing the function
569declared:
570
571<P>
572
573<DL COMPACT>
574<DT>
575<DD><PRE>
576asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t
577count)
578</PRE>
579</DD>
580</DL>
581<P>
582You can obtain the values of <SPAN CLASS="texttt">fd</SPAN>, <SPAN CLASS="texttt">buf</SPAN>, and
583<SPAN CLASS="texttt">count</SPAN>, respectively, as <SPAN CLASS="texttt">uint_arg(1)</SPAN>,
584<SPAN CLASS="texttt">pointer_arg(2)</SPAN>, and <SPAN CLASS="texttt">ulong_arg(3)</SPAN>. In this case, your
585probe code must first call <SPAN CLASS="texttt">asmlinkage()</SPAN>, because on some
586architectures the asmlinkage attribute affects how the function's
587arguments are passed.
588
589<P>
590When you're in a return probe, <SPAN CLASS="texttt">$return</SPAN> isn't supported
591without DWARF, but you can call <SPAN CLASS="texttt">returnval()</SPAN> to get the value
592of the register in which the function value is typically returned, or
593call <SPAN CLASS="texttt">returnstr()</SPAN> to get a string version of that value.
594
595<P>
596And at any code probepoint, you can call
597<SPAN CLASS="texttt">register("regname")</SPAN> to get the value of the specified CPU
598register when the probe point was hit.
599<SPAN CLASS="texttt">u_register("regname")</SPAN> is like <SPAN CLASS="texttt">register("regname")</SPAN>,
600but interprets the value as an unsigned integer.
601
602<P>
603SystemTap supports the following constructs:
604
605<DL COMPACT>
606<DT>
607<DD><PRE>
608kprobe.function(FUNCTION)
609kprobe.function(FUNCTION).return
610kprobe.module(NAME).function(FUNCTION)
611kprobe.module(NAME).function(FUNCTION).return
612kprobe.statement(ADDRESS).absolute
613</PRE>
614</DD>
615</DL>
616<P>
617Use <SPAN CLASS="textbf">.function</SPAN> probes for kernel functions and
618<SPAN CLASS="textbf">.module</SPAN> probes for probing functions of a specified module.
619If you do not know the absolute address of a kernel or module
620function, use <SPAN CLASS="textbf">.statement</SPAN> probes. Do not use wildcards in
621<SPAN CLASS="textit">FUNCTION</SPAN> and <SPAN CLASS="textit">MODULE</SPAN> names. Wildcards cause the probe
622to not register. Also, statement probes are available only in guru mode.
623
624<P>
625
626<H2><A ID="SECTION00055000000000000000"></A>
627<A NAME="440"></A>
628<A NAME="441"></A>
629<BR>
630<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN> Userspace probing
631</H2>
632Support for userspace probing is supported on kernels that are
633configured to include the utrace or uprobes extensions.
634
635<P>
636
637<H3><A ID="SECTION00055100000000000000"></A>
638<A ID="sec:beginendvariants"></A>
639<BR>
640<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN> Begin/end variants
641</H3>
642Constructs:
643
644<DL COMPACT>
645<DT>
646<DD><PRE>
647process.begin
648process("PATH").begin
649process(PID).begin
650
651process.thread.begin
652process("PATH").thread.begin
653process(PID).thread.begin
654
655process.end
656process("PATH").end
657process(PID).end
658
659process.thread.end
660process("PATH").thread.end
661process(PID).thread.end
662</PRE>
663</DD>
664</DL>
665<P>
666The <SPAN CLASS="texttt">.begin</SPAN> variant is called when a new process described by
667<SPAN CLASS="texttt">PID</SPAN> or <SPAN CLASS="texttt">PATH</SPAN> is created. If no <SPAN CLASS="texttt">PID</SPAN> or
668<SPAN CLASS="texttt">PATH</SPAN> argument is specified (for example
669<SPAN CLASS="texttt">process.begin</SPAN>), the probe flags any new process being
670spawned.
671
672<P>
673The <SPAN CLASS="texttt">.thread.begin</SPAN> variant is called when a new thread
674described by <SPAN CLASS="texttt">PID</SPAN> or <SPAN CLASS="texttt">PATH</SPAN> is created.
675
676<P>
677The <SPAN CLASS="texttt">.end</SPAN> variant is called when a process described by
678<SPAN CLASS="texttt">PID</SPAN> or <SPAN CLASS="texttt">PATH</SPAN> dies.
679
680<P>
681The <SPAN CLASS="texttt">.thread.end</SPAN> variant is called when a thread described by
682<SPAN CLASS="texttt">PID</SPAN> or <SPAN CLASS="texttt">PATH</SPAN> dies.
683
684<P>
685
686<H3><A ID="SECTION00055200000000000000"></A>
687<A ID="sec:syscallvariants"></A>
688<BR>
689<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN> Syscall variants
690</H3>
691Constructs:
692
693<DL COMPACT>
694<DT>
695<DD><PRE>
696process.syscall
697process("PATH").syscall
698process(PID).syscall
699
700process.syscall.return
701process("PATH").syscall.return
702process(PID).syscall.return
703</PRE>
704</DD>
705</DL>
706<P>
707The <SPAN CLASS="texttt">.syscall</SPAN> variant is called when a thread described by
708<SPAN CLASS="texttt">PID</SPAN> or <SPAN CLASS="texttt">PATH</SPAN> makes a system call. The system call
709number is available in the <SPAN CLASS="texttt">$syscall</SPAN> context variable. The
710first six arguments of the system call are available in the
711<SPAN CLASS="texttt">$argN</SPAN> parameter, for example <SPAN CLASS="texttt">$arg1</SPAN>,
712<SPAN CLASS="texttt">$arg2</SPAN>, and so on.
713
714<P>
715The <SPAN CLASS="texttt">.syscall.return</SPAN> variant is called when a thread described
716by <SPAN CLASS="texttt">PID</SPAN> or <SPAN CLASS="texttt">PATH</SPAN> returns from a system call. The
717system call number is available in the <SPAN CLASS="texttt">$syscall</SPAN> context
718variable. The return value of the system call is available in the
719<SPAN CLASS="texttt">$return</SPAN> context variable.
720
721<P>
722
723<H3><A ID="SECTION00055300000000000000"></A>
724<A ID="sec:function-statement"></A>
725<BR>
726<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN> Function/statement variants
727</H3>
728Constructs:
729
730<DL COMPACT>
731<DT>
732<DD><PRE>
733process("PATH").function("NAME")
734process("PATH").statement("*@FILE.c:123")
735process("PATH").function("*").return
736process("PATH").function("myfun").label("foo")
737</PRE>
738</DD>
739</DL>
740<P>
741Full symbolic source-level probes in userspace programs and shared
742libraries are supported. These are exactly analogous to the symbolic
743DWARF-based kernel or module probes described previously and expose
744similar contextual <SPAN CLASS="texttt">$-variables</SPAN>. See
745Section&nbsp;<A HREF="#dwarfprobes"><IMG ALT="[*]" SRC="crossref.png"></A> for more information
746
747<P>
748Here is an example of prototype symbolic userspace probing support:
749
750<DL COMPACT>
751<DT>
752<DD><PRE>
753# stap -e 'probe process("ls").function("*").call {
754 log (probefunc()." ".$$parms)
755 }' \
756 -c 'ls -l'
757</PRE>
758</DD>
759</DL>
760<P>
761To run, this script requires debugging information for the named
762program and utrace support in the kernel. If you see a "pass 4a-time"
763build failure, check that your kernel supports utrace.
764
765<P>
766
767<H3><A ID="SECTION00055400000000000000"></A>
768<A ID="sec:absolutevariant"></A>
769<BR>
770<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN> Absolute variant
771</H3>
772A non-symbolic probe point such as
773<SPAN CLASS="texttt">process(PID).statement(ADDRESS).absolute</SPAN> is analogous to
774<BR><SPAN CLASS="texttt">kernel.statement(ADDRESS).absolute</SPAN> in that both use
775raw, unverified virtual addresses and provide no <SPAN CLASS="texttt">$variables</SPAN>.
776The target <SPAN CLASS="texttt">PID</SPAN> parameter must identify a running process and
777<SPAN CLASS="texttt">ADDRESS</SPAN> must identify a valid instruction address. All
778threads of the listed process will be probed. This is a guru mode
779probe.
780
781<P>
782
783<H3><A ID="SECTION00055500000000000000"></A>
784<A ID="sec:paths"></A>
785<BR>
786<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN> Process probe paths
787</H3>
788For all process probes, <SPAN CLASS="texttt">PATH</SPAN> names refer to executables that
789are searched the same way that shells do: the explicit path specified
790if the path name begins with a slash (/) character sequence; otherwise
791<SPAN CLASS="texttt">$PATH</SPAN> is searched. For example, the following probe syntax:
792
793<DL COMPACT>
794<DT>
795<DD><PRE>
796probe process("ls").syscall {}
797probe process("./a.out").syscall {}
798</PRE>
799</DD>
800</DL>
801<P>
802works the same as:
803
804<DL COMPACT>
805<DT>
806<DD><PRE>
807probe process("/bin/ls").syscall {}
808probe process("/my/directory/a.out").syscall {}
809</PRE>
810</DD>
811</DL>
812<P>
813If a process probe is specified without a <SPAN CLASS="texttt">PID</SPAN> or
814<SPAN CLASS="texttt">PATH</SPAN> parameter, all user threads are probed. However, if
815systemtap is invoked in target process mode, process probes are
816restricted to the process hierarchy associated with the target
817process. If stap is running in <SPAN CLASS="texttt">-unprivileged</SPAN> mode, only
818processes owned by the current user are selected.
819
820<P>
821
822<H3><A ID="SECTION00055600000000000000"></A>
823<A ID="sec:targetprocessmode"></A>
824<BR>
825<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN> Target process mode
826</H3>
827Target process mode (invoked with <SPAN CLASS="texttt">stap -c CMD</SPAN> or <SPAN CLASS="texttt">-x
828 PID</SPAN>) implicitly restricts all <SPAN CLASS="texttt">process.*</SPAN> probes to the
829given child process. It does not affect <SPAN CLASS="texttt">kernel.*</SPAN> or other
830probe types. The <SPAN CLASS="texttt">CMD</SPAN> string is normally run directly, rather
831than from a &ldquo;<SPAN CLASS="texttt">/bin/sh -c</SPAN>&rdquo; sub-shell, since utrace and uprobe
832probes receive a fairly "clean" event stream. If meta-characters such
833as redirection operators are present in <SPAN CLASS="texttt">CMD</SPAN>, &ldquo;<SPAN CLASS="texttt">/bin/sh
834 -c CMD</SPAN>&rdquo; is still used, and utrace and uprobe probes will receive
835events from the shell. For example:
836
837<DL COMPACT>
838<DT>
839<DD><PRE>
840% stap -e 'probe process.syscall, process.end {
841 printf("%s %d %s\n", execname(), pid(), pp())}' \
842 -c ls
843</PRE>
844</DD>
845</DL>
846<P>
847Here is the output from this command:
848
849<DL COMPACT>
850<DT>
851<DD><PRE>
852ls 2323 process.syscall
853ls 2323 process.syscall
854ls 2323 process.end
855</PRE>
856</DD>
857</DL>
858<P>
859If <SPAN CLASS="texttt">PATH</SPAN> names a shared library, all processes that map that
860shared library can be probed. If dwarf debugging information is
861installed, try using a command with this syntax:
862
863<DL COMPACT>
864<DT>
865<DD><PRE>
866probe process("/lib64/libc-2.8.so").function("....") { ... }
867</PRE>
868</DD>
869</DL>This command probes all threads that call into that library. Typing
870&ldquo;<SPAN CLASS="texttt">stap -c CMD</SPAN>&rdquo; or &ldquo;<SPAN CLASS="texttt">stap -x PID</SPAN>&rdquo; restricts this to
871the target command and descendants only. You can use
872<SPAN CLASS="texttt">$$vars</SPAN> and others. You can provide the location of debug
873information to the stap command with the <SPAN CLASS="texttt">-d DIRECTORY</SPAN> option.
874To qualify a probe point to a location in a library required by a
875particular process try using a command with this syntax:
876
877<DL COMPACT>
878<DT>
879<DD><PRE>
880probe process("...").library("...").function("....") { ... }
881</PRE>
882</DD>
883</DL>The library name may use wildcards.
884
885<P>
886The first syntax in the following will probe the functions in the program
887linkage table of a particular process. The second syntax will also add the
888program linkage tables of libraries required by that process. .plt("...") can
889be specified to match particular plt entries.
890
891<DL COMPACT>
892<DT>
893<DD><PRE>
894probe process("...").plt { ... }
895probe process("...").plt process("...").library("...").plt { ... }
896</PRE>
897</DD>
898</DL>
899<P>
900
901<H3><A ID="SECTION00055700000000000000"></A>
902<A ID="sec:insnprobes"></A>
903<BR>
904<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN> Instruction probes
905</H3>
906Constructs:
907
908<DL COMPACT>
909<DT>
910<DD><PRE>
911process("PATH").insn
912process(PID).insn
913
914process("PATH").insn.block
915process(PID).insn.block
916</PRE>
917</DD>
918</DL>The <SPAN CLASS="texttt">process().insn</SPAN> and <SPAN CLASS="texttt">process().insn.block</SPAN> probes
919inspect the process after each instruction or block of instructions is
920executed. These probes are not implemented on all architectures. If
921they are not implemented on your system, you will receive an error
922message when the script starts.
923
924<P>
925The <SPAN CLASS="texttt">.insn</SPAN> probe is called for every single-stepped
926instruction of the process described by <SPAN CLASS="texttt">PID</SPAN> or <SPAN CLASS="texttt">PATH</SPAN>.
927
928<P>
929The <SPAN CLASS="texttt">.insn.block</SPAN> probe is called for every block-stepped
930instruction of the process described by <SPAN CLASS="texttt">PID</SPAN> or <SPAN CLASS="texttt">PATH</SPAN>.
931
932<P>
933To count the total number of instructions that a process executes,
934type a command similar to:
935
936<DL COMPACT>
937<DT>
938<DD><PRE>
939$ stap -e 'global steps; probe process("/bin/ls").insn {steps++}
940 probe end {printf("Total instructions: %d\n", steps);}' \
941 -c /bin/ls
942</PRE>
943</DD>
944</DL>
945<P>
946Using this feature will significantly slow process execution.
947
948<P>
949
950<H3><A ID="SECTION00055800000000000000"></A>
951<A ID="sec:staticuserspace"></A>
952<BR>
953<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN> Static userspace probing
954</H3>
955You can probe symbolic static instrumentation compiled into programs
956and shared libraries with the following syntax:
957
958<DL COMPACT>
959<DT>
960<DD><PRE>
961process("PATH").mark("LABEL")
962</PRE>
963</DD>
964</DL>
965<P>
966The <SPAN CLASS="texttt">.mark</SPAN> variant is called from a static probe defined in
967the application by
968<SPAN CLASS="texttt">STAP_PROBE1(handle,LABEL,arg1)</SPAN>. <SPAN CLASS="texttt">STAP_PROBE1</SPAN> is
969defined in the sdt.h file. The parameters are:
970
971<P>
972<TABLE class="PAD BORDER" style=">
973<TR><TD CLASS="LEFT">Parameter</TD>
974<TD CLASS="RIGHT">Definition</TD>
975<TD CLASS="CENTER">&nbsp;</TD>
976</TR>
977<TR><TD CLASS="LEFT"><SPAN CLASS="texttt">handle</SPAN></TD>
978<TD CLASS="RIGHT">the application handle</TD>
979<TD CLASS="CENTER">&nbsp;</TD>
980</TR>
981<TR><TD CLASS="LEFT"><SPAN CLASS="texttt">LABEL</SPAN></TD>
982<TD CLASS="RIGHT">corresponds to the <SPAN CLASS="texttt">.mark</SPAN> argument</TD>
983<TD CLASS="CENTER">&nbsp;</TD>
984</TR>
985<TR><TD CLASS="LEFT"><SPAN CLASS="texttt">arg1</SPAN></TD>
986<TD CLASS="RIGHT">the argument</TD>
987<TD CLASS="CENTER">&nbsp;</TD>
988</TR>
989</TABLE>
990
991<P>
992Use <SPAN CLASS="texttt">STAP_PROBE1</SPAN> for probes with one argument. Use
993<SPAN CLASS="texttt">STAP_PROBE2</SPAN> for probes with 2 arguments, and so on. The
994arguments of the probe are available in the context variables
995<SPAN CLASS="texttt">$arg1</SPAN>, <SPAN CLASS="texttt">$arg2</SPAN>, and so on.
996
997<P>
998As an alternative to the <SPAN CLASS="texttt">STAP_PROBE</SPAN> macros, you can use the
999dtrace script to create custom macros. The sdt.h file also provides
1000dtrace compatible markers through <SPAN CLASS="texttt">DTRACE_PROBE</SPAN> and an
1001associated python <SPAN CLASS="texttt">dtrace</SPAN> script. You can use these in builds
1002based on dtrace that need dtrace -h or -G functionality.
1003
1004<P>
1005
1006<H2><A ID="SECTION00056000000000000000"></A>
1007<A NAME="592"></A>
1008<BR>
1009<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">6</SPAN> Java probes
1010</H2>
1011Support for probing Java methods is available using Byteman as a
1012backend. Byteman is an instrumentation tool from the JBoss project
1013which systemtap can use to monitor invocations for a specific method
1014or line in a Java program.
1015
1016<P>
1017Systemtap does so by generating a Byteman script listing the probes to
1018instrument and then invoking the Byteman <SPAN CLASS="texttt">bminstall</SPAN> utility. A
1019custom option <SPAN CLASS="texttt">-D OPTION</SPAN> (see the Byteman documentation for
1020more details) can be passed to bminstall by invoking systemtap with
1021option <SPAN CLASS="texttt">-J OPTION</SPAN>. The systemtap option <SPAN CLASS="texttt">-j</SPAN> is also
1022provided as a shorthand for <SPAN CLASS="texttt">-J
1023 org.jboss.byteman.compile.to.bytecode</SPAN>.
1024
1025<P>
1026This Java instrumentation support is currently a prototype feature
1027with major limitations: Java probes attach only to one Java process at
1028a time; other Java processes beyond the first one to be observed are
1029ignored. Moreover, Java probing currently does not work across users;
1030the stap script must run (with appropriate permissions) under the same
1031user as the Java process being probed. (Thus a stap script under
1032root currently cannot probe Java methods in a non-root-user Java process.)
1033
1034<P>
1035There are four probe point variants supported by the translator:
1036
1037<DL COMPACT>
1038<DT>
1039<DD><PRE>
1040java("PNAME").class("CLASSNAME").method("PATTERN")
1041java("PNAME").class("CLASSNAME").method("PATTERN").return
1042java(PID).class("CLASSNAME").method("PATTERN")
1043java(PID).class("CLASSNAME").method("PATTERN").return
1044</PRE>
1045</DD>
1046</DL>
1047<P>
1048The first two probe points refer to Java processes by the name of the
1049Java process. The PATTERN parameter specifies the signature of the
1050Java method to probe. The signature must consist of the exact name of
1051the method, followed by a bracketed list of the types of the
1052arguments, for instance <SPAN CLASS="texttt">myMethod(int,double,Foo)</SPAN>. Wildcards
1053are not supported.
1054
1055<P>
1056The probe can be set to trigger at a specific line within the method
1057by appending a line number with colon, just as in other types of
1058probes: <SPAN CLASS="texttt">myMethod(int,double,Foo):245</SPAN>.
1059
1060<P>
1061The CLASSNAME parameter identifies the Java class the method belongs
1062to, either with or without the package qualification. By default, the
1063probe only triggers on descendants of the class that do not override
1064the method definition of the original class. However, CLASSNAME can
1065take an optional caret prefix, as in
1066<code>class("^org.my.MyClass")</code>, which specifies that the probe
1067should also trigger on all descendants of MyClass that override the
1068original method. For instance, every method with signature foo(int) in
1069program org.my.MyApp can be probed at once using
1070
1071<DL COMPACT>
1072<DT>
1073<DD><PRE>
1074java("org.my.MyApp").class("^java.lang.Object").method("foo(int)")
1075</PRE>
1076</DD>
1077</DL>
1078<P>
1079The last two probe points work analogously, but refer to Java
1080processes by PID. (PIDs for already running processes can be obtained
1081using the <SPAN CLASS="texttt">jps</SPAN> utility.)
1082
1083<P>
1084Context variables defined within java probes include <code>$provider</code>
1085(which identifies the class providing the definition of the triggered
1086method) and <code>$name</code> (which gives the signature of the method).
1087Arguments to the method can be accessed using context variables
1088<code>$arg1$</code> through <code>$arg10</code>, for up to the first 10 arguments
1089of a method.
1090
1091<P>
1092
1093<H2><A ID="SECTION00057000000000000000"></A>
1094<A NAME="610"></A>
1095<BR>
1096<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">7</SPAN> PROCFS probes
1097</H2>
1098These probe points allow procfs pseudo-files in
1099<SPAN CLASS="texttt">/proc/systemtap/<SPAN CLASS="textit">MODNAME</SPAN></SPAN> to be created, read and
1100written. Specify the name of the systemtap module as
1101<SPAN CLASS="texttt"><SPAN CLASS="textit">MODNAME</SPAN></SPAN>. There are four probe point variants
1102supported by the translator:
1103
1104<DL COMPACT>
1105<DT>
1106<DD><PRE>
1107procfs("PATH").read
1108procfs("PATH").write
1109procfs.read
1110procfs.write
1111</PRE>
1112</DD>
1113</DL>
1114<P>
1115<SPAN CLASS="texttt">PATH</SPAN> is the file name to be created, relative to
1116<SPAN CLASS="texttt">/proc/systemtap/MODNAME</SPAN>. If no <SPAN CLASS="texttt">PATH</SPAN> is specified
1117(as in the last two variants in the previous list), <SPAN CLASS="texttt">PATH</SPAN>
1118defaults to "command".
1119
1120<P>
1121When a user reads <SPAN CLASS="texttt">/proc/systemtap/MODNAME/PATH</SPAN>, the
1122corresponding procfs read probe is triggered. Assign the string data
1123to be read to a variable named <SPAN CLASS="texttt">$value</SPAN>, as follows:
1124
1125<DL COMPACT>
1126<DT>
1127<DD><PRE>
1128procfs("PATH").read { $value = "100\n" }
1129</PRE>
1130</DD>
1131</DL>
1132<P>
1133When a user writes into <SPAN CLASS="texttt">/proc/systemtap/MODNAME/PATH</SPAN>, the
1134corresponding procfs write probe is triggered. The data the user
1135wrote is available in the string variable named <SPAN CLASS="texttt">$value</SPAN>, as
1136follows:
1137
1138<DL COMPACT>
1139<DT>
1140<DD><PRE>
1141procfs("PATH").write { printf("User wrote: %s", $value) }
1142</PRE>
1143</DD>
1144</DL>
1145<P>
1146
1147<H2><A ID="SECTION00058000000000000000"></A>
1148<A NAME="634"></A>
1149<BR>
1150<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">8</SPAN> Marker probes
1151</H2>
1152This family of probe points connects to static probe markers inserted
1153into the kernel or a module. These markers are special macro calls in
1154the kernel that make probing faster and more reliable than with
1155DWARF-based probes. DWARF debugging information is not required to
1156use probe markers.
1157
1158<P>
1159Marker probe points begin with a <SPAN CLASS="texttt">kernel</SPAN> prefix which
1160identifies the source of the symbol table used for finding
1161markers. The suffix names the marker itself:
1162<SPAN CLASS="texttt">mark.("MARK")</SPAN>. The marker name string, which can contain
1163wildcard characters, is matched against the names given to the marker
1164macros when the kernel or module is compiled. Optionally, you can
1165specify <SPAN CLASS="texttt">format("FORMAT")</SPAN>. Specifying the marker format
1166string allows differentiation between two markers with the same name
1167but different marker format strings.
1168
1169<P>
1170The handler associated with a marker probe reads any optional
1171parameters specified at the macro call site named <SPAN CLASS="texttt">$arg1</SPAN>
1172through <SPAN CLASS="texttt">$argNN</SPAN>, where <SPAN CLASS="texttt">NN</SPAN> is the number of
1173parameters supplied by the macro. Number and string parameters are
1174passed in a type-safe manner.
1175
1176<P>
1177The marker format string associated with a marker is available in
1178<SPAN CLASS="texttt">$format</SPAN>. The marker name string is available in
1179<SPAN CLASS="texttt">$name</SPAN>.
1180
1181<P>
1182Here are the marker probe constructs:
1183
1184<DL COMPACT>
1185<DT>
1186<DD><PRE>
1187kernel.mark("MARK")
1188kernel.mark("MARK").format("FORMAT")
1189</PRE>
1190</DD>
1191</DL>
1192<P>
1193For more information about marker probes, see
1194<kbd><A ID="tex2html4"
1195 HREF="http://sourceware.org/systemtap/wiki/UsingMarkers">http://sourceware.org/systemtap/wiki/UsingMarkers</A></kbd>.
1196
1197<P>
1198
1199<H2><A ID="SECTION00059000000000000000"></A>
1200<A ID="sec:tracepoints"></A><A NAME="650"></A>
1201<BR>
1202<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">9</SPAN> Tracepoints
1203</H2>
1204
1205<P>
1206This family of probe points hooks to static probing tracepoints
1207inserted into the kernel or kernel modules. As with marker probes,
1208these tracepoints are special macro calls inserted by kernel
1209developers to make probing faster and more reliable than with
1210DWARF-based probes. DWARF debugging information is not required to
1211probe tracepoints. Tracepoints have more strongly-typed parameters
1212than marker probes.
1213
1214<P>
1215Tracepoint probes begin with <SPAN CLASS="texttt">kernel</SPAN>. The next part names the
1216tracepoint itself: <SPAN CLASS="texttt">trace("name")</SPAN>. The tracepoint
1217<SPAN CLASS="texttt">name</SPAN> string, which can contain wildcard characters, is
1218matched against the names defined by the kernel developers in the
1219tracepoint header files.
1220
1221<P>
1222The handler associated with a tracepoint-based probe can read the
1223optional parameters specified at the macro call site. These
1224parameters are named according to the declaration by the tracepoint
1225author. For example, the tracepoint probe
1226<SPAN CLASS="texttt">kernel.trace("sched_switch")</SPAN> provides the parameters
1227<SPAN CLASS="texttt">$rq</SPAN>, <SPAN CLASS="texttt">$prev</SPAN>, and <SPAN CLASS="texttt">$next</SPAN>. If the parameter
1228is a complex type such as a struct pointer, then a script can access
1229fields with the same syntax as DWARF <SPAN CLASS="texttt">$target</SPAN> variables.
1230Tracepoint parameters cannot be modified; however, in guru mode a
1231script can modify fields of parameters.
1232
1233<P>
1234The name of the tracepoint is available in <SPAN CLASS="texttt">$$name</SPAN>, and a
1235string of <SPAN CLASS="texttt">name=value</SPAN> pairs for all parameters of the
1236tracepoint is available in <SPAN CLASS="texttt">$$vars</SPAN> or <SPAN CLASS="texttt">$$parms</SPAN>.
1237
1238<P>
1239
1240<H2><A ID="SECTION000510000000000000000"></A>
1241<A ID="sec:syscall"></A><A NAME="665"></A>
1242<BR>
1243<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">10</SPAN> Syscall probes
1244</H2>
1245The <SPAN CLASS="texttt">syscall.*</SPAN> aliases define several hundred probes. They
1246use the following syntax:
1247
1248<DL COMPACT>
1249<DT>
1250<DD><PRE>
1251syscall.NAME
1252syscall.NAME.return
1253</PRE>
1254</DD>
1255</DL>
1256<P>
1257Generally, two probes are defined for each normal system call as
1258listed in the syscalls(2) manual page: one for entry and one for
1259return. System calls that never return do not have a
1260corresponding <SPAN CLASS="texttt">.return</SPAN> probe.
1261
1262<P>
1263Each probe alias defines a variety of variables. Look at the tapset
1264source code to find the most reliable source of variable definitions.
1265Generally, each variable listed in the standard manual page is
1266available as a script-level variable. For example,
1267<SPAN CLASS="texttt">syscall.open</SPAN> exposes file name, flags, and mode. In addition,
1268a standard suite of variables is available at most aliases, as follows:
1269
1270<P>
1271
1272<UL>
1273<LI><SPAN CLASS="texttt">argstr</SPAN>: A pretty-printed form of the entire argument
1274 list, without parentheses.
1275</LI>
1276<LI><SPAN CLASS="texttt">name</SPAN>: The name of the system call.
1277</LI>
1278<LI><SPAN CLASS="texttt">retstr</SPAN>: For return probes, a pretty-printed form of the
1279 system call result.
1280</LI>
1281</UL>
1282
1283<P>
1284Not all probe aliases obey all of these general guidelines. Please
1285report exceptions that you encounter as a bug.
1286
1287<P>
1288
1289<H2><A ID="SECTION000511000000000000000"></A>
1290<A NAME="679"></A>
1291<BR>
1292<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">11</SPAN> Timer probes
1293</H2>
1294You can use intervals defined by the standard kernel jiffies<A NAME="680"></A>
1295timer to trigger probe handlers asynchronously. A <SPAN CLASS="textit">jiffy</SPAN> is a kernel-defined
1296unit of time typically between 1 and 60 msec. Two probe point variants are
1297supported by the translator:
1298
1299<P>
1300
1301<DL COMPACT>
1302<DT>
1303<DD><PRE>
1304timer.jiffies(N)
1305timer.jiffies(N).randomize(M)
1306</PRE>
1307</DD>
1308</DL>The probe handler runs every N jiffies. If the <SPAN CLASS="texttt">randomize</SPAN><A NAME="687"></A>
1309component is given, a linearly distributed random value in the range [-M
1310... +M] is added to N every time the handler executes. N is restricted
1311to a reasonable range (1 to approximately 1,000,000), and M is restricted
1312to be less than N. There are no target variables provided in either context.
1313Probes can be run concurrently on multiple processors.
1314
1315<P>
1316Intervals may be specified in units of time. There are two probe point variants
1317similar to the jiffies timer:
1318
1319<P>
1320
1321<DL COMPACT>
1322<DT>
1323<DD><PRE>
1324timer.ms(N)
1325timer.ms(N).randomize(M)
1326</PRE>
1327</DD>
1328</DL>Here, N and M are specified in milliseconds<A NAME="694"></A>, but the
1329full options for units are seconds (s or sec), milliseconds (ms or msec),
1330microseconds (us or usec), nanoseconds (ns or nsec), and hertz (hz). Randomization
1331is not supported for hertz timers.
1332
1333<P>
1334The resolution of the timers depends on the target kernel. For kernels prior
1335to 2.6.17, timers are limited to jiffies resolution, so intervals are rounded
1336up to the nearest jiffies interval. After 2.6.17, the implementation uses
1337hrtimers for greater precision, though the resulting resolution will be dependent
1338upon architecture. In either case, if the randomize component is given, then
1339the random value will be added to the interval before any rounding occurs.
1340
1341<P>
1342Profiling timers are available to provide probes that execute on all CPUs
1343at each system tick. This probe takes no parameters, as follows.
1344
1345<P>
1346
1347<DL COMPACT>
1348<DT>
1349<DD><PRE>
1350timer.profile.tick
1351</PRE>
1352</DD>
1353</DL>Full context information of the interrupted process is available, making
1354this probe suitable for implementing a time-based sampling profiler.
1355
1356<P>
1357It is recommended to use the tapset probe <code>timer.profile</code> rather
1358than <code>timer.profile.tick</code>. This probe point behaves identically
1359to <code>timer.profile.tick</code> when the underlying functionality is
1360available, and falls back to using <code>perf.sw.cpu_clock</code> on some
1361recent kernels which lack the corresponding profile timer facility.
1362
1363<P>
1364The following is an example of timer usage.
1365
1366<P>
1367
1368<DL COMPACT>
1369<DT>
1370<DD><PRE>
1371# Refers to a periodic interrupt, every 1000 jiffies:
1372timer.jiffies(1000)
1373
1374# Fires every 5 seconds:
1375timer.sec(5)
1376
1377# Refers to a periodic interrupt, every 1000 +/- 200 jiffies:
1378timer.jiffies(1000).randomize(200)
1379</PRE>
1380</DD>
1381</DL>
1382<P>
1383
1384<H2><A ID="SECTION000512000000000000000">
1385<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN> Special probe points</A>
1386</H2>
1387
1388<P>
1389The probe points <SPAN CLASS="texttt">begin</SPAN> and <SPAN CLASS="texttt">end</SPAN> are defined by the translator
1390to refer to the time of session startup and shutdown. There are no target
1391variables available in either context.
1392
1393<P>
1394
1395<H3><A ID="SECTION000512100000000000000"></A>
1396<A NAME="707"></A>
1397<BR>
1398<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">1</SPAN> begin
1399</H3>
1400The <SPAN CLASS="texttt">begin</SPAN> probe is the start of the SystemTap session.
1401All <SPAN CLASS="texttt">begin</SPAN>
1402probe handlers are run during the startup of the session.
1403
1404<P>
1405
1406<H3><A ID="SECTION000512200000000000000"></A>
1407<A NAME="711"></A>
1408<BR>
1409<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">2</SPAN> end
1410</H3>
1411The <SPAN CLASS="texttt">end</SPAN> probe is the end of the SystemTap session. All <SPAN CLASS="texttt">end</SPAN>
1412probes are run during the normal shutdown of a session, such as in the aftermath
1413of a SystemTap <SPAN CLASS="texttt">exit</SPAN> function call, or an interruption from the user.
1414In the case of an shutdown triggered by error, <SPAN CLASS="texttt">end</SPAN> probes are not run.
1415
1416<P>
1417
1418<H3><A ID="SECTION000512300000000000000"></A>
1419<A NAME="717"></A>
1420<BR>
1421<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">3</SPAN> error
1422</H3>
1423The <SPAN CLASS="textit">error</SPAN> probe point is similar to the end
1424probe, except the probe handler runs when the session ends if an error
1425occurred. In this case, an <SPAN CLASS="texttt">end</SPAN> probe is skipped, but each
1426<SPAN CLASS="texttt">error</SPAN> probe is still attempted. You can use an
1427<SPAN CLASS="texttt">error</SPAN> probe to clean up or perform a final action on script
1428termination.
1429
1430<P>
1431Here is a simple example:
1432
1433<DL COMPACT>
1434<DT>
1435<DD><PRE>
1436probe error { println ("Oops, errors occurred. Here's a report anyway.")
1437 foreach (coin in mint) { println (coin) } }
1438</PRE>
1439</DD>
1440</DL>
1441<P>
1442
1443<H3><A ID="SECTION000512400000000000000"></A>
1444<A NAME="727"></A>
1445<BR>
1446<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">4</SPAN> begin, end, and error probe sequence
1447</H3>
1448<SPAN CLASS="texttt">begin</SPAN>, <SPAN CLASS="texttt">end</SPAN>, and <SPAN CLASS="texttt">error</SPAN> probes can be
1449specified with an optional sequence number that controls the order in
1450which they are run. If no sequence number is provided, the sequence
1451number defaults to zero and probes are run in the order that they
1452occur in the script file. Sequence numbers may be either positive or
1453negative, and are especially useful for tapset writers who want to do
1454initialization in a <SPAN CLASS="texttt">begin</SPAN> probe. The following are examples.
1455
1456<P>
1457
1458<DL COMPACT>
1459<DT>
1460<DD><PRE>
1461# In a tapset file:
1462probe begin(-1000) { ... }
1463
1464# In a user script:
1465probe begin { ... }
1466</PRE>
1467</DD>
1468</DL>The user script <SPAN CLASS="texttt">begin</SPAN> probe defaults to sequence number zero, so
1469the tapset <SPAN CLASS="texttt">begin</SPAN> probe will run first.
1470
1471<P>
1472
1473<H3><A ID="SECTION000512500000000000000"></A>
1474<A NAME="739"></A>
1475<BR>
1476<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">5</SPAN> never
1477</H3>
1478The <SPAN CLASS="texttt">never</SPAN> probe point is defined by the translator to mean <SPAN CLASS="textit">never</SPAN>.
1479Its statements are analyzed for symbol and type correctness, but its probe
1480handler is never run. This probe point may be useful in conjunction with
1481optional probes. See Section&nbsp;<A HREF="#sub:Optional-probe-points"><IMG ALT="[*]" SRC="crossref.png"></A>.
1482
1483<P>
1484
1485<DIV CLASS="navigation"><HR>
1486<!--Navigation Panel-->
1487<A
1488 HREF="5_Language_elements.html">
1489<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
1490<A
1491 HREF="langref.html">
1492<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
1493<A
1494 HREF="3_Components_SystemTap_scri.html">
1495<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
1496<A ID="tex2html280"
1497 HREF="Contents.html">
1498<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
1499<A ID="tex2html282"
1500 HREF="Index.html">
1501<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
1502<BR>
1503<B> Next:</B> <A
1504 HREF="5_Language_elements.html">5 Language elements</A>
1505<B> Up:</B> <A
1506 HREF="langref.html">SystemTap Language Reference</A>
1507<B> Previous:</B> <A
1508 HREF="3_Components_SystemTap_scri.html">3 Components of a</A>
1509 &nbsp; <B> <A ID="tex2html281"
1510 HREF="Contents.html">Contents</A></B>
1511 &nbsp; <B> <A ID="tex2html283"
1512 HREF="Index.html">Index</A></B> </DIV>
1513<!--End of Navigation Panel-->
1514
1515</BODY>
1516</HTML>
diff --git a/langref/5_Language_elements.html b/langref/5_Language_elements.html
deleted file mode 100644
index 456adc22..00000000
--- a/langref/5_Language_elements.html
+++ /dev/null
@@ -1,905 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>5 Language elements</TITLE>
7<META NAME="description" CONTENT="5 Language elements">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="6_Statement_types.html">
19<LINK REL="previous" HREF="4_Probe_points.html">
20<LINK REL="next" HREF="6_Statement_types.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="6_Statement_types.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="4_Probe_points.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html316"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html318"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="6_Statement_types.html">6 Statement types</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="4_Probe_points.html">4 Probe points</A>
48 &nbsp; <B> <A ID="tex2html317"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html319"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html320"
60 HREF="5_Language_elements.html#SECTION00061000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN> Identifiers</A>
61<LI><A ID="tex2html321"
62 HREF="5_Language_elements.html#SECTION00062000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN> Data types</A>
63<UL>
64<LI><A ID="tex2html322"
65 HREF="5_Language_elements.html#SECTION00062100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Literals</A>
66<LI><A ID="tex2html323"
67 HREF="5_Language_elements.html#SECTION00062200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Integers</A>
68<LI><A ID="tex2html324"
69 HREF="5_Language_elements.html#SECTION00062300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN> Strings</A>
70<LI><A ID="tex2html325"
71 HREF="5_Language_elements.html#SECTION00062400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">4</SPAN> Associative arrays</A>
72<LI><A ID="tex2html326"
73 HREF="5_Language_elements.html#SECTION00062500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">5</SPAN> Statistics</A>
74</UL>
75<BR>
76<LI><A ID="tex2html327"
77 HREF="5_Language_elements.html#SECTION00063000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN> Semicolons</A>
78<LI><A ID="tex2html328"
79 HREF="5_Language_elements.html#SECTION00064000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN> Comments</A>
80<LI><A ID="tex2html329"
81 HREF="5_Language_elements.html#SECTION00065000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN> Whitespace</A>
82<LI><A ID="tex2html330"
83 HREF="5_Language_elements.html#SECTION00066000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN> Expressions</A>
84<UL>
85<LI><A ID="tex2html331"
86 HREF="5_Language_elements.html#SECTION00066100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN> Binary numeric operators</A>
87<LI><A ID="tex2html332"
88 HREF="5_Language_elements.html#SECTION00066200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN> Binary string operators</A>
89<LI><A ID="tex2html333"
90 HREF="5_Language_elements.html#SECTION00066300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN> Numeric assignment operators</A>
91<LI><A ID="tex2html334"
92 HREF="5_Language_elements.html#SECTION00066400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN> String assignment operators</A>
93<LI><A ID="tex2html335"
94 HREF="5_Language_elements.html#SECTION00066500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN> Unary numeric operators</A>
95<LI><A ID="tex2html336"
96 HREF="5_Language_elements.html#SECTION00066600000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN> Numeric &amp; string comparison, regular expression matching operators</A>
97<LI><A ID="tex2html337"
98 HREF="5_Language_elements.html#SECTION00066700000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN> Ternary operator</A>
99<LI><A ID="tex2html338"
100 HREF="5_Language_elements.html#SECTION00066800000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN> Grouping operator</A>
101<LI><A ID="tex2html339"
102 HREF="5_Language_elements.html#SECTION00066900000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN> Function call</A>
103<LI><A ID="tex2html340"
104 HREF="5_Language_elements.html#SECTION000661000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN> $ptr-&gt;member</A>
105<LI><A ID="tex2html341"
106 HREF="5_Language_elements.html#SECTION000661100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN> Pointer typecasting</A>
107<LI><A ID="tex2html342"
108 HREF="5_Language_elements.html#SECTION000661200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN> &lt;value&gt; in &lt;array_name&gt;</A>
109<LI><A ID="tex2html343"
110 HREF="5_Language_elements.html#SECTION000661300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">13</SPAN> [ &lt;value&gt;, ... ] in &lt;array_name&gt;</A>
111</UL>
112<BR>
113<LI><A ID="tex2html344"
114 HREF="5_Language_elements.html#SECTION00067000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN> Literals passed in from the stap command line</A>
115<UL>
116<LI><A ID="tex2html345"
117 HREF="5_Language_elements.html#SECTION00067100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN> $1 ... $&lt;NN&gt; for literal pasting</A>
118<LI><A ID="tex2html346"
119 HREF="5_Language_elements.html#SECTION00067200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">2</SPAN> @1 ... @&lt;NN&gt; for strings</A>
120<LI><A ID="tex2html347"
121 HREF="5_Language_elements.html#SECTION00067300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">3</SPAN> Examples</A>
122</UL>
123<BR>
124<LI><A ID="tex2html348"
125 HREF="5_Language_elements.html#SECTION00068000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN> Conditional compilation</A>
126<UL>
127<LI><A ID="tex2html349"
128 HREF="5_Language_elements.html#SECTION00068100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN> Conditions</A>
129<LI><A ID="tex2html350"
130 HREF="5_Language_elements.html#SECTION00068200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN> Conditions based on available target variables</A>
131<LI><A ID="tex2html351"
132 HREF="5_Language_elements.html#SECTION00068300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN> Conditions based on kernel version: kernel_v, kernel_vr</A>
133<LI><A ID="tex2html352"
134 HREF="5_Language_elements.html#SECTION00068400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN> Conditions based on architecture: arch</A>
135<LI><A ID="tex2html353"
136 HREF="5_Language_elements.html#SECTION00068500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN> Conditions based on privilege level: systemtap_privilege</A>
137<LI><A ID="tex2html354"
138 HREF="5_Language_elements.html#SECTION00068600000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">6</SPAN> True and False Tokens</A>
139</UL>
140<BR>
141<LI><A ID="tex2html355"
142 HREF="5_Language_elements.html#SECTION00069000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN> Preprocessor macros</A>
143<UL>
144<LI><A ID="tex2html356"
145 HREF="5_Language_elements.html#SECTION00069100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN> Local macros</A>
146<LI><A ID="tex2html357"
147 HREF="5_Language_elements.html#SECTION00069200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN> Library macros</A>
148</UL></UL>
149<!--End of Table of Child-Links-->
150<HR>
151
152<H1><A ID="SECTION00060000000000000000"></A><A ID="sec:Language-Elements"></A>
153<BR>
154<SPAN CLASS="arabic">5</SPAN> Language elements
155</H1>
156
157<H2><A ID="SECTION00061000000000000000"></A>
158<A NAME="745"></A>
159<BR>
160<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN> Identifiers
161</H2>
162<SPAN CLASS="textit">Identifiers</SPAN> are used to name variables and functions. They are an
163alphanumeric sequence that may include the underscore (_) and dollar sign
164($) characters. They have the same syntax as C identifiers, except that
165the dollar sign is also a legal character. Identifiers that begin with a
166dollar sign are interpreted as references to variables in the target software,
167rather than to SystemTap script variables. Identifiers may not start with
168a plain digit.
169
170<P>
171
172<H2><A ID="SECTION00062000000000000000"></A><A ID="sub:Data-types"></A>
173<A NAME="748"></A>
174<BR>
175<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN> Data types
176</H2>
177The SystemTap language includes a small number of data types, but no type
178declarations. A variable's type is inferred<A NAME="749"></A> from its use.
179To support this inference, the translator enforces consistent typing of function
180arguments and return values, array indices and values. There are no implicit
181type conversions between strings and numbers. Inconsistent type-related use
182of an identifier signals an error.
183
184<P>
185
186<H3><A ID="SECTION00062100000000000000"></A>
187<A NAME="751"></A>
188<BR>
189<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Literals
190</H3>
191Literals are either strings or integers.
192Literal integers can be expressed as decimal,
193octal, or hexadecimal, using C notation. Type suffixes (e.g., <SPAN CLASS="textit">L</SPAN> or
194<SPAN CLASS="textit">U</SPAN>) are not used.
195
196<P>
197
198<H3><A ID="SECTION00062200000000000000"></A><A ID="sub:Integers"></A>
199<A NAME="755"></A> <A NAME="756"></A>
200<BR>
201<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Integers
202</H3>
203Integers are decimal, hexadecimal, or octal, and use the same notation as
204in C. Integers are 64-bit signed quantities, although the parser also accepts
205(and wraps around) values above positive <SPAN CLASS="MATH"><IMG STYLE="height: 1.96ex; vertical-align: -0.12ex; " SRC="img1.png"
206 ALT="$2^{63}$"></SPAN> but below <SPAN CLASS="MATH"><IMG STYLE="height: 1.96ex; vertical-align: -0.12ex; " SRC="img2.png"
207 ALT="$2^{64}$"></SPAN>.
208
209<P>
210
211<H3><A ID="SECTION00062300000000000000"></A><A ID="sub:Strings"></A>
212<A NAME="760"></A>
213<BR>
214<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN> Strings
215</H3>
216
217<P>
218Strings are enclosed in quotation marks (&ldquo;string&rdquo;), and pass
219through standard C escape codes with backslashes. A string literal may
220be split into several pieces, which are glued together, as follows.
221
222<P>
223
224<DL COMPACT>
225<DT>
226<DD><PRE>
227str1 = "foo" "bar"
228 /* --&gt; becomes "foobar" */
229
230str2 = "a good way to do a multi-line\n"
231 "string literal"
232 /* --&gt; becomes "a good way to do a multi-line\nstring literal" */
233
234str3 = "also a good way to " @1 " splice command line args"
235 /* --&gt; becomes "also a good way to foo splice command line args",
236 assuming @1 is given as foo on the command line */
237</PRE>
238</DD>
239</DL>
240<P>
241Observe that script arguments can also be glued into a string literal.
242
243<P>
244Strings are limited in length to MAXSTRINGLEN. For more information
245about this and other limits, see Section&nbsp;<A HREF="1_SystemTap_overview.html#sub:SystemTap-safety"><IMG ALT="[*]" SRC="crossref.png"></A>.
246
247<P>
248
249<H3><A ID="SECTION00062400000000000000">
250<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">4</SPAN> Associative arrays</A>
251</H3>
252
253<P>
254See Section&nbsp;<A HREF="7_Associative_arrays.html#sec:Associative-Arrays"><IMG ALT="[*]" SRC="crossref.png"></A>
255
256<P>
257
258<H3><A ID="SECTION00062500000000000000">
259<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">5</SPAN> Statistics</A>
260</H3>
261
262<P>
263See Section&nbsp;<A HREF="8_Statistics_aggregates.html#sec:Statistics"><IMG ALT="[*]" SRC="crossref.png"></A>
264
265<P>
266
267<H2><A ID="SECTION00063000000000000000"></A>
268<A NAME="772"></A>
269<BR>
270<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN> Semicolons
271</H2>
272The semicolon is the null statement, or do nothing statement. It is optional,
273and useful as a separator between statements to improve detection of syntax
274errors and to reduce ambiguities in grammar.
275
276<P>
277
278<H2><A ID="SECTION00064000000000000000"></A>
279<A NAME="774"></A>
280<BR>
281<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN> Comments
282</H2>
283Three forms of comments are supported, as follows.
284
285<P>
286
287<DL COMPACT>
288<DT>
289<DD><PRE>
290# ... shell style, to the end of line
291// ... C++ style, to the end of line
292/* ... C style ... */
293</PRE>
294</DD>
295</DL>
296<P>
297
298<H2><A ID="SECTION00065000000000000000"></A>
299<A NAME="780"></A>
300<BR>
301<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN> Whitespace
302</H2>
303As in C, spaces, tabs, returns, newlines, and comments are treated as whitespace.
304Whitespace is ignored by the parser.
305
306<P>
307
308<H2><A ID="SECTION00066000000000000000"></A>
309<A NAME="782"></A>
310<BR>
311<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN> Expressions
312</H2>
313SystemTap supports a number of operators that use the same general syntax,
314semantics, and precedence as in C and awk. Arithmetic is performed per C
315rules for signed integers. If the parser detects division by zero or an overflow,
316it generates an error. The following subsections list these operators.
317
318<P>
319
320<H3><A ID="SECTION00066100000000000000"></A>
321<A NAME="784"></A>
322<BR>
323<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN> Binary numeric operators
324</H3>
325<SPAN CLASS="texttt">* / % + - &gt;&nbsp;&gt; &gt;&nbsp;&gt;&nbsp;&gt; &lt;&nbsp;&lt; &amp; &#94;
326| &amp;&amp; ||</SPAN>
327
328<P>
329
330<H3><A ID="SECTION00066200000000000000"></A>
331<A NAME="792"></A>
332<BR>
333<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN> Binary string operators
334</H3>
335<SPAN CLASS="texttt"><SPAN CLASS="textbf">.</SPAN></SPAN> (string concatenation)
336
337<P>
338
339<H3><A ID="SECTION00066300000000000000"></A>
340<A NAME="795"></A>
341<BR>
342<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN> Numeric assignment operators
343</H3>
344<SPAN CLASS="texttt">= *= /= %= += -= &gt;&nbsp;&gt;= &lt;&nbsp;&lt;=
345&amp;= &#94;= |=</SPAN>
346
347<P>
348
349<H3><A ID="SECTION00066400000000000000">
350<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN> String assignment operators</A>
351</H3>
352
353<P>
354<SPAN CLASS="texttt">= .=</SPAN>
355
356<P>
357
358<H3><A ID="SECTION00066500000000000000"></A>
359<A NAME="803"></A>
360<BR>
361<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN> Unary numeric operators
362</H3>
363<SPAN CLASS="texttt">+ - ! ~ ++ -</SPAN>
364
365<P>
366
367<H3><A ID="SECTION00066600000000000000"></A>
368<A NAME="807"></A>
369<BR>
370<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN> Numeric &amp; string comparison, regular expression matching operators
371</H3>
372<SPAN CLASS="texttt">&lt; &gt; &lt;= &gt;= == !=</SPAN> <code>=~</code> <code>!~</code>
373
374<P>
375The <code>=~</code> and <code>!~</code> operators perform regular expression
376matching. The second operand must be a string literal
377containing a syntactically valid regular expression. The <code>=~</code> operator returns <SPAN style="font-family:monospace">1</SPAN> on a successful match and <SPAN CLASS="texttt">0</SPAN> on a failed match.
378The <code>!~</code> operator returns <SPAN style="font-family:monospace">1</SPAN> on a failed match.
379The regular expression syntax supports most of the features of POSIX Extended
380Regular Expressions, except for subexpression reuse (<code>\1</code>)
381functionality. After a successful match, the matched substring and subexpressions can be extracted using the <SPAN CLASS="texttt">matched</SPAN> tapset
382function. The <SPAN CLASS="texttt">ngroups</SPAN> tapset function returns the number of
383subexpressions in the last successfully matched regular expression.
384
385<P>
386
387<H3><A ID="SECTION00066700000000000000"></A><A ID="sub:Ternary-operator"></A>
388<A NAME="815"></A>
389<BR>
390<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN> Ternary operator
391</H3>
392<SPAN CLASS="texttt">cond ? exp1 : exp2</SPAN>
393
394<P>
395
396<H3><A ID="SECTION00066800000000000000"></A>
397<A NAME="818"></A>
398<BR>
399<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN> Grouping operator
400</H3>
401<SPAN CLASS="texttt">( exp )</SPAN>
402
403<P>
404
405<H3><A ID="SECTION00066900000000000000"></A>
406<A NAME="821"></A>
407<BR>
408<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN> Function call
409</H3>
410General syntax:
411
412<P>
413<SPAN CLASS="texttt">fn ([ arg1, arg2, ... ])</SPAN>
414
415<P>
416
417<H3><A ID="SECTION000661000000000000000"></A>
418<A NAME="824"></A>
419<BR>
420<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN> $ptr-&gt;member
421</H3>
422<SPAN CLASS="texttt">ptr</SPAN> is a kernel pointer available in a probed context.
423
424<P>
425
426<H3><A ID="SECTION000661100000000000000"></A>
427<A NAME="827"></A>
428<BR>
429<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN> Pointer typecasting
430</H3>
431
432<P>
433<SPAN CLASS="textit">Typecasting</SPAN> is supported using the <SPAN CLASS="texttt">@cast()</SPAN> operator. A
434script can define a pointer type for a <SPAN CLASS="textit">long</SPAN> value, then access
435type members using the same syntax as with <SPAN CLASS="texttt">$target</SPAN>
436variables. After a pointer is saved into a script integer variable,
437the translator loses the necessary type information to access members
438from that pointer. The <SPAN CLASS="texttt">@cast()</SPAN> operator tells the translator
439how to read a pointer.
440
441<P>
442The following statement interprets <SPAN CLASS="texttt">p</SPAN> as a pointer to a struct
443or union named <SPAN CLASS="texttt">type_name</SPAN> and dereferences the
444<SPAN CLASS="texttt">member</SPAN> value:
445
446<DL COMPACT>
447<DT>
448<DD><PRE>
449@cast(p, "type_name"[, "module"])-&gt;member
450</PRE>
451</DD>
452</DL>
453<P>
454The optional <SPAN CLASS="texttt">module</SPAN> parameter tells the translator where to
455look for information about that type. You can specify multiple modules
456as a list with colon (<SPAN CLASS="texttt">:</SPAN>) separators. If you do not specify
457the module parameter, the translator defaults to either the probe
458module for dwarf probes or to <SPAN CLASS="textit">kernel</SPAN> for functions and all
459other probe types.
460
461<P>
462The following statement retrieves the parent PID from a kernel
463task_struct:
464
465<DL COMPACT>
466<DT>
467<DD><PRE>
468@cast(pointer, "task_struct", "kernel")-&gt;parent-&gt;tgid
469</PRE>
470</DD>
471</DL>
472<P>
473The translator can create its own module with type information from a
474header surrounded by angle brackets (<SPAN CLASS="texttt">&lt; &gt;</SPAN>) if normal debugging
475information is not available. For kernel headers, prefix it with
476<SPAN CLASS="texttt">kernel</SPAN> to use the appropriate build system. All other
477headers are built with default GCC parameters into a user module. The
478following statements are examples.
479
480<DL COMPACT>
481<DT>
482<DD><PRE>
483@cast(tv, "timeval", "&lt;sys/time.h&gt;")-&gt;tv_sec
484@cast(task, "task_struct", "kernel&lt;linux/sched.h&gt;")-&gt;tgid
485</PRE>
486</DD>
487</DL>
488<P>
489In guru mode, the translator allows scripts to assign new values to
490members of typecasted pointers.
491
492<P>
493Typecasting is also useful in the case of <SPAN CLASS="texttt">void*</SPAN> members whose
494type might be determinable at run time.
495
496<DL COMPACT>
497<DT>
498<DD><PRE>
499probe foo {
500 if ($var-&gt;type == 1) {
501 value = @cast($var-&gt;data, "type1")-&gt;bar
502 } else {
503 value = @cast($var-&gt;data, "type2")-&gt;baz
504 }
505 print(value)
506}
507</PRE>
508</DD>
509</DL>
510<P>
511
512<H3><A ID="SECTION000661200000000000000"></A>
513<A NAME="859"></A>
514<BR>
515<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN> &lt;value&gt; in &lt;array_name&gt;
516</H3>
517This expression evaluates to true if the array contains an element with the
518specified index.
519
520<P>
521
522<H3><A ID="SECTION000661300000000000000">
523<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">13</SPAN> [ &lt;value&gt;, ... ] in &lt;array_name&gt;</A>
524</H3>
525
526<P>
527The number of index values must match the number of indexes previously specified.
528
529<P>
530
531<H2><A ID="SECTION00067000000000000000"></A><A ID="sub:Literals-passed-in"></A>
532<A NAME="862"></A>
533<BR>
534<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN> Literals passed in from the stap command line
535</H2>
536<SPAN CLASS="textit">Literals</SPAN> are either strings enclosed in double quotes (&rdquo; &rdquo;) or
537integers. For information about integers, see Section&nbsp;<A HREF="#sub:Integers"><IMG ALT="[*]" SRC="crossref.png"></A>.
538For information about strings, see Section&nbsp;<A HREF="#sub:Strings"><IMG ALT="[*]" SRC="crossref.png"></A>.
539
540<P>
541Script arguments at the end of a command line are expanded as literals. You
542can use these in all contexts where literals are accepted. A reference to
543a nonexistent argument number is an error.
544
545<P>
546
547<H3><A ID="SECTION00067100000000000000"></A>
548<A NAME="867"></A>
549<BR>
550<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN> $1 ... $&lt;NN&gt; for literal pasting
551</H3>
552Use <SPAN CLASS="texttt">$1 ... $&lt;NN&gt;</SPAN> for pasting the entire argument string
553into the input stream, which will be further lexically tokenized.
554
555<P>
556
557<H3><A ID="SECTION00067200000000000000">
558<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">2</SPAN> @1 ... @&lt;NN&gt; for strings</A>
559</H3>
560
561<P>
562Use <SPAN CLASS="texttt">@1 ... @&lt;NN&gt;</SPAN> for casting an entire argument
563as a string literal.
564
565<P>
566
567<H3><A ID="SECTION00067300000000000000">
568<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">3</SPAN> Examples</A>
569</H3>
570
571<P>
572For example, if the following script named example.stp
573
574<P>
575
576<DL COMPACT>
577<DT>
578<DD><PRE>
579probe begin { printf("%d, %s\n", $1, @2) }
580</PRE>
581</DD>
582</DL>is invoked as follows
583
584<P>
585
586<DL COMPACT>
587<DT>
588<DD><PRE>
589# stap example.stp '5+5' mystring
590</PRE>
591</DD>
592</DL>then 5+5 is substituted for $1 and &#34;mystring&#34; for @2. The
593output will be
594
595<P>
596
597<DL COMPACT>
598<DT>
599<DD><PRE>
60010, mystring
601</PRE>
602</DD>
603</DL>
604<P>
605
606<H2><A ID="SECTION00068000000000000000">
607<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN> Conditional compilation</A>
608</H2>
609
610<P>
611
612<H3><A ID="SECTION00068100000000000000"></A>
613<A NAME="888"></A>
614<BR>
615<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN> Conditions
616</H3>
617One of the steps of parsing is a simple preprocessing stage. The
618preprocessor supports conditionals with a general form similar to the
619ternary operator (Section&nbsp;<A HREF="#sub:Ternary-operator"><IMG ALT="[*]" SRC="crossref.png"></A>).
620
621<P>
622
623<DL COMPACT>
624<DT>
625<DD><PRE>
626%( CONDITION %? TRUE-TOKENS %)
627%( CONDITION %? TRUE-TOKENS %: FALSE-TOKENS %)
628</PRE>
629</DD>
630</DL>The CONDITION is a limited expression whose format is determined by its first
631keyword. The following is the general syntax.
632
633<P>
634
635<DL COMPACT>
636<DT>
637<DD><PRE>
638%( &lt;condition&gt; %? &lt;code&gt; [ %: &lt;code&gt; ] %)
639</PRE>
640</DD>
641</DL>
642<P>
643
644<H3><A ID="SECTION00068200000000000000"></A>
645<A NAME="899"></A>
646<BR>
647<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN> Conditions based on available target variables
648</H3>
649The predicate @defined() is available for testing whether a
650particular $variable/expression is resolvable at translation time. The
651following is an example of its use:
652
653<P>
654
655<DL COMPACT>
656<DT>
657<DD><PRE>
658 probe foo { if (@defined($bar)) log ("$bar is available here") }
659</PRE>
660</DD>
661</DL>
662<P>
663
664<H3><A ID="SECTION00068300000000000000"></A>
665<A NAME="905"></A>
666<A NAME="906"></A>
667<A NAME="907"></A>
668<BR>
669<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN> Conditions based on kernel version: kernel_v, kernel_vr
670</H3>
671If the first part of a conditional expression is the identifier <SPAN CLASS="texttt">kernel_v</SPAN>
672or <SPAN CLASS="texttt">kernel_vr</SPAN>, the second part must be one of six standard numeric
673comparison operators &ldquo;&lt;&rdquo;, &ldquo;&lt;=&rdquo;, &ldquo;==&rdquo;, &ldquo;!=&rdquo;, &ldquo;&gt;&rdquo;,
674or &ldquo;&gt;=&rdquo;,
675and the third part must be a string literal that contains an RPM-style version-release
676value. The condition returns true if the version of the target kernel (as
677optionally overridden by the <SPAN CLASS="textbf">-r</SPAN> option) matches the given version
678string. The comparison is performed by the glibc function strverscmp.
679
680<P>
681<SPAN CLASS="texttt">kernel_v</SPAN> refers to the kernel version number only, such as &ldquo;2.6.13&#34;.
682
683<P>
684<SPAN CLASS="texttt">kernel_vr</SPAN> refers to the kernel version number including the release
685code suffix, such as &ldquo;2.6.13-1.322FC3smp&rdquo;.
686
687<P>
688
689<H3><A ID="SECTION00068400000000000000"></A>
690<A NAME="923"></A>
691<BR>
692<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN> Conditions based on architecture: arch
693</H3>
694If the first part of the conditional expression is the identifier <SPAN CLASS="texttt">arch</SPAN>
695which refers to the processor architecture, then the second part is a string
696comparison operator &rdquo;==&rdquo; or &rdquo;!=&rdquo;, and the third part is a string
697literal for matching it. This comparison is a simple string equality or inequality.
698The currently supported architecture strings are i386, i686, x86_64, ia64,
699s390, and powerpc.
700
701<P>
702
703<H3><A ID="SECTION00068500000000000000"></A>
704<A NAME="926"></A>
705<BR>
706<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN> Conditions based on privilege level: systemtap_privilege
707</H3>
708
709<P>
710If the first part of the conditional expression is the identifier
711<SPAN CLASS="texttt">systemtap_privilege</SPAN> which refers to the privilege level the
712systemtap script is being compiled with, then the second part is a
713string comparison operator &rdquo;==&rdquo; or &rdquo;!=&rdquo;, and the third part is a
714string literal for matching it. This comparison is a simple string
715equality or inequality. The possible privilege strings to consider
716are <code>"stapusr"</code> for unprivileged scripts, and <code>"stapsys"</code> or
717<code>"stapdev"</code> for privileged scripts. (In general, to test for a
718privileged script it is best to use <code>!= "stapusr"</code>.)
719
720<P>
721This condition can be used to write scripts that can be run in both
722privileged and unprivileged modes, with additional functionality made
723available in the privileged case.
724
725<P>
726
727<H3><A ID="SECTION00068600000000000000"></A>
728<A NAME="929"></A>
729<BR>
730<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">6</SPAN> True and False Tokens
731</H3>
732TRUE-TOKENS and FALSE-TOKENS are zero or more general parser tokens, possibly
733including nested preprocessor conditionals, that are pasted into the input
734stream if the condition is true or false. For example, the following code
735induces a parse error unless the target kernel version is newer than 2.6.5.
736
737<P>
738
739<DL COMPACT>
740<DT>
741<DD><PRE>
742%( kernel_v &lt;= "2.6.5" %? **ERROR** %) # invalid token sequence
743</PRE>
744</DD>
745</DL>The following code adapts to hypothetical kernel version drift.
746
747<P>
748
749<DL COMPACT>
750<DT>
751<DD><PRE>
752probe kernel.function (
753 %( kernel_v &lt;= "2.6.12" %? "__mm_do_fault" %:
754 %( kernel_vr == "2.6.13-1.8273FC3smp" %? "do_page_fault" %: UNSUPPORTED %)
755 %)) { /* ... */ }
756
757%( arch == "ia64" %?
758 probe syscall.vliw = kernel.function("vliw_widget") {}
759%)
760</PRE>
761</DD>
762</DL>
763<P>
764The following code adapts to the presence of a kernel CONFIG option.
765
766<P>
767
768<DL COMPACT>
769<DT>
770<DD><PRE>
771%( CONFIG_UTRACE == "y" %?
772 probe process.syscall {}
773%)
774</PRE>
775</DD>
776</DL>
777<P>
778
779<H2><A ID="SECTION00069000000000000000">
780<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN> Preprocessor macros</A>
781</H2>
782
783<P>
784This feature lets scripts eliminate some types of repetition.
785
786<P>
787
788<H3><A ID="SECTION00069100000000000000">
789<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN> Local macros</A>
790</H3>
791
792<P>
793The preprocessor also supports a simple macro facility.
794
795<P>
796Macros taking zero or more arguments are defined using the following
797construct:
798
799<P>
800
801<DL COMPACT>
802<DT>
803<DD><PRE>
804@define NAME %( BODY %)
805@define NAME(PARAM_1, PARAM_2, ...) %( BODY %)
806</PRE>
807</DD>
808</DL>
809<P>
810Macro arguments are referred to in the body by prefixing the argument
811name with an <SPAN CLASS="texttt">@</SPAN> symbol. Likewise, once defined, macros are
812invoked by prefixing the macro name with an <SPAN CLASS="texttt">@</SPAN> symbol:
813
814<P>
815
816<DL COMPACT>
817<DT>
818<DD><PRE>
819@define foo %( x %)
820@define add(a,b) %( ((@a)+(@b)) %)
821
822 @foo = @add(2,2)
823</PRE>
824</DD>
825</DL>
826<P>
827Macro expansion is currently performed in a separate pass before
828conditional compilation. Therefore, both TRUE- and FALSE-tokens in
829conditional expressions will be macroexpanded regardless of how the
830condition is evaluated. This can sometimes lead to errors:
831
832<P>
833
834<DL COMPACT>
835<DT>
836<DD><PRE>
837// The following results in a conflict:
838%( CONFIG_UTRACE == "y" %?
839 @define foo %( process.syscall %)
840%:
841 @define foo %( **ERROR** %)
842%)
843
844// The following works properly as expected:
845@define foo %(
846 %( CONFIG_UTRACE == "y" %? process.syscall %: **ERROR** %)
847%)
848</PRE>
849</DD>
850</DL>
851<P>
852The first example is incorrect because both <SPAN CLASS="texttt">@define</SPAN>s are
853evaluated in a pass prior to the conditional being evaluated.
854
855<P>
856
857<H3><A ID="SECTION00069200000000000000">
858<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN> Library macros</A>
859</H3>
860
861<P>
862Normally, a macro definition is local to the file it occurs in. Thus,
863defining a macro in a tapset does not make it available to the user of
864the tapset.
865
866<P>
867Publically available library macros can be defined by including
868<SPAN CLASS="texttt">.stpm</SPAN> files on the tapset search path. These files may only
869contain <SPAN CLASS="texttt">@define</SPAN> constructs, which become visible across all
870tapsets and user scripts.
871
872<P>
873
874<DIV CLASS="navigation"><HR>
875<!--Navigation Panel-->
876<A
877 HREF="6_Statement_types.html">
878<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
879<A
880 HREF="langref.html">
881<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
882<A
883 HREF="4_Probe_points.html">
884<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
885<A ID="tex2html316"
886 HREF="Contents.html">
887<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
888<A ID="tex2html318"
889 HREF="Index.html">
890<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
891<BR>
892<B> Next:</B> <A
893 HREF="6_Statement_types.html">6 Statement types</A>
894<B> Up:</B> <A
895 HREF="langref.html">SystemTap Language Reference</A>
896<B> Previous:</B> <A
897 HREF="4_Probe_points.html">4 Probe points</A>
898 &nbsp; <B> <A ID="tex2html317"
899 HREF="Contents.html">Contents</A></B>
900 &nbsp; <B> <A ID="tex2html319"
901 HREF="Index.html">Index</A></B> </DIV>
902<!--End of Navigation Panel-->
903
904</BODY>
905</HTML>
diff --git a/langref/6_Statement_types.html b/langref/6_Statement_types.html
deleted file mode 100644
index 88989723..00000000
--- a/langref/6_Statement_types.html
+++ /dev/null
@@ -1,430 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>6 Statement types</TITLE>
7<META NAME="description" CONTENT="6 Statement types">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="7_Associative_arrays.html">
19<LINK REL="previous" HREF="5_Language_elements.html">
20<LINK REL="next" HREF="7_Associative_arrays.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="7_Associative_arrays.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="5_Language_elements.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html358"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html360"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="7_Associative_arrays.html">7 Associative arrays</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="5_Language_elements.html">5 Language elements</A>
48 &nbsp; <B> <A ID="tex2html359"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html361"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html362"
60 HREF="6_Statement_types.html#SECTION00071000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN> break and continue</A>
61<LI><A ID="tex2html363"
62 HREF="6_Statement_types.html#SECTION00072000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN> try/catch</A>
63<LI><A ID="tex2html364"
64 HREF="6_Statement_types.html#SECTION00073000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN> delete</A>
65<LI><A ID="tex2html365"
66 HREF="6_Statement_types.html#SECTION00074000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN> EXP (expression)</A>
67<LI><A ID="tex2html366"
68 HREF="6_Statement_types.html#SECTION00075000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN> for</A>
69<LI><A ID="tex2html367"
70 HREF="6_Statement_types.html#SECTION00076000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN> foreach</A>
71<LI><A ID="tex2html368"
72 HREF="6_Statement_types.html#SECTION00077000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN> if</A>
73<LI><A ID="tex2html369"
74 HREF="6_Statement_types.html#SECTION00078000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN> next</A>
75<LI><A ID="tex2html370"
76 HREF="6_Statement_types.html#SECTION00079000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN> ; (null statement)</A>
77<LI><A ID="tex2html371"
78 HREF="6_Statement_types.html#SECTION000710000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN> return</A>
79<LI><A ID="tex2html372"
80 HREF="6_Statement_types.html#SECTION000711000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN> { } (statement block)</A>
81<LI><A ID="tex2html373"
82 HREF="6_Statement_types.html#SECTION000712000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN> while</A>
83</UL>
84<!--End of Table of Child-Links-->
85<HR>
86
87<H1><A ID="SECTION00070000000000000000"></A><A ID="sec:Statement-Types"></A>
88<BR>
89<SPAN CLASS="arabic">6</SPAN> Statement types
90</H1>
91
92<P>
93Statements enable procedural control flow within functions and probe handlers.
94The total number of statements executed in response to any single probe event
95is limited to MAXACTION, which defaults to 1000. See Section&nbsp;<A HREF="1_SystemTap_overview.html#sub:SystemTap-safety"><IMG ALT="[*]" SRC="crossref.png"></A>.
96
97<P>
98
99<H2><A ID="SECTION00071000000000000000"></A>
100<A NAME="965"></A>
101<A NAME="966"></A>
102<BR>
103<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN> break and continue
104</H2>
105Use <SPAN CLASS="texttt">break</SPAN> or <SPAN CLASS="texttt">continue</SPAN> to exit or iterate the innermost
106nesting loop statement, such as within a <SPAN CLASS="texttt">while, for,</SPAN> or <SPAN CLASS="texttt">foreach</SPAN>
107statement. The syntax and semantics are the same as those used in C.
108
109<P>
110
111<H2><A ID="SECTION00072000000000000000"></A>
112<A NAME="972"></A>
113<A NAME="973"></A>
114<BR>
115<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN> try/catch
116</H2>
117Use <SPAN CLASS="texttt">try</SPAN>/<SPAN CLASS="texttt">catch</SPAN> to handle most kinds of run-time errors within the script
118instead of aborting the probe handler in progress. The semantics are similar
119to C++ in that try/catch blocks may be nested. The error string may be captured
120by optionally naming a variable which is to receive it.
121
122<P>
123
124<DL COMPACT>
125<DT>
126<DD><PRE>
127try {
128 /* do something */
129 /* trigger error like kread(0), or divide by zero, or error("foo") */
130} catch (msg) { /* omit (msg) entirely if not interested */
131 /* println("caught error ", msg) */
132 /* handle error */
133}
134/* execution continues */
135</PRE>
136</DD>
137</DL>
138<P>
139
140<H2><A ID="SECTION00073000000000000000"></A><A ID="sub:delete"></A>
141<A NAME="981"></A>
142<BR>
143<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN> delete
144</H2>
145<SPAN CLASS="texttt">delete</SPAN> removes an element.
146
147<P>
148The following statement removes from ARRAY the element specified by the index
149tuple. The value will no longer be available, and subsequent iterations will
150not report the element. It is not an error to delete an element that does
151not exist.
152
153<P>
154
155<DL COMPACT>
156<DT>
157<DD><PRE>
158delete ARRAY[INDEX1, INDEX2, ...]
159</PRE>
160</DD>
161</DL>The following syntax removes all elements from ARRAY:
162
163<P>
164
165<DL COMPACT>
166<DT>
167<DD><PRE>
168delete ARRAY
169</PRE>
170</DD>
171</DL>The following statement removes the value of SCALAR. Integers and strings
172are cleared to zero and null (&#34;&#34;) respectively, while statistics
173are reset to their initial empty state.
174
175<P>
176
177<DL COMPACT>
178<DT>
179<DD><PRE>
180delete SCALAR
181</PRE>
182</DD>
183</DL>
184<P>
185
186<H2><A ID="SECTION00074000000000000000"></A>
187<A NAME="998"></A>
188<BR>
189<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN> EXP (expression)
190</H2>
191An <SPAN CLASS="texttt">expression</SPAN> executes a string- or integer-valued expression and
192discards the value.
193
194<P>
195
196<H2><A ID="SECTION00075000000000000000"></A>
197<A NAME="1001"></A>
198<BR>
199<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN> for
200</H2>
201General syntax:
202
203<DL COMPACT>
204<DT>
205<DD><PRE>
206for (EXP1; EXP2; EXP3) STMT
207</PRE>
208</DD>
209</DL>The <SPAN CLASS="texttt">for</SPAN> statement is similar to the <SPAN CLASS="texttt">for</SPAN> statement in C.
210The <SPAN CLASS="texttt">for</SPAN> expression executes EXP1 as initialization. While EXP2 is
211non-zero, it executes STMT, then the iteration expression EXP3.
212
213<P>
214
215<H2><A ID="SECTION00076000000000000000"></A><A ID="sub:foreach"></A>
216<A NAME="1010"></A>
217<BR>
218<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN> foreach
219</H2>
220General syntax:
221
222<DL COMPACT>
223<DT>
224<DD><PRE>
225foreach (VAR in ARRAY) STMT
226</PRE>
227</DD>
228</DL>The <SPAN CLASS="texttt">foreach</SPAN> statement loops over each element of a named global array, assigning
229the current key to VAR. The array must not be modified within the statement.
230If you add a single plus (+) or minus (-) operator after the VAR or the ARRAY
231identifier, the iteration order will be sorted by the ascending or descending
232index or value.
233
234<P>
235The following statement behaves the same as the first example, except it
236is used when an array is indexed with a tuple of keys. Use a sorting suffix
237on at most one VAR or ARRAY identifier.
238
239<P>
240
241<DL COMPACT>
242<DT>
243<DD><PRE>
244foreach ([VAR1, VAR2, ...] in ARRAY) STMT
245</PRE>
246</DD>
247</DL>
248<P>
249You can combine the first and second syntax to capture both the full tuple
250and the keys at the same time as follows.
251
252<DL COMPACT>
253<DT>
254<DD><PRE>
255foreach (VAR = [VAR1, VAR2, ...] in ARRAY) STMT
256</PRE>
257</DD>
258</DL>
259<P>
260The following statement is the same as the first example, except that the
261<SPAN CLASS="texttt">limit</SPAN> keyword limits the number of loop iterations to EXP times.
262EXP is evaluated once at the beginning of the loop.
263
264<P>
265
266<DL COMPACT>
267<DT>
268<DD><PRE>
269foreach (VAR in ARRAY limit EXP) STMT
270</PRE>
271</DD>
272</DL>
273<P>
274
275<H2><A ID="SECTION00077000000000000000"></A>
276<A NAME="1030"></A>
277<BR>
278<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN> if
279</H2>
280General syntax:
281
282<P>
283
284<DL COMPACT>
285<DT>
286<DD><PRE>
287if (EXP) STMT1 [ else STMT2 ]
288</PRE>
289</DD>
290</DL>The <SPAN CLASS="texttt">if</SPAN> statement compares an integer-valued EXP to zero. It executes
291the first STMT if non-zero, or the second STMT if zero.
292
293<P>
294The <SPAN CLASS="texttt">if</SPAN> command has the same syntax and semantics as used in C.
295
296<P>
297
298<H2><A ID="SECTION00078000000000000000"></A>
299<A NAME="1038"></A>
300<BR>
301<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN> next
302</H2>
303The <SPAN CLASS="texttt">next</SPAN> statement returns immediately from the enclosing probe
304handler. When used in functions, the execution will be immediately transferred
305to the next overloaded function.
306
307<P>
308
309<H2><A ID="SECTION00079000000000000000"></A>
310<A NAME="1041"></A>
311<A NAME="1042"></A>
312<BR>
313<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN> ; (null statement)
314</H2>
315General syntax:
316
317<P>
318
319<DL COMPACT>
320<DT>
321<DD><PRE>
322statement1
323;
324statement2
325</PRE>
326</DD>
327</DL>The semicolon represents the null statement, or do nothing. It is useful
328as an optional separator between statements to improve syntax error detection
329and to handle certain grammar ambiguities.
330
331<P>
332
333<H2><A ID="SECTION000710000000000000000"></A>
334<A NAME="1048"></A>
335<BR>
336<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN> return
337</H2>
338General syntax:
339
340<P>
341
342<DL COMPACT>
343<DT>
344<DD><PRE>
345return EXP
346</PRE>
347</DD>
348</DL>The <SPAN CLASS="texttt">return</SPAN> statement returns the EXP value from the enclosing function.
349If the value of the function is not returned, then a return statement is
350not needed, and the function will have a special <SPAN CLASS="textit">unknown</SPAN> type with
351no return value.
352
353<P>
354
355<H2><A ID="SECTION000711000000000000000"></A>
356<A NAME="1056"></A>
357<A NAME="1057"></A>
358<BR>
359<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN> { } (statement block)
360</H2>
361This is the statement block with zero or more statements enclosed within
362brackets. The following is the general syntax:
363
364<P>
365
366<DL COMPACT>
367<DT>
368<DD><PRE>
369{ STMT1 STMT2 ... }
370</PRE>
371</DD>
372</DL>The statement block executes each statement in sequence in the block. Separators
373or terminators are generally not necessary between statements. The statement
374block uses the same syntax and semantics as in C.
375
376<P>
377
378<H2><A ID="SECTION000712000000000000000"></A>
379<A NAME="1063"></A>
380<BR>
381<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN> while
382</H2>
383General syntax:
384
385<P>
386
387<DL COMPACT>
388<DT>
389<DD><PRE>
390while (EXP) STMT
391</PRE>
392</DD>
393</DL>The <SPAN CLASS="texttt">while</SPAN> statement uses the same syntax and semantics as in C.
394In the statement above, while the integer-valued EXP evaluates to non-zero,
395the parser will execute STMT.
396
397<P>
398
399<DIV CLASS="navigation"><HR>
400<!--Navigation Panel-->
401<A
402 HREF="7_Associative_arrays.html">
403<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
404<A
405 HREF="langref.html">
406<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
407<A
408 HREF="5_Language_elements.html">
409<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
410<A ID="tex2html358"
411 HREF="Contents.html">
412<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
413<A ID="tex2html360"
414 HREF="Index.html">
415<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
416<BR>
417<B> Next:</B> <A
418 HREF="7_Associative_arrays.html">7 Associative arrays</A>
419<B> Up:</B> <A
420 HREF="langref.html">SystemTap Language Reference</A>
421<B> Previous:</B> <A
422 HREF="5_Language_elements.html">5 Language elements</A>
423 &nbsp; <B> <A ID="tex2html359"
424 HREF="Contents.html">Contents</A></B>
425 &nbsp; <B> <A ID="tex2html361"
426 HREF="Index.html">Index</A></B> </DIV>
427<!--End of Navigation Panel-->
428
429</BODY>
430</HTML>
diff --git a/langref/7_Associative_arrays.html b/langref/7_Associative_arrays.html
deleted file mode 100644
index 5fc5dbb9..00000000
--- a/langref/7_Associative_arrays.html
+++ /dev/null
@@ -1,262 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>7 Associative arrays</TITLE>
7<META NAME="description" CONTENT="7 Associative arrays">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="8_Statistics_aggregates.html">
19<LINK REL="previous" HREF="6_Statement_types.html">
20<LINK REL="next" HREF="8_Statistics_aggregates.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="8_Statistics_aggregates.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="6_Statement_types.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html374"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html376"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="8_Statistics_aggregates.html">8 Statistics (aggregates)</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="6_Statement_types.html">6 Statement types</A>
48 &nbsp; <B> <A ID="tex2html375"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html377"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html378"
60 HREF="7_Associative_arrays.html#SECTION00081000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN> Examples</A>
61<LI><A ID="tex2html379"
62 HREF="7_Associative_arrays.html#SECTION00082000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">2</SPAN> Types of values</A>
63<LI><A ID="tex2html380"
64 HREF="7_Associative_arrays.html#SECTION00083000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">3</SPAN> Array capacity</A>
65<LI><A ID="tex2html381"
66 HREF="7_Associative_arrays.html#SECTION00084000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">4</SPAN> Array wrapping</A>
67<LI><A ID="tex2html382"
68 HREF="7_Associative_arrays.html#SECTION00085000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">5</SPAN> Iteration, foreach</A>
69<LI><A ID="tex2html383"
70 HREF="7_Associative_arrays.html#SECTION00086000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">6</SPAN> Deletion</A>
71</UL>
72<!--End of Table of Child-Links-->
73<HR>
74
75<H1><A ID="SECTION00080000000000000000"></A><A ID="sec:Associative-Arrays"></A>
76<A NAME="1070"></A>
77<BR>
78<SPAN CLASS="arabic">7</SPAN> Associative arrays
79</H1>
80Associative arrays are implemented as hash tables with a maximum size set
81at startup. Associative arrays are too large to be created dynamically for
82individual probe handler runs, so they must be declared as global. The basic
83operations for arrays are setting and looking up elements. These operations
84are expressed in awk syntax: the array name followed by an opening bracket
85([), a comma-separated list of up to nine index index expressions, and
86a closing bracket (]). Each index expression may be a string or a number,
87as long as it is consistently typed throughout the script.
88
89<P>
90
91<H2><A ID="SECTION00081000000000000000">
92<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN> Examples</A>
93</H2>
94
95<P>
96
97<DL COMPACT>
98<DT>
99<DD><PRE>
100# Increment the named array slot:
101foo [4,"hello"] ++
102
103# Update a statistic:
104processusage [uid(),execname()] ++
105
106# Set a timestamp reference point:
107times [tid()] = get_cycles()
108
109# Compute a timestamp delta:
110delta = get_cycles() - times [tid()]
111</PRE>
112</DD>
113</DL>
114<P>
115
116<H2><A ID="SECTION00082000000000000000">
117<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">2</SPAN> Types of values</A>
118</H2>
119
120<P>
121Array elements may be set to a number, a string, or an aggregate.
122The type must be consistent
123throughout the use of the array. The first assignment to the array defines
124the type of the elements. Unset array elements may be fetched and return
125a null value (zero or empty string) as appropriate, but they are not seen
126by a membership test.
127
128<P>
129
130<H2><A ID="SECTION00083000000000000000">
131<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">3</SPAN> Array capacity</A>
132</H2>
133
134<P>
135Array sizes can be specified explicitly or allowed to default to the maximum
136size as defined by MAXMAPENTRIES. See Section&nbsp;<A HREF="1_SystemTap_overview.html#sub:SystemTap-safety"><IMG ALT="[*]" SRC="crossref.png"></A>
137for details on changing MAXMAPENTRIES.
138
139<P>
140You can explicitly specify the size of an array as follows:
141
142<P>
143
144<DL COMPACT>
145<DT>
146<DD><PRE>
147global ARRAY[&lt;size&gt;]
148</PRE>
149</DD>
150</DL>If you do not specify the size parameter, then the array is created to hold
151MAXMAPENTRIES number of elements.
152
153<P>
154
155<H2><A ID="SECTION00084000000000000000"></A><A ID="sub:Array-Wrapping"></A>
156<BR>
157<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">4</SPAN> Array wrapping
158</H2>
159
160<P>
161Arrays may be wrapped using the percentage symbol (%) causing previously entered
162elements to be overwritten if more elements are inserted than the array can
163hold. This works for both regular and statistics typed arrays.
164
165<P>
166You can mark arrays for wrapping as follows:
167
168<P>
169
170<DL COMPACT>
171<DT>
172<DD><PRE>
173global ARRAY1%[&lt;size&gt;], ARRAY2%
174</PRE>
175</DD>
176</DL>
177<P>
178
179<H2><A ID="SECTION00085000000000000000"></A>
180<A NAME="1090"></A>
181<BR>
182<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">5</SPAN> Iteration, foreach
183</H2>
184Like awk, SystemTap's foreach creates a loop that iterates over key tuples
185of an array, not only values. The iteration may be sorted by any single key
186or a value by adding an extra plus symbol (+) or minus symbol (-) to the
187code or limited to only a few elements with the limit keyword.
188The following are examples.
189
190<P>
191
192<DL COMPACT>
193<DT>
194<DD><PRE>
195# Simple loop in arbitrary sequence:
196foreach ([a,b] in foo)
197 fuss_with(foo[a,b])
198
199# Loop in increasing sequence of value:
200foreach ([a,b] in foo+) { ... }
201
202# Loop in decreasing sequence of first key:
203foreach ([a-,b] in foo) { ... }
204
205# Print the first 10 tuples and values in the array in decreasing sequence
206foreach (v = [i,j] in foo- limit 10)
207 printf("foo[%d,%s] = %d\n", i, j, v)
208</PRE>
209</DD>
210</DL>The <SPAN CLASS="texttt">break</SPAN> and <SPAN CLASS="texttt">continue</SPAN> statements also work inside foreach
211loops. Since arrays can be large but probe handlers must execute quickly,
212you should write scripts that exit iteration early, if possible. For simplicity,
213SystemTap forbids any modification of an array during iteration with a foreach.
214
215<P>
216For a full description of <SPAN CLASS="texttt">foreach</SPAN> see subsection <A HREF="6_Statement_types.html#sub:foreach"><IMG ALT="[*]" SRC="crossref.png"></A>.
217
218<P>
219
220<H2><A ID="SECTION00086000000000000000"></A>
221<A NAME="1100"></A>
222<BR>
223<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">6</SPAN> Deletion
224</H2>
225The <SPAN CLASS="texttt">delete</SPAN> statement can either remove a single element by index from
226an array or clear an entire array at once. See subsection <A HREF="6_Statement_types.html#sub:delete"><IMG ALT="[*]" SRC="crossref.png"></A> for
227details and examples.
228
229<P>
230
231<DIV CLASS="navigation"><HR>
232<!--Navigation Panel-->
233<A
234 HREF="8_Statistics_aggregates.html">
235<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
236<A
237 HREF="langref.html">
238<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
239<A
240 HREF="6_Statement_types.html">
241<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
242<A ID="tex2html374"
243 HREF="Contents.html">
244<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
245<A ID="tex2html376"
246 HREF="Index.html">
247<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
248<BR>
249<B> Next:</B> <A
250 HREF="8_Statistics_aggregates.html">8 Statistics (aggregates)</A>
251<B> Up:</B> <A
252 HREF="langref.html">SystemTap Language Reference</A>
253<B> Previous:</B> <A
254 HREF="6_Statement_types.html">6 Statement types</A>
255 &nbsp; <B> <A ID="tex2html375"
256 HREF="Contents.html">Contents</A></B>
257 &nbsp; <B> <A ID="tex2html377"
258 HREF="Index.html">Index</A></B> </DIV>
259<!--End of Navigation Panel-->
260
261</BODY>
262</HTML>
diff --git a/langref/8_Statistics_aggregates.html b/langref/8_Statistics_aggregates.html
deleted file mode 100644
index b9200fe1..00000000
--- a/langref/8_Statistics_aggregates.html
+++ /dev/null
@@ -1,376 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>8 Statistics (aggregates)</TITLE>
7<META NAME="description" CONTENT="8 Statistics (aggregates)">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="9_Formatted_output.html">
19<LINK REL="previous" HREF="7_Associative_arrays.html">
20<LINK REL="next" HREF="9_Formatted_output.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="9_Formatted_output.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="7_Associative_arrays.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html384"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html386"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="9_Formatted_output.html">9 Formatted output</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="7_Associative_arrays.html">7 Associative arrays</A>
48 &nbsp; <B> <A ID="tex2html385"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html387"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html388"
60 HREF="8_Statistics_aggregates.html#SECTION00091000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN> The aggregation (&lt; &lt; &lt;) operator</A>
61<LI><A ID="tex2html389"
62 HREF="8_Statistics_aggregates.html#SECTION00092000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN> Extraction functions</A>
63<LI><A ID="tex2html390"
64 HREF="8_Statistics_aggregates.html#SECTION00093000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN> Integer extractors</A>
65<UL>
66<LI><A ID="tex2html391"
67 HREF="8_Statistics_aggregates.html#SECTION00093100000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> @count(s)</A>
68<LI><A ID="tex2html392"
69 HREF="8_Statistics_aggregates.html#SECTION00093200000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN> @sum(s)</A>
70<LI><A ID="tex2html393"
71 HREF="8_Statistics_aggregates.html#SECTION00093300000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN> @min(s)</A>
72<LI><A ID="tex2html394"
73 HREF="8_Statistics_aggregates.html#SECTION00093400000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN> @max(s)</A>
74<LI><A ID="tex2html395"
75 HREF="8_Statistics_aggregates.html#SECTION00093500000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN> @avg(s)</A>
76</UL>
77<BR>
78<LI><A ID="tex2html396"
79 HREF="8_Statistics_aggregates.html#SECTION00094000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN> Histogram extractors</A>
80<UL>
81<LI><A ID="tex2html397"
82 HREF="8_Statistics_aggregates.html#SECTION00094100000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> @hist_linear</A>
83<LI><A ID="tex2html398"
84 HREF="8_Statistics_aggregates.html#SECTION00094200000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> @hist_log</A>
85</UL>
86<BR>
87<LI><A ID="tex2html399"
88 HREF="8_Statistics_aggregates.html#SECTION00095000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN> Deletion</A>
89</UL>
90<!--End of Table of Child-Links-->
91<HR>
92
93<H1><A ID="SECTION00090000000000000000"></A><A ID="sec:Statistics"></A>
94<A NAME="1104"></A>
95<BR>
96<SPAN CLASS="arabic">8</SPAN> Statistics (aggregates)
97</H1>
98Aggregate instances are used to collect statistics on numerical values, when
99it is important to accumulate new data quickly and in large volume. These
100instances operate without exclusive locks, and store only aggregated stream
101statistics. Aggregates make sense only for global variables. They are stored
102individually or as elements of an associative array. For information about
103wrapping associative arrays with statistics elements, see section&nbsp;<A HREF="7_Associative_arrays.html#sub:Array-Wrapping"><IMG ALT="[*]" SRC="crossref.png"></A>
104
105<P>
106
107<H2><A ID="SECTION00091000000000000000">
108<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN> The aggregation (&lt; &lt; &lt;) operator</A>
109</H2>
110<A NAME="1399"></A>
111The aggregation operator is &ldquo;&lt; &lt; &lt;&rdquo;,
112and its effect is similar to an assignment or a C++ output streaming operation.
113The left operand specifies a scalar or array-index <SPAN CLASS="textit">l-value</SPAN>, which
114must be declared global. The right operand is a numeric expression. The meaning
115is intuitive: add the given number as a sample to the set of numbers to compute their
116statistics. The specific list of statistics to gather is given separately
117by the extraction functions. The following is an example.
118
119<P>
120
121<DL COMPACT>
122<DT>
123<DD><PRE>
124a &lt;&lt;&lt; delta_timestamp
125writes[execname()] &lt;&lt;&lt; count
126</PRE>
127</DD>
128</DL>
129<P>
130
131<H2><A ID="SECTION00092000000000000000"></A>
132<A NAME="1119"></A>
133<BR>
134<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN> Extraction functions
135</H2>
136For each instance of a distinct extraction function operating on a given
137identifier, the translator computes a set of statistics. With each execution
138of an extraction function, the aggregation is computed for that moment across
139all processors. The first argument of each function is the same style of
140l-value as used on the left side of the aggregation operation.
141
142<P>
143
144<H2><A ID="SECTION00093000000000000000">
145<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN> Integer extractors</A>
146</H2>
147
148<P>
149The following functions provide methods to extract information about aggregate.
150
151<P>
152
153<H3><A ID="SECTION00093100000000000000"></A>
154<A NAME="1122"></A>
155<BR>
156<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> @count(s)
157</H3>
158This statement returns the number of samples accumulated in aggregate s.
159
160<P>
161
162<H3><A ID="SECTION00093200000000000000"></A>
163<A NAME="1124"></A>
164<BR>
165<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN> @sum(s)
166</H3>
167This statement returns the total sum of all samples in aggregate s.
168
169<P>
170
171<H3><A ID="SECTION00093300000000000000"></A>
172<A NAME="1126"></A>
173<BR>
174<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN> @min(s)
175</H3>
176This statement returns the minimum of all samples in aggregate s.
177
178<P>
179
180<H3><A ID="SECTION00093400000000000000"></A>
181<A NAME="1128"></A>
182<BR>
183<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN> @max(s)
184</H3>
185This statement returns the maximum of all samples in aggregate s.
186
187<P>
188
189<H3><A ID="SECTION00093500000000000000"></A>
190<A NAME="1130"></A>
191<BR>
192<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN> @avg(s)
193</H3>
194This statement returns the average value of all samples in aggregate s.
195
196<P>
197
198<H2><A ID="SECTION00094000000000000000"></A>
199<A NAME="1132"></A>
200<BR>
201<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN> Histogram extractors
202</H2>
203The following functions provide methods to extract histogram information.
204Printing a histogram with the print family of functions renders a histogram
205object as a tabular "ASCII art" bar chart.
206
207<P>
208
209<H3><A ID="SECTION00094100000000000000"></A>
210<A NAME="1134"></A>
211<BR>
212<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> @hist_linear
213</H3>
214The statement <SPAN CLASS="texttt">@hist_linear(v,L,H,W)</SPAN> represents a linear histogram
215of aggregate <SPAN CLASS="texttt">v</SPAN>,
216where <SPAN CLASS="textit">L</SPAN> and <SPAN CLASS="textit">H</SPAN> represent the lower and upper end of
217a range of values and <SPAN CLASS="textit">W</SPAN> represents the width (or size) of each bucket
218within the range. The low and high values can be negative, but the overall
219difference (high minus low) must be positive. The width parameter must also
220be positive.
221
222<P>
223In the output, a range of consecutive empty buckets may be replaced with a tilde
224(~) character. This can be controlled on the command line
225with -DHIST_ELISION=&lt; num&gt; ,
226where &lt; num&gt; specifies how many
227empty buckets at the top and bottom of the range to print.
228The default is 2. A &lt; num&gt; of 0
229removes all empty buckets. A negative &lt; num&gt;
230disables removal.
231
232<P>
233For example, if you specify -DHIST_ELISION=3 and the histogram has 10
234consecutive empty buckets, the first 3 and last 3 empty buckets will
235be printed and the middle 4 empty buckets will be represented by a
236tilde (~).
237
238<P>
239The following is an example.
240
241<P>
242
243<DL COMPACT>
244<DT>
245<DD><PRE>
246global reads
247probe netdev.receive {
248 reads &lt;&lt;&lt; length
249}
250probe end {
251 print(@hist_linear(reads, 0, 10240, 200))
252}
253</PRE>
254</DD>
255</DL>This generates the following output.
256
257<P>
258
259<DL COMPACT>
260<DT>
261<DD><PRE>
262value |-------------------------------------------------- count
263 0 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ 1650
264 200 | 8
265 400 | 0
266 600 | 0
267 ~
268 1000 | 0
269 1200 | 0
270 1400 | 1
271 1600 | 0
272 1800 | 0
273</PRE>
274</DD>
275</DL>
276This shows that 1650 network reads were of a size between 0 and 199 bytes,
2778 reads were between 200 and 399 bytes, and 1 read was between
2781200 and 1399 bytes. The tilde (~) character indicates
279the bucket for 800 to 999 bytes was removed because it was empty.
280Empty buckets for 2000 bytes and larger were also removed because they
281were empty.
282
283<P>
284
285<H3><A ID="SECTION00094200000000000000"></A>
286<A NAME="1162"></A>
287<BR>
288<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> @hist_log
289</H3>
290The statement <SPAN CLASS="texttt">@hist_log(v)</SPAN> represents a base-2 logarithmic
291histogram. Empty buckets are replaced with a tilde (~)
292character in the same way as <SPAN CLASS="texttt">@hist_linear()</SPAN> (see above).
293
294<P>
295The following is an example.
296
297<P>
298
299<DL COMPACT>
300<DT>
301<DD><PRE>
302global reads
303probe netdev.receive {
304 reads &lt;&lt;&lt; length
305}
306probe end {
307 print(@hist_log(reads))
308}
309</PRE>
310</DD>
311</DL>This generates the following output.
312
313<P>
314
315<DL COMPACT>
316<DT>
317<DD><PRE>
318value |-------------------------------------------------- count
319 8 | 0
320 16 | 0
321 32 | 254
322 64 | 3
323 128 | 2
324 256 | 2
325 512 | 4
326 1024 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ 16689
327 2048 | 0
328 4096 | 0
329</PRE>
330</DD>
331</DL>
332
333<P>
334
335<H2><A ID="SECTION00095000000000000000"></A>
336<A NAME="1177"></A>
337<BR>
338<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN> Deletion
339</H2>
340The <SPAN CLASS="texttt">delete</SPAN> statement (subsection <A HREF="6_Statement_types.html#sub:delete"><IMG ALT="[*]" SRC="crossref.png"></A>) applied to an
341aggregate variable will reset it to the initial empty state.
342
343<P>
344
345<DIV CLASS="navigation"><HR>
346<!--Navigation Panel-->
347<A
348 HREF="9_Formatted_output.html">
349<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
350<A
351 HREF="langref.html">
352<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
353<A
354 HREF="7_Associative_arrays.html">
355<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
356<A ID="tex2html384"
357 HREF="Contents.html">
358<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
359<A ID="tex2html386"
360 HREF="Index.html">
361<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
362<BR>
363<B> Next:</B> <A
364 HREF="9_Formatted_output.html">9 Formatted output</A>
365<B> Up:</B> <A
366 HREF="langref.html">SystemTap Language Reference</A>
367<B> Previous:</B> <A
368 HREF="7_Associative_arrays.html">7 Associative arrays</A>
369 &nbsp; <B> <A ID="tex2html385"
370 HREF="Contents.html">Contents</A></B>
371 &nbsp; <B> <A ID="tex2html387"
372 HREF="Index.html">Index</A></B> </DIV>
373<!--End of Navigation Panel-->
374
375</BODY>
376</HTML>
diff --git a/langref/9_Formatted_output.html b/langref/9_Formatted_output.html
deleted file mode 100644
index 96efd33f..00000000
--- a/langref/9_Formatted_output.html
+++ /dev/null
@@ -1,479 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>9 Formatted output</TITLE>
7<META NAME="description" CONTENT="9 Formatted output">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="10_Tapset_defined_functions.html">
19<LINK REL="previous" HREF="8_Statistics_aggregates.html">
20<LINK REL="next" HREF="10_Tapset_defined_functions.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="10_Tapset_defined_functions.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="8_Statistics_aggregates.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html400"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<A ID="tex2html402"
39 HREF="Index.html">
40<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
41<BR>
42<B> Next:</B> <A
43 HREF="10_Tapset_defined_functions.html">10 Tapset-defined functions</A>
44<B> Up:</B> <A
45 HREF="langref.html">SystemTap Language Reference</A>
46<B> Previous:</B> <A
47 HREF="8_Statistics_aggregates.html">8 Statistics (aggregates)</A>
48 &nbsp; <B> <A ID="tex2html401"
49 HREF="Contents.html">Contents</A></B>
50 &nbsp; <B> <A ID="tex2html403"
51 HREF="Index.html">Index</A></B>
52<BR>
53<BR></DIV>
54<!--End of Navigation Panel-->
55<!--Table of Child-Links-->
56<A ID="CHILD_LINKS"><STRONG>Subsections</STRONG></A>
57
58<UL CLASS="ChildLinks">
59<LI><A ID="tex2html404"
60 HREF="9_Formatted_output.html#SECTION000101000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN> print</A>
61<LI><A ID="tex2html405"
62 HREF="9_Formatted_output.html#SECTION000102000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN> printf</A>
63<LI><A ID="tex2html406"
64 HREF="9_Formatted_output.html#SECTION000103000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">3</SPAN> printd</A>
65<LI><A ID="tex2html407"
66 HREF="9_Formatted_output.html#SECTION000104000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">4</SPAN> printdln</A>
67<LI><A ID="tex2html408"
68 HREF="9_Formatted_output.html#SECTION000105000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">5</SPAN> println</A>
69<LI><A ID="tex2html409"
70 HREF="9_Formatted_output.html#SECTION000106000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">6</SPAN> sprint</A>
71<LI><A ID="tex2html410"
72 HREF="9_Formatted_output.html#SECTION000107000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">7</SPAN> sprintf</A>
73</UL>
74<!--End of Table of Child-Links-->
75<HR>
76
77<H1><A ID="SECTION000100000000000000000">
78<SPAN CLASS="arabic">9</SPAN> Formatted output</A>
79</H1>
80
81<P>
82
83<H2><A ID="SECTION000101000000000000000"></A>
84<A NAME="1182"></A>
85<BR>
86<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN> print
87</H2>
88General syntax:
89
90<P>
91
92<DL COMPACT>
93<DT>
94<DD><PRE>
95print ()
96</PRE>
97</DD>
98</DL>This function prints a single value of any type.
99
100<P>
101
102<H2><A ID="SECTION000102000000000000000"></A>
103<A NAME="1188"></A>
104<BR>
105<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN> printf
106</H2>
107General syntax:
108
109<P>
110
111<DL COMPACT>
112<DT>
113<DD><PRE>
114printf (fmt:string, ...)
115</PRE>
116</DD>
117</DL>The printf function takes a formatting string as an argument, and a number
118of values of corresponding types, and prints them all. The format must be a
119literal string constant. The printf formatting directives are similar to those
120of C, except that they are fully checked for type by the translator.
121
122<P>
123The formatting string can contain tags that are defined as follows:
124
125<P>
126
127<DL COMPACT>
128<DT>
129<DD><PRE>
130%[flags][width][.precision][length]specifier
131</PRE>
132</DD>
133</DL>Where <SPAN CLASS="texttt">specifier</SPAN> is required and defines the type and the interpretation
134of the value of the corresponding argument. The following table shows the
135details of the specifier parameter:
136
137<P>
138<BR><P></P>
139<DIV class="CENTER">
140
141<A ID="1199"></A>
142<TABLE class="PAD BORDER" style="">
143<CAPTION><STRONG>Table:</STRONG>
144printf specifier values</CAPTION>
145<TR><TH CLASS="LEFT TOP" WIDTH=72>
146<DIV class="LEFT"3688>
147<SPAN CLASS="textbf">Specifier</SPAN>
148</DIV></TH>
149<TH CLASS="LEFT TOP" WIDTH=252>
150<DIV class="LEFT"3690>
151<SPAN CLASS="textbf">Output</SPAN>
152</DIV></TH>
153<TH CLASS="LEFT TOP" WIDTH=90>
154<DIV class="LEFT"3692>
155<SPAN CLASS="textbf">Example</SPAN>
156<BR>
157d or i
158</DIV></TH>
159</TR>
160</TABLE>
161</DIV>
162<BR>
163The tag can also contain <SPAN CLASS="texttt">flags</SPAN>, <SPAN CLASS="texttt">width</SPAN>, <SPAN CLASS="texttt">.precision</SPAN>
164and <SPAN CLASS="texttt">modifiers</SPAN> sub-specifiers, which are optional and follow these
165specifications:
166
167<P>
168<BR><P></P>
169<DIV class="CENTER">
170
171<A ID="1217"></A>
172<TABLE class="PAD BORDER" style="">
173<CAPTION><STRONG>Table:</STRONG>
174printf flag values</CAPTION>
175<TR><TH CLASS="LEFT TOP" WIDTH=108>
176<DIV class="LEFT"3697>
177<SPAN CLASS="textbf">Flags</SPAN>
178</DIV></TH>
179<TH CLASS="LEFT TOP" WIDTH=324>
180<DIV class="LEFT"3699>
181<SPAN CLASS="textbf">Description</SPAN>
182<BR>
183
184- (minus sign)
185</DIV></TH>
186</TR>
187</TABLE>
188</DIV>
189<BR>
190
191<P>
192<BR><P></P>
193<DIV class="CENTER">
194
195<A ID="1236"></A>
196<TABLE class="PAD BORDER" style="">
197<CAPTION><STRONG>Table:</STRONG>
198printf width values</CAPTION>
199<TR><TH CLASS="LEFT TOP" WIDTH=108>
200<DIV class="LEFT"3704>
201<SPAN CLASS="textbf">Width</SPAN>
202</DIV></TH>
203<TH CLASS="LEFT TOP" WIDTH=324>
204<DIV class="LEFT"3706>
205<SPAN CLASS="textbf">Description</SPAN>
206<BR>
207
208(number)
209</DIV></TH>
210</TR>
211</TABLE>
212</DIV>
213<BR>
214
215<P>
216<BR><P></P>
217<DIV class="CENTER">
218
219<P>
220
221<P>
222<A ID="1247"></A>
223<TABLE class="PAD BORDER" style="">
224<CAPTION><STRONG>Table:</STRONG>
225printf precision values</CAPTION>
226<TR><TH CLASS="LEFT TOP" WIDTH=108>
227<DIV class="LEFT"3711>
228<SPAN CLASS="textbf">Precision</SPAN>
229</DIV></TH>
230<TH CLASS="LEFT TOP" WIDTH=324>
231<DIV class="LEFT"3713>
232<SPAN CLASS="textbf">Description</SPAN>
233<BR>
234
235.number
236</DIV></TH>
237</TR>
238</TABLE>
239</DIV>
240<BR>
241
242<P>
243<SPAN CLASS="textbf">Binary Write Examples</SPAN>
244
245<P>
246The following is an example of using the binary write functions:
247
248<P>
249
250<DL COMPACT>
251<DT>
252<DD><PRE>
253probe begin {
254 for (i = 97; i &lt; 110; i++)
255 printf("%3d: %1b%1b%1b\n", i, i, i-32, i-64)
256 exit()
257}
258</PRE>
259</DD>
260</DL>This prints:
261
262<P>
263
264<DL COMPACT>
265<DT>
266<DD><PRE>
267 97: aA!
268 98: bB"
269 99: cC#
270100: dD$
271101: eE%
272102: fF&amp;
273103: gG'
274104: hH(
275105: iI)
276106: jJ*
277107: kK+
278108: lL,
279109: mM-
280</PRE>
281</DD>
282</DL>Another example:
283
284<P>
285
286<DL COMPACT>
287<DT>
288<DD><PRE>
289stap -e 'probe begin{printf("%b%b", 0xc0dedbad, \
2900x12345678);exit()}' | hexdump -C
291</PRE>
292</DD>
293</DL>This prints:
294
295<P>
296
297<DL COMPACT>
298<DT>
299<DD><PRE>
30000000000 ad db de c0 00 00 00 00 78 56 34 12 00 00 00 00 |........xV4.....|
30100000010
302</PRE>
303</DD>
304</DL>Another example:
305
306<P>
307
308<DL COMPACT>
309<DT>
310<DD><PRE>
311probe begin{
312 printf("%1b%1b%1blo %1b%1brld\n", 72,101,108,87,111)
313 exit()
314}
315</PRE>
316</DD>
317</DL>This prints:
318
319<P>
320
321<DL COMPACT>
322<DT>
323<DD><PRE>
324Hello World
325</PRE>
326</DD>
327</DL>
328<P>
329
330<H2><A ID="SECTION000103000000000000000"></A>
331<A NAME="1287"></A>
332<BR>
333<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">3</SPAN> printd
334</H2>
335General syntax:
336
337<P>
338
339<DL COMPACT>
340<DT>
341<DD><PRE>
342printd (delimiter:string, ...)
343</PRE>
344</DD>
345</DL>This function takes a string delimiter and two or more values of any type, then
346prints the values with the delimiter interposed. The delimiter must be a
347literal string constant.
348
349<P>
350For example:
351
352<DL COMPACT>
353<DT>
354<DD><PRE>
355printd("/", "one", "two", "three", 4, 5, 6)
356</PRE>
357</DD>
358</DL>prints:
359
360<DL COMPACT>
361<DT>
362<DD><PRE>
363one/two/three/4/5/6
364</PRE>
365</DD>
366</DL>
367<P>
368
369<H2><A ID="SECTION000104000000000000000"></A>
370<A NAME="1301"></A>
371<BR>
372<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">4</SPAN> printdln
373</H2>
374General syntax:
375
376<P>
377
378<DL COMPACT>
379<DT>
380<DD><PRE>
381printdln (delimiter:string, ...)
382</PRE>
383</DD>
384</DL>This function operates like <SPAN CLASS="texttt">printd</SPAN>, but also appends a newline.
385
386<P>
387
388<H2><A ID="SECTION000105000000000000000"></A>
389<A NAME="1308"></A>
390<BR>
391<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">5</SPAN> println
392</H2>
393General syntax:
394
395<P>
396
397<DL COMPACT>
398<DT>
399<DD><PRE>
400println ()
401</PRE>
402</DD>
403</DL>This function prints a single value like <SPAN CLASS="texttt">print</SPAN>,
404but also appends a newline.
405
406<P>
407
408<H2><A ID="SECTION000106000000000000000"></A>
409<A NAME="1315"></A>
410<BR>
411<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">6</SPAN> sprint
412</H2>
413General syntax:
414
415<P>
416
417<DL COMPACT>
418<DT>
419<DD><PRE>
420sprint:string ()
421</PRE>
422</DD>
423</DL>This function operates like <SPAN CLASS="texttt">print</SPAN>, but returns the string rather
424than printing it.
425
426<P>
427
428<H2><A ID="SECTION000107000000000000000"></A>
429<A NAME="1322"></A>
430<BR>
431<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">7</SPAN> sprintf
432</H2>
433General syntax:
434
435<P>
436
437<DL COMPACT>
438<DT>
439<DD><PRE>
440sprintf:string (fmt:string, ...)
441</PRE>
442</DD>
443</DL>This function operates like <SPAN CLASS="texttt">printf</SPAN>, but returns the formatted string
444rather than printing it.
445
446<P>
447
448<DIV CLASS="navigation"><HR>
449<!--Navigation Panel-->
450<A
451 HREF="10_Tapset_defined_functions.html">
452<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
453<A
454 HREF="langref.html">
455<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
456<A
457 HREF="8_Statistics_aggregates.html">
458<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
459<A ID="tex2html400"
460 HREF="Contents.html">
461<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
462<A ID="tex2html402"
463 HREF="Index.html">
464<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
465<BR>
466<B> Next:</B> <A
467 HREF="10_Tapset_defined_functions.html">10 Tapset-defined functions</A>
468<B> Up:</B> <A
469 HREF="langref.html">SystemTap Language Reference</A>
470<B> Previous:</B> <A
471 HREF="8_Statistics_aggregates.html">8 Statistics (aggregates)</A>
472 &nbsp; <B> <A ID="tex2html401"
473 HREF="Contents.html">Contents</A></B>
474 &nbsp; <B> <A ID="tex2html403"
475 HREF="Index.html">Index</A></B> </DIV>
476<!--End of Navigation Panel-->
477
478</BODY>
479</HTML>
diff --git a/langref/About_this_document.html b/langref/About_this_document.html
deleted file mode 100644
index 2796f81e..00000000
--- a/langref/About_this_document.html
+++ /dev/null
@@ -1,64 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>About this document ...</TITLE>
7<META NAME="description" CONTENT="About this document ...">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="previous" HREF="Index.html">
19</HEAD>
20
21<BODY >
22
23<DIV CLASS="navigation"><!--Navigation Panel-->
24<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next_g.png">
25<A
26 HREF="langref.html">
27<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
28<A
29 HREF="Index.html">
30<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
31<A ID="tex2html421"
32 HREF="Contents.html">
33<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
34<A ID="tex2html423"
35 HREF="Index.html">
36<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
37<BR>
38<B> Up:</B> <A
39 HREF="langref.html">SystemTap Language Reference</A>
40<B> Previous:</B> <A
41 HREF="Index.html">Index</A>
42 &nbsp; <B> <A ID="tex2html422"
43 HREF="Contents.html">Contents</A></B>
44 &nbsp; <B> <A ID="tex2html424"
45 HREF="Index.html">Index</A></B>
46<BR>
47<BR></DIV>
48<!--End of Navigation Panel-->
49
50<H1><A ID="SECTION000140000000000000000">
51About this document ...</A>
52</H1>
53 <STRONG>SystemTap Language Reference</STRONG><P>
54This document was generated using the
55<A HREF="http://www.latex2html.org/">LaTeX2HTML</A> translator Version 2018.3 (Released July 19, 2018)
56<P>
57The command line arguments were: <BR>
58 <kbd>latex2html -noaddress -show_section_numbers -custom_titles -local_icons -split 4 langref.tex -dir /tmp/stapdocs0r5/htdocs/langref/</kbd>
59<P>
60The translation was initiated on 2019-05-07
61<BR><HR>
62
63</BODY>
64</HTML>
diff --git a/langref/Contents.html b/langref/Contents.html
deleted file mode 100644
index adb89ac6..00000000
--- a/langref/Contents.html
+++ /dev/null
@@ -1,251 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>Contents</TITLE>
7<META NAME="description" CONTENT="Contents">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="1_SystemTap_overview.html">
19<LINK REL="previous" HREF="langref.html">
20<LINK REL="next" HREF="1_SystemTap_overview.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="1_SystemTap_overview.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="langref.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html162"
36 HREF="Index.html">
37<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
38<BR>
39<B> Next:</B> <A
40 HREF="1_SystemTap_overview.html">1 SystemTap overview</A>
41<B> Up:</B> <A
42 HREF="langref.html">SystemTap Language Reference</A>
43<B> Previous:</B> <A
44 HREF="langref.html">SystemTap Language Reference</A>
45 &nbsp; <B> <A ID="tex2html163"
46 HREF="Index.html">Index</A></B>
47<BR>
48<BR></DIV>
49<!--End of Navigation Panel-->
50<BR>
51
52<H2><A ID="SECTION00010000000000000000">
53Contents</A>
54</H2>
55<!--Table of Contents-->
56
57<UL CLASS="TofC">
58<LI><A ID="tex2html164"
59 HREF="1_SystemTap_overview.html">1 SystemTap overview</A>
60<UL>
61<LI><A ID="tex2html165"
62 HREF="1_SystemTap_overview.html#SECTION00021000000000000000">1.1 About this guide</A>
63<LI><A ID="tex2html166"
64 HREF="1_SystemTap_overview.html#SECTION00022000000000000000">1.2 Reasons to use SystemTap</A>
65<LI><A ID="tex2html167"
66 HREF="1_SystemTap_overview.html#SECTION00023000000000000000">1.3 Event-action language</A>
67<LI><A ID="tex2html168"
68 HREF="1_SystemTap_overview.html#SECTION00024000000000000000">1.4 Sample SystemTap scripts</A>
69<LI><A ID="tex2html169"
70 HREF="1_SystemTap_overview.html#SECTION00025000000000000000">1.5 The stap command</A>
71<LI><A ID="tex2html170"
72 HREF="1_SystemTap_overview.html#SECTION00026000000000000000">1.6 Safety and security</A>
73</UL>
74<BR>
75<LI><A ID="tex2html171"
76 HREF="2_Types_SystemTap_scripts.html">2 Types of SystemTap scripts</A>
77<UL>
78<LI><A ID="tex2html172"
79 HREF="2_Types_SystemTap_scripts.html#SECTION00031000000000000000">2.1 Probe scripts</A>
80<LI><A ID="tex2html173"
81 HREF="2_Types_SystemTap_scripts.html#SECTION00032000000000000000">2.2 Tapset scripts</A>
82</UL>
83<BR>
84<LI><A ID="tex2html174"
85 HREF="3_Components_SystemTap_scri.html">3 Components of a SystemTap script</A>
86<UL>
87<LI><A ID="tex2html175"
88 HREF="3_Components_SystemTap_scri.html#SECTION00041000000000000000">3.1 Probe definitions</A>
89<LI><A ID="tex2html176"
90 HREF="3_Components_SystemTap_scri.html#SECTION00042000000000000000">3.2 Probe aliases</A>
91<LI><A ID="tex2html177"
92 HREF="3_Components_SystemTap_scri.html#SECTION00043000000000000000">3.3 Variables</A>
93<LI><A ID="tex2html178"
94 HREF="3_Components_SystemTap_scri.html#SECTION00044000000000000000">3.4 Auxiliary functions</A>
95<LI><A ID="tex2html179"
96 HREF="3_Components_SystemTap_scri.html#SECTION00045000000000000000">3.5 Embedded C</A>
97<LI><A ID="tex2html180"
98 HREF="3_Components_SystemTap_scri.html#SECTION00046000000000000000">3.6 Embedded C functions</A>
99<LI><A ID="tex2html181"
100 HREF="3_Components_SystemTap_scri.html#SECTION00047000000000000000">3.7 Embedded C pragma comments</A>
101<LI><A ID="tex2html182"
102 HREF="3_Components_SystemTap_scri.html#SECTION00048000000000000000">3.8 Accessing script level global variables</A>
103</UL>
104<BR>
105<LI><A ID="tex2html183"
106 HREF="4_Probe_points.html">4 Probe points</A>
107<UL>
108<LI><A ID="tex2html184"
109 HREF="4_Probe_points.html#SECTION00051000000000000000">4.1 General syntax</A>
110<LI><A ID="tex2html185"
111 HREF="4_Probe_points.html#SECTION00052000000000000000">4.2 Built-in probe point types (DWARF probes)</A>
112<LI><A ID="tex2html186"
113 HREF="4_Probe_points.html#SECTION00053000000000000000">4.3 Function return probes</A>
114<LI><A ID="tex2html187"
115 HREF="4_Probe_points.html#SECTION00054000000000000000">4.4 DWARF-less probing</A>
116<LI><A ID="tex2html188"
117 HREF="4_Probe_points.html#SECTION00055000000000000000">4.5 Userspace probing</A>
118<LI><A ID="tex2html189"
119 HREF="4_Probe_points.html#SECTION00056000000000000000">4.6 Java probes</A>
120<LI><A ID="tex2html190"
121 HREF="4_Probe_points.html#SECTION00057000000000000000">4.7 PROCFS probes</A>
122<LI><A ID="tex2html191"
123 HREF="4_Probe_points.html#SECTION00058000000000000000">4.8 Marker probes</A>
124<LI><A ID="tex2html192"
125 HREF="4_Probe_points.html#SECTION00059000000000000000">4.9 Tracepoints</A>
126<LI><A ID="tex2html193"
127 HREF="4_Probe_points.html#SECTION000510000000000000000">4.10 Syscall probes</A>
128<LI><A ID="tex2html194"
129 HREF="4_Probe_points.html#SECTION000511000000000000000">4.11 Timer probes</A>
130<LI><A ID="tex2html195"
131 HREF="4_Probe_points.html#SECTION000512000000000000000">4.12 Special probe points</A>
132</UL>
133<BR>
134<LI><A ID="tex2html196"
135 HREF="5_Language_elements.html">5 Language elements</A>
136<UL>
137<LI><A ID="tex2html197"
138 HREF="5_Language_elements.html#SECTION00061000000000000000">5.1 Identifiers</A>
139<LI><A ID="tex2html198"
140 HREF="5_Language_elements.html#SECTION00062000000000000000">5.2 Data types</A>
141<LI><A ID="tex2html199"
142 HREF="5_Language_elements.html#SECTION00063000000000000000">5.3 Semicolons</A>
143<LI><A ID="tex2html200"
144 HREF="5_Language_elements.html#SECTION00064000000000000000">5.4 Comments</A>
145<LI><A ID="tex2html201"
146 HREF="5_Language_elements.html#SECTION00065000000000000000">5.5 Whitespace</A>
147<LI><A ID="tex2html202"
148 HREF="5_Language_elements.html#SECTION00066000000000000000">5.6 Expressions</A>
149<LI><A ID="tex2html203"
150 HREF="5_Language_elements.html#SECTION00067000000000000000">5.7 Literals passed in from the stap command line</A>
151<LI><A ID="tex2html204"
152 HREF="5_Language_elements.html#SECTION00068000000000000000">5.8 Conditional compilation</A>
153<LI><A ID="tex2html205"
154 HREF="5_Language_elements.html#SECTION00069000000000000000">5.9 Preprocessor macros</A>
155</UL>
156<BR>
157<LI><A ID="tex2html206"
158 HREF="6_Statement_types.html">6 Statement types</A>
159<UL>
160<LI><A ID="tex2html207"
161 HREF="6_Statement_types.html#SECTION00071000000000000000">6.1 break and continue</A>
162<LI><A ID="tex2html208"
163 HREF="6_Statement_types.html#SECTION00072000000000000000">6.2 try/catch</A>
164<LI><A ID="tex2html209"
165 HREF="6_Statement_types.html#SECTION00073000000000000000">6.3 delete</A>
166<LI><A ID="tex2html210"
167 HREF="6_Statement_types.html#SECTION00074000000000000000">6.4 EXP (expression)</A>
168<LI><A ID="tex2html211"
169 HREF="6_Statement_types.html#SECTION00075000000000000000">6.5 for</A>
170<LI><A ID="tex2html212"
171 HREF="6_Statement_types.html#SECTION00076000000000000000">6.6 foreach</A>
172<LI><A ID="tex2html213"
173 HREF="6_Statement_types.html#SECTION00077000000000000000">6.7 if</A>
174<LI><A ID="tex2html214"
175 HREF="6_Statement_types.html#SECTION00078000000000000000">6.8 next</A>
176<LI><A ID="tex2html215"
177 HREF="6_Statement_types.html#SECTION00079000000000000000">6.9 ; (null statement)</A>
178<LI><A ID="tex2html216"
179 HREF="6_Statement_types.html#SECTION000710000000000000000">6.10 return</A>
180<LI><A ID="tex2html217"
181 HREF="6_Statement_types.html#SECTION000711000000000000000">6.11 { } (statement block)</A>
182<LI><A ID="tex2html218"
183 HREF="6_Statement_types.html#SECTION000712000000000000000">6.12 while</A>
184</UL>
185<BR>
186<LI><A ID="tex2html219"
187 HREF="7_Associative_arrays.html">7 Associative arrays</A>
188<UL>
189<LI><A ID="tex2html220"
190 HREF="7_Associative_arrays.html#SECTION00081000000000000000">7.1 Examples</A>
191<LI><A ID="tex2html221"
192 HREF="7_Associative_arrays.html#SECTION00082000000000000000">7.2 Types of values</A>
193<LI><A ID="tex2html222"
194 HREF="7_Associative_arrays.html#SECTION00083000000000000000">7.3 Array capacity</A>
195<LI><A ID="tex2html223"
196 HREF="7_Associative_arrays.html#SECTION00084000000000000000">7.4 Array wrapping</A>
197<LI><A ID="tex2html224"
198 HREF="7_Associative_arrays.html#SECTION00085000000000000000">7.5 Iteration, foreach</A>
199<LI><A ID="tex2html225"
200 HREF="7_Associative_arrays.html#SECTION00086000000000000000">7.6 Deletion</A>
201</UL>
202<BR>
203<LI><A ID="tex2html226"
204 HREF="8_Statistics_aggregates.html">8 Statistics (aggregates)</A>
205<UL>
206<LI><A ID="tex2html227"
207 HREF="8_Statistics_aggregates.html#SECTION00091000000000000000">8.1 The aggregation (&lt; &lt; &lt;) operator</A>
208<LI><A ID="tex2html228"
209 HREF="8_Statistics_aggregates.html#SECTION00092000000000000000">8.2 Extraction functions</A>
210<LI><A ID="tex2html229"
211 HREF="8_Statistics_aggregates.html#SECTION00093000000000000000">8.3 Integer extractors</A>
212<LI><A ID="tex2html230"
213 HREF="8_Statistics_aggregates.html#SECTION00094000000000000000">8.4 Histogram extractors</A>
214<LI><A ID="tex2html231"
215 HREF="8_Statistics_aggregates.html#SECTION00095000000000000000">8.5 Deletion</A>
216</UL>
217<BR>
218<LI><A ID="tex2html232"
219 HREF="9_Formatted_output.html">9 Formatted output</A>
220<UL>
221<LI><A ID="tex2html233"
222 HREF="9_Formatted_output.html#SECTION000101000000000000000">9.1 print</A>
223<LI><A ID="tex2html234"
224 HREF="9_Formatted_output.html#SECTION000102000000000000000">9.2 printf</A>
225<LI><A ID="tex2html235"
226 HREF="9_Formatted_output.html#SECTION000103000000000000000">9.3 printd</A>
227<LI><A ID="tex2html236"
228 HREF="9_Formatted_output.html#SECTION000104000000000000000">9.4 printdln</A>
229<LI><A ID="tex2html237"
230 HREF="9_Formatted_output.html#SECTION000105000000000000000">9.5 println</A>
231<LI><A ID="tex2html238"
232 HREF="9_Formatted_output.html#SECTION000106000000000000000">9.6 sprint</A>
233<LI><A ID="tex2html239"
234 HREF="9_Formatted_output.html#SECTION000107000000000000000">9.7 sprintf</A>
235</UL>
236<BR>
237<LI><A ID="tex2html240"
238 HREF="10_Tapset_defined_functions.html">10 Tapset-defined functions</A>
239<LI><A ID="tex2html241"
240 HREF="11_Further_Reference.html">11 For Further Reference</A>
241<LI><A ID="tex2html242"
242 HREF="Index.html">Index</A>
243</UL>
244<!--End of Table of Contents-->
245
246
247<P>
248<BR><HR>
249
250</BODY>
251</HTML>
diff --git a/langref/Index.html b/langref/Index.html
deleted file mode 100644
index ccde10ae..00000000
--- a/langref/Index.html
+++ /dev/null
@@ -1,299 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>Index</TITLE>
7<META NAME="description" CONTENT="Index">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="About_this_document.html">
19<LINK REL="previous" HREF="11_Further_Reference.html">
20<LINK REL="next" HREF="About_this_document.html">
21</HEAD>
22
23<BODY >
24
25<DIV CLASS="navigation"><!--Navigation Panel-->
26<A
27 HREF="About_this_document.html">
28<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
29<A
30 HREF="langref.html">
31<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up.png"></A>
32<A
33 HREF="11_Further_Reference.html">
34<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev.png"></A>
35<A ID="tex2html419"
36 HREF="Contents.html">
37<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
38<BR>
39<B> Next:</B> <A
40 HREF="About_this_document.html">About this document ...</A>
41<B> Up:</B> <A
42 HREF="langref.html">SystemTap Language Reference</A>
43<B> Previous:</B> <A
44 HREF="11_Further_Reference.html">11 For Further Reference</A>
45 &nbsp; <B> <A ID="tex2html420"
46 HREF="Contents.html">Contents</A></B>
47<BR>
48<BR></DIV>
49<!--End of Navigation Panel-->
50<BR>
51
52<H2><A ID="SECTION000130000000000000000">
53Index</A>
54</H2><DL COMPACT>
55<DT><STRONG>$</STRONG>
56<DD><A HREF="5_Language_elements.html#867"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
57<DT><STRONG>+=</STRONG>
58<DD><A HREF="3_Components_SystemTap_scri.html#161"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
59<DT><STRONG>;</STRONG>
60<DD><A HREF="5_Language_elements.html#772"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
61 | <A HREF="6_Statement_types.html#1041"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN></A>
62<DT><STRONG>&lt; &lt; &lt;</STRONG>
63<DD><A HREF="8_Statistics_aggregates.html#1399"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
64<DT><STRONG>=</STRONG>
65<DD><A HREF="3_Components_SystemTap_scri.html#154"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
66<DT><STRONG>?</STRONG>
67<DD><A HREF="4_Probe_points.html#309"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
68 | <A HREF="5_Language_elements.html#815"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN></A>
69<DT><STRONG>{ }</STRONG>
70<DD><A HREF="6_Statement_types.html#1056"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN></A>
71<DT><STRONG>aggregates</STRONG>
72<DD><A HREF="8_Statistics_aggregates.html#1104"><SPAN CLASS="arabic">8</SPAN></A>
73<DT><STRONG>arch</STRONG>
74<DD><A HREF="5_Language_elements.html#923"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
75<DT><STRONG>associative arrays</STRONG>
76<DD><A HREF="7_Associative_arrays.html#1070"><SPAN CLASS="arabic">7</SPAN></A>
77<DT><STRONG>asynchronous</STRONG>
78<DD><A HREF="4_Probe_points.html#292"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
79<DT><STRONG>auxiliary functions</STRONG>
80<DD><A HREF="3_Components_SystemTap_scri.html#203"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
81<DT><STRONG>avg</STRONG>
82<DD><A HREF="8_Statistics_aggregates.html#1130"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
83<DT><STRONG>begin</STRONG>
84<DD><A HREF="4_Probe_points.html#707"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
85<DT><STRONG>binary</STRONG>
86<DD><A HREF="5_Language_elements.html#784"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
87 | <A HREF="5_Language_elements.html#792"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
88<DT><STRONG>braceexpansion</STRONG>
89<DD><A HREF="4_Probe_points.html#315"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
90<DT><STRONG>break</STRONG>
91<DD><A HREF="6_Statement_types.html#965"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
92<DT><STRONG>built-in probes</STRONG>
93<DD><A HREF="4_Probe_points.html#321"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
94<DT><STRONG>catch</STRONG>
95<DD><A HREF="6_Statement_types.html#973"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
96<DT><STRONG>comments</STRONG>
97<DD><A HREF="5_Language_elements.html#774"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
98<DT><STRONG>comparison</STRONG>
99<DD><A HREF="5_Language_elements.html#807"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
100<DT><STRONG>conditions</STRONG>
101<DD><A HREF="5_Language_elements.html#888"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
102<DT><STRONG>constraints</STRONG>
103<DD><A HREF="1_SystemTap_overview.html#96"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
104<DT><STRONG>continue</STRONG>
105<DD><A HREF="6_Statement_types.html#966"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
106<DT><STRONG>count</STRONG>
107<DD><A HREF="8_Statistics_aggregates.html#1122"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
108<DT><STRONG>data types</STRONG>
109<DD><A HREF="5_Language_elements.html#748"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
110<DT><STRONG>defined target variable</STRONG>
111<DD><A HREF="5_Language_elements.html#899"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
112<DT><STRONG>delete</STRONG>
113<DD><A HREF="6_Statement_types.html#981"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
114 | <A HREF="7_Associative_arrays.html#1100"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
115 | <A HREF="8_Statistics_aggregates.html#1177"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
116<DT><STRONG>dwarf probes</STRONG>
117<DD><A HREF="4_Probe_points.html#322"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
118<DT><STRONG>DWARF-less probing</STRONG>
119<DD><A HREF="4_Probe_points.html#411"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
120<DT><STRONG>embedded C</STRONG>
121<DD><A HREF="3_Components_SystemTap_scri.html#238"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
122<DT><STRONG>end</STRONG>
123<DD><A HREF="4_Probe_points.html#711"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
124<DT><STRONG>epilogue-style aliases</STRONG>
125<DD><A HREF="3_Components_SystemTap_scri.html#160"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
126<DT><STRONG>error</STRONG>
127<DD><A HREF="4_Probe_points.html#717"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
128<DT><STRONG>example scripts</STRONG>
129<DD><A HREF="1_SystemTap_overview.html#52"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
130<DT><STRONG>expression</STRONG>
131<DD><A HREF="6_Statement_types.html#998"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
132<DT><STRONG>expressions</STRONG>
133<DD><A HREF="5_Language_elements.html#782"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
134<DT><STRONG>extraction</STRONG>
135<DD><A HREF="8_Statistics_aggregates.html#1119"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
136<DT><STRONG>fn</STRONG>
137<DD><A HREF="5_Language_elements.html#821"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN></A>
138<DT><STRONG>for</STRONG>
139<DD><A HREF="6_Statement_types.html#1001"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
140<DT><STRONG>foreach</STRONG>
141<DD><A HREF="6_Statement_types.html#1010"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
142 | <A HREF="7_Associative_arrays.html#1090"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
143<DT><STRONG>grouping</STRONG>
144<DD><A HREF="5_Language_elements.html#818"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN></A>
145<DT><STRONG>guru mode</STRONG>
146<DD><A HREF="3_Components_SystemTap_scri.html#239"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
147<DT><STRONG>hist_linear</STRONG>
148<DD><A HREF="8_Statistics_aggregates.html#1134"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
149<DT><STRONG>hist_log</STRONG>
150<DD><A HREF="8_Statistics_aggregates.html#1162"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
151<DT><STRONG>histograms</STRONG>
152<DD><A HREF="8_Statistics_aggregates.html#1132"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
153<DT><STRONG>identifiers</STRONG>
154<DD><A HREF="5_Language_elements.html#745"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
155<DT><STRONG>if</STRONG>
156<DD><A HREF="6_Statement_types.html#1030"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN></A>
157<DT><STRONG>index</STRONG>
158<DD><A HREF="5_Language_elements.html#859"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN></A>
159<DT><STRONG>inference</STRONG>
160<DD><A HREF="5_Language_elements.html#749"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
161<DT><STRONG>integers</STRONG>
162<DD><A HREF="5_Language_elements.html#755"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
163<DT><STRONG>Java probes</STRONG>
164<DD><A HREF="4_Probe_points.html#592"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
165<DT><STRONG>jiffies</STRONG>
166<DD><A HREF="4_Probe_points.html#680"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">11</SPAN></A>
167<DT><STRONG>kernel version</STRONG>
168<DD><A HREF="5_Language_elements.html#905"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
169<DT><STRONG>kernel.function</STRONG>
170<DD><A HREF="4_Probe_points.html#382"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
171<DT><STRONG>kernel.statement</STRONG>
172<DD><A HREF="4_Probe_points.html#394"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
173<DT><STRONG>kernel_v</STRONG>
174<DD><A HREF="5_Language_elements.html#907"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
175<DT><STRONG>kernel_vr</STRONG>
176<DD><A HREF="5_Language_elements.html#906"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
177<DT><STRONG>language</STRONG>
178<DD><A HREF="1_SystemTap_overview.html#48"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
179<DT><STRONG>limits</STRONG>
180<DD><A HREF="1_SystemTap_overview.html#93"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
181<DT><STRONG>literals</STRONG>
182<DD><A HREF="5_Language_elements.html#751"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
183 | <A HREF="5_Language_elements.html#862"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN></A>
184<DT><STRONG>local arrays</STRONG>
185<DD><A HREF="3_Components_SystemTap_scri.html#187"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
186<DT><STRONG>marker probes</STRONG>
187<DD><A HREF="4_Probe_points.html#634"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">8</SPAN></A>
188<DT><STRONG>max</STRONG>
189<DD><A HREF="8_Statistics_aggregates.html#1128"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
190<DT><STRONG>milliseconds</STRONG>
191<DD><A HREF="4_Probe_points.html#694"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">11</SPAN></A>
192<DT><STRONG>min</STRONG>
193<DD><A HREF="8_Statistics_aggregates.html#1126"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
194<DT><STRONG>module().function</STRONG>
195<DD><A HREF="4_Probe_points.html#383"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
196<DT><STRONG>module().statement</STRONG>
197<DD><A HREF="4_Probe_points.html#395"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
198<DT><STRONG>never</STRONG>
199<DD><A HREF="4_Probe_points.html#739"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
200<DT><STRONG>next</STRONG>
201<DD><A HREF="6_Statement_types.html#1038"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN></A>
202<DT><STRONG>null statement</STRONG>
203<DD><A HREF="6_Statement_types.html#1042"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN></A>
204<DT><STRONG>numbers</STRONG>
205<DD><A HREF="5_Language_elements.html#756"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
206<DT><STRONG>numeric</STRONG>
207<DD><A HREF="5_Language_elements.html#795"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
208<DT><STRONG>pointer</STRONG>
209<DD><A HREF="5_Language_elements.html#824"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN></A>
210<DT><STRONG>Pointer typecasting</STRONG>
211<DD><A HREF="5_Language_elements.html#827"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN></A>
212<DT><STRONG>prefixes</STRONG>
213<DD><A HREF="4_Probe_points.html#294"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
214<DT><STRONG>print</STRONG>
215<DD><A HREF="9_Formatted_output.html#1182"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
216<DT><STRONG>printd</STRONG>
217<DD><A HREF="9_Formatted_output.html#1287"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
218<DT><STRONG>printdln</STRONG>
219<DD><A HREF="9_Formatted_output.html#1301"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
220<DT><STRONG>printf</STRONG>
221<DD><A HREF="9_Formatted_output.html#1188"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
222<DT><STRONG>println</STRONG>
223<DD><A HREF="9_Formatted_output.html#1308"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
224<DT><STRONG>probe aliases</STRONG>
225<DD><A HREF="3_Components_SystemTap_scri.html#133"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
226<DT><STRONG>probe points</STRONG>
227<DD><A HREF="4_Probe_points.html#282"><SPAN CLASS="arabic">4</SPAN></A>
228<DT><STRONG>probe sequence</STRONG>
229<DD><A HREF="4_Probe_points.html#727"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">4</SPAN></A>
230<DT><STRONG>probe syntax</STRONG>
231<DD><A HREF="4_Probe_points.html#284"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
232<DT><STRONG>process</STRONG>
233<DD><A HREF="4_Probe_points.html#441"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
234<DT><STRONG>PROCFS probes</STRONG>
235<DD><A HREF="4_Probe_points.html#610"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">7</SPAN></A>
236<DT><STRONG>prologue-style aliases</STRONG>
237<DD><A HREF="3_Components_SystemTap_scri.html#153"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
238<DT><STRONG>randomize</STRONG>
239<DD><A HREF="4_Probe_points.html#687"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">11</SPAN></A>
240<DT><STRONG>recursion</STRONG>
241<DD><A HREF="1_SystemTap_overview.html#74"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
242<DT><STRONG>return</STRONG>
243<DD><A HREF="6_Statement_types.html#1048"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN></A>
244<DT><STRONG>return probes</STRONG>
245<DD><A HREF="4_Probe_points.html#406"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
246<DT><STRONG>sprint</STRONG>
247<DD><A HREF="9_Formatted_output.html#1315"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
248<DT><STRONG>sprintf</STRONG>
249<DD><A HREF="9_Formatted_output.html#1322"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">7</SPAN></A>
250<DT><STRONG>stap</STRONG>
251<DD><A HREF="1_SystemTap_overview.html#86"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
252<DT><STRONG>STAP_ARG_</STRONG>
253<DD><A HREF="3_Components_SystemTap_scri.html#261"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
254<DT><STRONG>STAP_RETVALUE</STRONG>
255<DD><A HREF="3_Components_SystemTap_scri.html#264"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
256<DT><STRONG>statement block</STRONG>
257<DD><A HREF="6_Statement_types.html#1057"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN></A>
258<DT><STRONG>strings</STRONG>
259<DD><A HREF="5_Language_elements.html#760"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
260<DT><STRONG>suffixes</STRONG>
261<DD><A HREF="4_Probe_points.html#299"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
262<DT><STRONG>sum</STRONG>
263<DD><A HREF="8_Statistics_aggregates.html#1124"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
264<DT><STRONG>synchronous</STRONG>
265<DD><A HREF="4_Probe_points.html#290"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
266<DT><STRONG>syscall probes</STRONG>
267<DD><A HREF="4_Probe_points.html#665"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">10</SPAN></A>
268<DT><STRONG>systemtap_privilege</STRONG>
269<DD><A HREF="5_Language_elements.html#926"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
270<DT><STRONG>target variables</STRONG>
271<DD><A HREF="3_Components_SystemTap_scri.html#131"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
272<DT><STRONG>timer probes</STRONG>
273<DD><A HREF="4_Probe_points.html#679"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">11</SPAN></A>
274<DT><STRONG>tokens</STRONG>
275<DD><A HREF="5_Language_elements.html#929"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">6</SPAN></A>
276<DT><STRONG>tracepoints</STRONG>
277<DD><A HREF="4_Probe_points.html#650"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">9</SPAN></A>
278<DT><STRONG>try</STRONG>
279<DD><A HREF="6_Statement_types.html#972"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN></A>
280<DT><STRONG>unary</STRONG>
281<DD><A HREF="5_Language_elements.html#803"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
282<DT><STRONG>unused variables</STRONG>
283<DD><A HREF="3_Components_SystemTap_scri.html#200"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN></A>
284<DT><STRONG>userspace probing</STRONG>
285<DD><A HREF="4_Probe_points.html#440"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
286<DT><STRONG>variables</STRONG>
287<DD><A HREF="3_Components_SystemTap_scri.html#186"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
288<DT><STRONG>while</STRONG>
289<DD><A HREF="6_Statement_types.html#1063"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN></A>
290<DT><STRONG>whitespace</STRONG>
291<DD><A HREF="5_Language_elements.html#780"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN></A>
292<DT><STRONG>wildcards</STRONG>
293<DD><A HREF="4_Probe_points.html#302"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN></A>
294
295</DL>
296<BR><HR>
297
298</BODY>
299</HTML>
diff --git a/langref/index.html b/langref/index.html
deleted file mode 100644
index f0742299..00000000
--- a/langref/index.html
+++ /dev/null
@@ -1,435 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>SystemTap Language Reference</TITLE>
7<META NAME="description" CONTENT="SystemTap Language Reference">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="Contents.html">
19</HEAD>
20
21<BODY >
22
23<DIV CLASS="navigation"><!--Navigation Panel-->
24<A
25 HREF="Contents.html">
26<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
27<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up_g.png">
28<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev_g.png">
29<A ID="tex2html12"
30 HREF="Contents.html">
31<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
32<A ID="tex2html14"
33 HREF="Index.html">
34<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
35<BR>
36<B> Next:</B> <A
37 HREF="Contents.html">Contents</A>
38 &nbsp; <B> <A ID="tex2html13"
39 HREF="Contents.html">Contents</A></B>
40 &nbsp; <B> <A ID="tex2html15"
41 HREF="Index.html">Index</A></B>
42<BR>
43<BR></DIV>
44<!--End of Navigation Panel-->
45
46<P>
47
48<P>
49<H1 class="CENTER">SystemTap Language Reference</H1>
50<DIV CLASS="author_info">
51
52</DIV>
53This document was derived from other documents contributed to the SystemTap project by employees of Red Hat, IBM and Intel.
54<BR>
55
56<P>
57Copyright &#169; 2007-2013 Red Hat Inc.
58<BR>
59Copyright &#169; 2007-2009 IBM Corp.
60<BR>
61Copyright &#169; 2007 Intel Corporation.
62<BR>
63
64<P>
65Permission is granted to copy, distribute and/or modify this document
66under the terms of the GNU Free Documentation License, Version 1.2
67or any later version published by the Free Software Foundation;
68with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
69<BR>
70
71<P>
72The GNU Free Documentation License is available from
73<kbd><A ID="tex2html1"
74 HREF="http://www.gnu.org/licenses/fdl.html">http://www.gnu.org/licenses/fdl.html</A></kbd> or by writing to
75the Free Software Foundation, Inc., 51 Franklin Street,
76Fifth Floor, Boston, MA 02110-1301, USA.
77
78<BR><HR>
79<!--Table of Child-Links-->
80<A ID="CHILD_LINKS"></A>
81
82<UL CLASS="ChildLinks">
83<LI><A ID="tex2html16"
84 HREF="Contents.html">Contents</A>
85<LI><A ID="tex2html17"
86 HREF="1_SystemTap_overview.html"><SPAN CLASS="arabic">1</SPAN> SystemTap overview</A>
87<UL>
88<LI><A ID="tex2html18"
89 HREF="1_SystemTap_overview.html#SECTION00021000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN> About this guide</A>
90<LI><A ID="tex2html19"
91 HREF="1_SystemTap_overview.html#SECTION00022000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN> Reasons to use SystemTap</A>
92<LI><A ID="tex2html20"
93 HREF="1_SystemTap_overview.html#SECTION00023000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN> Event-action language</A>
94<LI><A ID="tex2html21"
95 HREF="1_SystemTap_overview.html#SECTION00024000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN> Sample SystemTap scripts</A>
96<UL>
97<LI><A ID="tex2html22"
98 HREF="1_SystemTap_overview.html#SECTION00024100000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> Basic SystemTap syntax and control structures</A>
99<LI><A ID="tex2html23"
100 HREF="1_SystemTap_overview.html#SECTION00024200000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> Primes between 0 and 49</A>
101<LI><A ID="tex2html24"
102 HREF="1_SystemTap_overview.html#SECTION00024300000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN> Recursive functions</A>
103</UL>
104<LI><A ID="tex2html25"
105 HREF="1_SystemTap_overview.html#SECTION00025000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN> The stap command</A>
106<LI><A ID="tex2html26"
107 HREF="1_SystemTap_overview.html#SECTION00026000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">6</SPAN> Safety and security</A>
108</UL>
109<BR>
110<LI><A ID="tex2html27"
111 HREF="2_Types_SystemTap_scripts.html"><SPAN CLASS="arabic">2</SPAN> Types of SystemTap scripts</A>
112<UL>
113<LI><A ID="tex2html28"
114 HREF="2_Types_SystemTap_scripts.html#SECTION00031000000000000000"><SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Probe scripts</A>
115<LI><A ID="tex2html29"
116 HREF="2_Types_SystemTap_scripts.html#SECTION00032000000000000000"><SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Tapset scripts</A>
117</UL>
118<BR>
119<LI><A ID="tex2html30"
120 HREF="3_Components_SystemTap_scri.html"><SPAN CLASS="arabic">3</SPAN> Components of a SystemTap script</A>
121<UL>
122<LI><A ID="tex2html31"
123 HREF="3_Components_SystemTap_scri.html#SECTION00041000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> Probe definitions</A>
124<LI><A ID="tex2html32"
125 HREF="3_Components_SystemTap_scri.html#SECTION00042000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN> Probe aliases</A>
126<UL>
127<LI><A ID="tex2html33"
128 HREF="3_Components_SystemTap_scri.html#SECTION00042100000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Prologue-style aliases (=)</A>
129<LI><A ID="tex2html34"
130 HREF="3_Components_SystemTap_scri.html#SECTION00042200000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Epilogue-style aliases (+=)</A>
131<LI><A ID="tex2html35"
132 HREF="3_Components_SystemTap_scri.html#SECTION00042300000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN> Probe alias usage</A>
133<LI><A ID="tex2html36"
134 HREF="3_Components_SystemTap_scri.html#SECTION00042400000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">4</SPAN> Alias suffixes</A>
135<LI><A ID="tex2html37"
136 HREF="3_Components_SystemTap_scri.html#SECTION00042500000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">5</SPAN> Alias suffixes and wildcards</A>
137</UL>
138<LI><A ID="tex2html38"
139 HREF="3_Components_SystemTap_scri.html#SECTION00043000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN> Variables</A>
140<UL>
141<LI><A ID="tex2html39"
142 HREF="3_Components_SystemTap_scri.html#SECTION00043100000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> Unused variables</A>
143</UL>
144<LI><A ID="tex2html40"
145 HREF="3_Components_SystemTap_scri.html#SECTION00044000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN> Auxiliary functions</A>
146<LI><A ID="tex2html41"
147 HREF="3_Components_SystemTap_scri.html#SECTION00045000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN> Embedded C</A>
148<LI><A ID="tex2html42"
149 HREF="3_Components_SystemTap_scri.html#SECTION00046000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">6</SPAN> Embedded C functions</A>
150<LI><A ID="tex2html43"
151 HREF="3_Components_SystemTap_scri.html#SECTION00047000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">7</SPAN> Embedded C pragma comments</A>
152<LI><A ID="tex2html44"
153 HREF="3_Components_SystemTap_scri.html#SECTION00048000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">8</SPAN> Accessing script level global variables</A>
154</UL>
155<BR>
156<LI><A ID="tex2html45"
157 HREF="4_Probe_points.html"><SPAN CLASS="arabic">4</SPAN> Probe points</A>
158<UL>
159<LI><A ID="tex2html46"
160 HREF="4_Probe_points.html#SECTION00051000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> General syntax</A>
161<UL>
162<LI><A ID="tex2html47"
163 HREF="4_Probe_points.html#SECTION00051100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN> Prefixes</A>
164<LI><A ID="tex2html48"
165 HREF="4_Probe_points.html#SECTION00051200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN> Suffixes</A>
166<LI><A ID="tex2html49"
167 HREF="4_Probe_points.html#SECTION00051300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN> Wildcarded file names, function names</A>
168<LI><A ID="tex2html50"
169 HREF="4_Probe_points.html#SECTION00051400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN> Optional probe points</A>
170<LI><A ID="tex2html51"
171 HREF="4_Probe_points.html#SECTION00051500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN> Brace expansion</A>
172</UL>
173<LI><A ID="tex2html52"
174 HREF="4_Probe_points.html#SECTION00052000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> Built-in probe point types (DWARF probes)</A>
175<UL>
176<LI><A ID="tex2html53"
177 HREF="4_Probe_points.html#SECTION00052100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> kernel.function, module().function</A>
178<LI><A ID="tex2html54"
179 HREF="4_Probe_points.html#SECTION00052200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> kernel.statement, module().statement</A>
180</UL>
181<LI><A ID="tex2html55"
182 HREF="4_Probe_points.html#SECTION00053000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN> Function return probes</A>
183<LI><A ID="tex2html56"
184 HREF="4_Probe_points.html#SECTION00054000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">4</SPAN> DWARF-less probing</A>
185<LI><A ID="tex2html57"
186 HREF="4_Probe_points.html#SECTION00055000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN> Userspace probing</A>
187<UL>
188<LI><A ID="tex2html58"
189 HREF="4_Probe_points.html#SECTION00055100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN> Begin/end variants</A>
190<LI><A ID="tex2html59"
191 HREF="4_Probe_points.html#SECTION00055200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN> Syscall variants</A>
192<LI><A ID="tex2html60"
193 HREF="4_Probe_points.html#SECTION00055300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN> Function/statement variants</A>
194<LI><A ID="tex2html61"
195 HREF="4_Probe_points.html#SECTION00055400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN> Absolute variant</A>
196<LI><A ID="tex2html62"
197 HREF="4_Probe_points.html#SECTION00055500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN> Process probe paths</A>
198<LI><A ID="tex2html63"
199 HREF="4_Probe_points.html#SECTION00055600000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN> Target process mode</A>
200<LI><A ID="tex2html64"
201 HREF="4_Probe_points.html#SECTION00055700000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN> Instruction probes</A>
202<LI><A ID="tex2html65"
203 HREF="4_Probe_points.html#SECTION00055800000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN> Static userspace probing</A>
204</UL>
205<LI><A ID="tex2html66"
206 HREF="4_Probe_points.html#SECTION00056000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">6</SPAN> Java probes</A>
207<LI><A ID="tex2html67"
208 HREF="4_Probe_points.html#SECTION00057000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">7</SPAN> PROCFS probes</A>
209<LI><A ID="tex2html68"
210 HREF="4_Probe_points.html#SECTION00058000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">8</SPAN> Marker probes</A>
211<LI><A ID="tex2html69"
212 HREF="4_Probe_points.html#SECTION00059000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">9</SPAN> Tracepoints</A>
213<LI><A ID="tex2html70"
214 HREF="4_Probe_points.html#SECTION000510000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">10</SPAN> Syscall probes</A>
215<LI><A ID="tex2html71"
216 HREF="4_Probe_points.html#SECTION000511000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">11</SPAN> Timer probes</A>
217<LI><A ID="tex2html72"
218 HREF="4_Probe_points.html#SECTION000512000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN> Special probe points</A>
219<UL>
220<LI><A ID="tex2html73"
221 HREF="4_Probe_points.html#SECTION000512100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">1</SPAN> begin</A>
222<LI><A ID="tex2html74"
223 HREF="4_Probe_points.html#SECTION000512200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">2</SPAN> end</A>
224<LI><A ID="tex2html75"
225 HREF="4_Probe_points.html#SECTION000512300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">3</SPAN> error</A>
226<LI><A ID="tex2html76"
227 HREF="4_Probe_points.html#SECTION000512400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">4</SPAN> begin, end, and error probe sequence</A>
228<LI><A ID="tex2html77"
229 HREF="4_Probe_points.html#SECTION000512500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">5</SPAN> never</A>
230</UL>
231</UL>
232<BR>
233<LI><A ID="tex2html78"
234 HREF="5_Language_elements.html"><SPAN CLASS="arabic">5</SPAN> Language elements</A>
235<UL>
236<LI><A ID="tex2html79"
237 HREF="5_Language_elements.html#SECTION00061000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN> Identifiers</A>
238<LI><A ID="tex2html80"
239 HREF="5_Language_elements.html#SECTION00062000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN> Data types</A>
240<UL>
241<LI><A ID="tex2html81"
242 HREF="5_Language_elements.html#SECTION00062100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Literals</A>
243<LI><A ID="tex2html82"
244 HREF="5_Language_elements.html#SECTION00062200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Integers</A>
245<LI><A ID="tex2html83"
246 HREF="5_Language_elements.html#SECTION00062300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN> Strings</A>
247<LI><A ID="tex2html84"
248 HREF="5_Language_elements.html#SECTION00062400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">4</SPAN> Associative arrays</A>
249<LI><A ID="tex2html85"
250 HREF="5_Language_elements.html#SECTION00062500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">5</SPAN> Statistics</A>
251</UL>
252<LI><A ID="tex2html86"
253 HREF="5_Language_elements.html#SECTION00063000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN> Semicolons</A>
254<LI><A ID="tex2html87"
255 HREF="5_Language_elements.html#SECTION00064000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN> Comments</A>
256<LI><A ID="tex2html88"
257 HREF="5_Language_elements.html#SECTION00065000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN> Whitespace</A>
258<LI><A ID="tex2html89"
259 HREF="5_Language_elements.html#SECTION00066000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN> Expressions</A>
260<UL>
261<LI><A ID="tex2html90"
262 HREF="5_Language_elements.html#SECTION00066100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN> Binary numeric operators</A>
263<LI><A ID="tex2html91"
264 HREF="5_Language_elements.html#SECTION00066200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN> Binary string operators</A>
265<LI><A ID="tex2html92"
266 HREF="5_Language_elements.html#SECTION00066300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN> Numeric assignment operators</A>
267<LI><A ID="tex2html93"
268 HREF="5_Language_elements.html#SECTION00066400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN> String assignment operators</A>
269<LI><A ID="tex2html94"
270 HREF="5_Language_elements.html#SECTION00066500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN> Unary numeric operators</A>
271<LI><A ID="tex2html95"
272 HREF="5_Language_elements.html#SECTION00066600000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN> Numeric &amp; string comparison, regular expression matching operators</A>
273<LI><A ID="tex2html96"
274 HREF="5_Language_elements.html#SECTION00066700000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN> Ternary operator</A>
275<LI><A ID="tex2html97"
276 HREF="5_Language_elements.html#SECTION00066800000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN> Grouping operator</A>
277<LI><A ID="tex2html98"
278 HREF="5_Language_elements.html#SECTION00066900000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN> Function call</A>
279<LI><A ID="tex2html99"
280 HREF="5_Language_elements.html#SECTION000661000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN> $ptr-&gt;member</A>
281<LI><A ID="tex2html100"
282 HREF="5_Language_elements.html#SECTION000661100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN> Pointer typecasting</A>
283<LI><A ID="tex2html101"
284 HREF="5_Language_elements.html#SECTION000661200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN> &lt;value&gt; in &lt;array_name&gt;</A>
285<LI><A ID="tex2html102"
286 HREF="5_Language_elements.html#SECTION000661300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">13</SPAN> [ &lt;value&gt;, ... ] in &lt;array_name&gt;</A>
287</UL>
288<LI><A ID="tex2html103"
289 HREF="5_Language_elements.html#SECTION00067000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN> Literals passed in from the stap command line</A>
290<UL>
291<LI><A ID="tex2html104"
292 HREF="5_Language_elements.html#SECTION00067100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN> $1 ... $&lt;NN&gt; for literal pasting</A>
293<LI><A ID="tex2html105"
294 HREF="5_Language_elements.html#SECTION00067200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">2</SPAN> @1 ... @&lt;NN&gt; for strings</A>
295<LI><A ID="tex2html106"
296 HREF="5_Language_elements.html#SECTION00067300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">3</SPAN> Examples</A>
297</UL>
298<LI><A ID="tex2html107"
299 HREF="5_Language_elements.html#SECTION00068000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN> Conditional compilation</A>
300<UL>
301<LI><A ID="tex2html108"
302 HREF="5_Language_elements.html#SECTION00068100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN> Conditions</A>
303<LI><A ID="tex2html109"
304 HREF="5_Language_elements.html#SECTION00068200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN> Conditions based on available target variables</A>
305<LI><A ID="tex2html110"
306 HREF="5_Language_elements.html#SECTION00068300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN> Conditions based on kernel version: kernel_v, kernel_vr</A>
307<LI><A ID="tex2html111"
308 HREF="5_Language_elements.html#SECTION00068400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN> Conditions based on architecture: arch</A>
309<LI><A ID="tex2html112"
310 HREF="5_Language_elements.html#SECTION00068500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN> Conditions based on privilege level: systemtap_privilege</A>
311<LI><A ID="tex2html113"
312 HREF="5_Language_elements.html#SECTION00068600000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">6</SPAN> True and False Tokens</A>
313</UL>
314<LI><A ID="tex2html114"
315 HREF="5_Language_elements.html#SECTION00069000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN> Preprocessor macros</A>
316<UL>
317<LI><A ID="tex2html115"
318 HREF="5_Language_elements.html#SECTION00069100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN> Local macros</A>
319<LI><A ID="tex2html116"
320 HREF="5_Language_elements.html#SECTION00069200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN> Library macros</A>
321</UL>
322</UL>
323<BR>
324<LI><A ID="tex2html117"
325 HREF="6_Statement_types.html"><SPAN CLASS="arabic">6</SPAN> Statement types</A>
326<UL>
327<LI><A ID="tex2html118"
328 HREF="6_Statement_types.html#SECTION00071000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN> break and continue</A>
329<LI><A ID="tex2html119"
330 HREF="6_Statement_types.html#SECTION00072000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN> try/catch</A>
331<LI><A ID="tex2html120"
332 HREF="6_Statement_types.html#SECTION00073000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN> delete</A>
333<LI><A ID="tex2html121"
334 HREF="6_Statement_types.html#SECTION00074000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN> EXP (expression)</A>
335<LI><A ID="tex2html122"
336 HREF="6_Statement_types.html#SECTION00075000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN> for</A>
337<LI><A ID="tex2html123"
338 HREF="6_Statement_types.html#SECTION00076000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN> foreach</A>
339<LI><A ID="tex2html124"
340 HREF="6_Statement_types.html#SECTION00077000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN> if</A>
341<LI><A ID="tex2html125"
342 HREF="6_Statement_types.html#SECTION00078000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN> next</A>
343<LI><A ID="tex2html126"
344 HREF="6_Statement_types.html#SECTION00079000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN> ; (null statement)</A>
345<LI><A ID="tex2html127"
346 HREF="6_Statement_types.html#SECTION000710000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN> return</A>
347<LI><A ID="tex2html128"
348 HREF="6_Statement_types.html#SECTION000711000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN> { } (statement block)</A>
349<LI><A ID="tex2html129"
350 HREF="6_Statement_types.html#SECTION000712000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN> while</A>
351</UL>
352<BR>
353<LI><A ID="tex2html130"
354 HREF="7_Associative_arrays.html"><SPAN CLASS="arabic">7</SPAN> Associative arrays</A>
355<UL>
356<LI><A ID="tex2html131"
357 HREF="7_Associative_arrays.html#SECTION00081000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN> Examples</A>
358<LI><A ID="tex2html132"
359 HREF="7_Associative_arrays.html#SECTION00082000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">2</SPAN> Types of values</A>
360<LI><A ID="tex2html133"
361 HREF="7_Associative_arrays.html#SECTION00083000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">3</SPAN> Array capacity</A>
362<LI><A ID="tex2html134"
363 HREF="7_Associative_arrays.html#SECTION00084000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">4</SPAN> Array wrapping</A>
364<LI><A ID="tex2html135"
365 HREF="7_Associative_arrays.html#SECTION00085000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">5</SPAN> Iteration, foreach</A>
366<LI><A ID="tex2html136"
367 HREF="7_Associative_arrays.html#SECTION00086000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">6</SPAN> Deletion</A>
368</UL>
369<BR>
370<LI><A ID="tex2html137"
371 HREF="8_Statistics_aggregates.html"><SPAN CLASS="arabic">8</SPAN> Statistics (aggregates)</A>
372<UL>
373<LI><A ID="tex2html138"
374 HREF="8_Statistics_aggregates.html#SECTION00091000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN> The aggregation (&lt; &lt; &lt;) operator</A>
375<LI><A ID="tex2html139"
376 HREF="8_Statistics_aggregates.html#SECTION00092000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN> Extraction functions</A>
377<LI><A ID="tex2html140"
378 HREF="8_Statistics_aggregates.html#SECTION00093000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN> Integer extractors</A>
379<UL>
380<LI><A ID="tex2html141"
381 HREF="8_Statistics_aggregates.html#SECTION00093100000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> @count(s)</A>
382<LI><A ID="tex2html142"
383 HREF="8_Statistics_aggregates.html#SECTION00093200000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN> @sum(s)</A>
384<LI><A ID="tex2html143"
385 HREF="8_Statistics_aggregates.html#SECTION00093300000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN> @min(s)</A>
386<LI><A ID="tex2html144"
387 HREF="8_Statistics_aggregates.html#SECTION00093400000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN> @max(s)</A>
388<LI><A ID="tex2html145"
389 HREF="8_Statistics_aggregates.html#SECTION00093500000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN> @avg(s)</A>
390</UL>
391<LI><A ID="tex2html146"
392 HREF="8_Statistics_aggregates.html#SECTION00094000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN> Histogram extractors</A>
393<UL>
394<LI><A ID="tex2html147"
395 HREF="8_Statistics_aggregates.html#SECTION00094100000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> @hist_linear</A>
396<LI><A ID="tex2html148"
397 HREF="8_Statistics_aggregates.html#SECTION00094200000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> @hist_log</A>
398</UL>
399<LI><A ID="tex2html149"
400 HREF="8_Statistics_aggregates.html#SECTION00095000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN> Deletion</A>
401</UL>
402<BR>
403<LI><A ID="tex2html150"
404 HREF="9_Formatted_output.html"><SPAN CLASS="arabic">9</SPAN> Formatted output</A>
405<UL>
406<LI><A ID="tex2html151"
407 HREF="9_Formatted_output.html#SECTION000101000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN> print</A>
408<LI><A ID="tex2html152"
409 HREF="9_Formatted_output.html#SECTION000102000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN> printf</A>
410<LI><A ID="tex2html153"
411 HREF="9_Formatted_output.html#SECTION000103000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">3</SPAN> printd</A>
412<LI><A ID="tex2html154"
413 HREF="9_Formatted_output.html#SECTION000104000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">4</SPAN> printdln</A>
414<LI><A ID="tex2html155"
415 HREF="9_Formatted_output.html#SECTION000105000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">5</SPAN> println</A>
416<LI><A ID="tex2html156"
417 HREF="9_Formatted_output.html#SECTION000106000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">6</SPAN> sprint</A>
418<LI><A ID="tex2html157"
419 HREF="9_Formatted_output.html#SECTION000107000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">7</SPAN> sprintf</A>
420</UL>
421<BR>
422<LI><A ID="tex2html158"
423 HREF="10_Tapset_defined_functions.html"><SPAN CLASS="arabic">10</SPAN> Tapset-defined functions</A>
424<LI><A ID="tex2html159"
425 HREF="11_Further_Reference.html"><SPAN CLASS="arabic">11</SPAN> For Further Reference</A>
426<LI><A ID="tex2html160"
427 HREF="Index.html">Index</A>
428<LI><A ID="tex2html161"
429 HREF="About_this_document.html">About this document ...</A>
430</UL>
431<!--End of Table of Child-Links-->
432<BR><HR>
433
434</BODY>
435</HTML>
diff --git a/langref/langref.html b/langref/langref.html
deleted file mode 100644
index f0742299..00000000
--- a/langref/langref.html
+++ /dev/null
@@ -1,435 +0,0 @@
1<!DOCTYPE HTML>
2
3<!--Converted with LaTeX2HTML 2018.3 (Released July 19, 2018) -->
4<HTML lang="EN">
5<HEAD>
6<TITLE>SystemTap Language Reference</TITLE>
7<META NAME="description" CONTENT="SystemTap Language Reference">
8<META NAME="keywords" CONTENT="langref">
9<META NAME="resource-type" CONTENT="document">
10<META NAME="distribution" CONTENT="global">
11
12<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
13<META NAME="viewport" CONTENT="width=device-width, initial-scale=1.0">
14<META NAME="Generator" CONTENT="LaTeX2HTML v2018.3">
15
16<LINK REL="STYLESHEET" HREF="langref.css">
17
18<LINK REL="next" HREF="Contents.html">
19</HEAD>
20
21<BODY >
22
23<DIV CLASS="navigation"><!--Navigation Panel-->
24<A
25 HREF="Contents.html">
26<IMG WIDTH="37" HEIGHT="24" ALT="next" SRC="next.png"></A>
27<IMG WIDTH="26" HEIGHT="24" ALT="up" SRC="up_g.png">
28<IMG WIDTH="63" HEIGHT="24" ALT="previous" SRC="prev_g.png">
29<A ID="tex2html12"
30 HREF="Contents.html">
31<IMG WIDTH="65" HEIGHT="24" ALT="contents" SRC="contents.png"></A>
32<A ID="tex2html14"
33 HREF="Index.html">
34<IMG WIDTH="43" HEIGHT="24" ALT="index" SRC="index.png"></A>
35<BR>
36<B> Next:</B> <A
37 HREF="Contents.html">Contents</A>
38 &nbsp; <B> <A ID="tex2html13"
39 HREF="Contents.html">Contents</A></B>
40 &nbsp; <B> <A ID="tex2html15"
41 HREF="Index.html">Index</A></B>
42<BR>
43<BR></DIV>
44<!--End of Navigation Panel-->
45
46<P>
47
48<P>
49<H1 class="CENTER">SystemTap Language Reference</H1>
50<DIV CLASS="author_info">
51
52</DIV>
53This document was derived from other documents contributed to the SystemTap project by employees of Red Hat, IBM and Intel.
54<BR>
55
56<P>
57Copyright &#169; 2007-2013 Red Hat Inc.
58<BR>
59Copyright &#169; 2007-2009 IBM Corp.
60<BR>
61Copyright &#169; 2007 Intel Corporation.
62<BR>
63
64<P>
65Permission is granted to copy, distribute and/or modify this document
66under the terms of the GNU Free Documentation License, Version 1.2
67or any later version published by the Free Software Foundation;
68with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
69<BR>
70
71<P>
72The GNU Free Documentation License is available from
73<kbd><A ID="tex2html1"
74 HREF="http://www.gnu.org/licenses/fdl.html">http://www.gnu.org/licenses/fdl.html</A></kbd> or by writing to
75the Free Software Foundation, Inc., 51 Franklin Street,
76Fifth Floor, Boston, MA 02110-1301, USA.
77
78<BR><HR>
79<!--Table of Child-Links-->
80<A ID="CHILD_LINKS"></A>
81
82<UL CLASS="ChildLinks">
83<LI><A ID="tex2html16"
84 HREF="Contents.html">Contents</A>
85<LI><A ID="tex2html17"
86 HREF="1_SystemTap_overview.html"><SPAN CLASS="arabic">1</SPAN> SystemTap overview</A>
87<UL>
88<LI><A ID="tex2html18"
89 HREF="1_SystemTap_overview.html#SECTION00021000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN> About this guide</A>
90<LI><A ID="tex2html19"
91 HREF="1_SystemTap_overview.html#SECTION00022000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN> Reasons to use SystemTap</A>
92<LI><A ID="tex2html20"
93 HREF="1_SystemTap_overview.html#SECTION00023000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN> Event-action language</A>
94<LI><A ID="tex2html21"
95 HREF="1_SystemTap_overview.html#SECTION00024000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN> Sample SystemTap scripts</A>
96<UL>
97<LI><A ID="tex2html22"
98 HREF="1_SystemTap_overview.html#SECTION00024100000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> Basic SystemTap syntax and control structures</A>
99<LI><A ID="tex2html23"
100 HREF="1_SystemTap_overview.html#SECTION00024200000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> Primes between 0 and 49</A>
101<LI><A ID="tex2html24"
102 HREF="1_SystemTap_overview.html#SECTION00024300000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN> Recursive functions</A>
103</UL>
104<LI><A ID="tex2html25"
105 HREF="1_SystemTap_overview.html#SECTION00025000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN> The stap command</A>
106<LI><A ID="tex2html26"
107 HREF="1_SystemTap_overview.html#SECTION00026000000000000000"><SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">6</SPAN> Safety and security</A>
108</UL>
109<BR>
110<LI><A ID="tex2html27"
111 HREF="2_Types_SystemTap_scripts.html"><SPAN CLASS="arabic">2</SPAN> Types of SystemTap scripts</A>
112<UL>
113<LI><A ID="tex2html28"
114 HREF="2_Types_SystemTap_scripts.html#SECTION00031000000000000000"><SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Probe scripts</A>
115<LI><A ID="tex2html29"
116 HREF="2_Types_SystemTap_scripts.html#SECTION00032000000000000000"><SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Tapset scripts</A>
117</UL>
118<BR>
119<LI><A ID="tex2html30"
120 HREF="3_Components_SystemTap_scri.html"><SPAN CLASS="arabic">3</SPAN> Components of a SystemTap script</A>
121<UL>
122<LI><A ID="tex2html31"
123 HREF="3_Components_SystemTap_scri.html#SECTION00041000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> Probe definitions</A>
124<LI><A ID="tex2html32"
125 HREF="3_Components_SystemTap_scri.html#SECTION00042000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN> Probe aliases</A>
126<UL>
127<LI><A ID="tex2html33"
128 HREF="3_Components_SystemTap_scri.html#SECTION00042100000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Prologue-style aliases (=)</A>
129<LI><A ID="tex2html34"
130 HREF="3_Components_SystemTap_scri.html#SECTION00042200000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Epilogue-style aliases (+=)</A>
131<LI><A ID="tex2html35"
132 HREF="3_Components_SystemTap_scri.html#SECTION00042300000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN> Probe alias usage</A>
133<LI><A ID="tex2html36"
134 HREF="3_Components_SystemTap_scri.html#SECTION00042400000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">4</SPAN> Alias suffixes</A>
135<LI><A ID="tex2html37"
136 HREF="3_Components_SystemTap_scri.html#SECTION00042500000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">5</SPAN> Alias suffixes and wildcards</A>
137</UL>
138<LI><A ID="tex2html38"
139 HREF="3_Components_SystemTap_scri.html#SECTION00043000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN> Variables</A>
140<UL>
141<LI><A ID="tex2html39"
142 HREF="3_Components_SystemTap_scri.html#SECTION00043100000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> Unused variables</A>
143</UL>
144<LI><A ID="tex2html40"
145 HREF="3_Components_SystemTap_scri.html#SECTION00044000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN> Auxiliary functions</A>
146<LI><A ID="tex2html41"
147 HREF="3_Components_SystemTap_scri.html#SECTION00045000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN> Embedded C</A>
148<LI><A ID="tex2html42"
149 HREF="3_Components_SystemTap_scri.html#SECTION00046000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">6</SPAN> Embedded C functions</A>
150<LI><A ID="tex2html43"
151 HREF="3_Components_SystemTap_scri.html#SECTION00047000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">7</SPAN> Embedded C pragma comments</A>
152<LI><A ID="tex2html44"
153 HREF="3_Components_SystemTap_scri.html#SECTION00048000000000000000"><SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">8</SPAN> Accessing script level global variables</A>
154</UL>
155<BR>
156<LI><A ID="tex2html45"
157 HREF="4_Probe_points.html"><SPAN CLASS="arabic">4</SPAN> Probe points</A>
158<UL>
159<LI><A ID="tex2html46"
160 HREF="4_Probe_points.html#SECTION00051000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> General syntax</A>
161<UL>
162<LI><A ID="tex2html47"
163 HREF="4_Probe_points.html#SECTION00051100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">1</SPAN> Prefixes</A>
164<LI><A ID="tex2html48"
165 HREF="4_Probe_points.html#SECTION00051200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">2</SPAN> Suffixes</A>
166<LI><A ID="tex2html49"
167 HREF="4_Probe_points.html#SECTION00051300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">3</SPAN> Wildcarded file names, function names</A>
168<LI><A ID="tex2html50"
169 HREF="4_Probe_points.html#SECTION00051400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">4</SPAN> Optional probe points</A>
170<LI><A ID="tex2html51"
171 HREF="4_Probe_points.html#SECTION00051500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN>.<SPAN CLASS="arabic">5</SPAN> Brace expansion</A>
172</UL>
173<LI><A ID="tex2html52"
174 HREF="4_Probe_points.html#SECTION00052000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> Built-in probe point types (DWARF probes)</A>
175<UL>
176<LI><A ID="tex2html53"
177 HREF="4_Probe_points.html#SECTION00052100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> kernel.function, module().function</A>
178<LI><A ID="tex2html54"
179 HREF="4_Probe_points.html#SECTION00052200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> kernel.statement, module().statement</A>
180</UL>
181<LI><A ID="tex2html55"
182 HREF="4_Probe_points.html#SECTION00053000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">3</SPAN> Function return probes</A>
183<LI><A ID="tex2html56"
184 HREF="4_Probe_points.html#SECTION00054000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">4</SPAN> DWARF-less probing</A>
185<LI><A ID="tex2html57"
186 HREF="4_Probe_points.html#SECTION00055000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN> Userspace probing</A>
187<UL>
188<LI><A ID="tex2html58"
189 HREF="4_Probe_points.html#SECTION00055100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN> Begin/end variants</A>
190<LI><A ID="tex2html59"
191 HREF="4_Probe_points.html#SECTION00055200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN> Syscall variants</A>
192<LI><A ID="tex2html60"
193 HREF="4_Probe_points.html#SECTION00055300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN> Function/statement variants</A>
194<LI><A ID="tex2html61"
195 HREF="4_Probe_points.html#SECTION00055400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN> Absolute variant</A>
196<LI><A ID="tex2html62"
197 HREF="4_Probe_points.html#SECTION00055500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN> Process probe paths</A>
198<LI><A ID="tex2html63"
199 HREF="4_Probe_points.html#SECTION00055600000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN> Target process mode</A>
200<LI><A ID="tex2html64"
201 HREF="4_Probe_points.html#SECTION00055700000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN> Instruction probes</A>
202<LI><A ID="tex2html65"
203 HREF="4_Probe_points.html#SECTION00055800000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN> Static userspace probing</A>
204</UL>
205<LI><A ID="tex2html66"
206 HREF="4_Probe_points.html#SECTION00056000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">6</SPAN> Java probes</A>
207<LI><A ID="tex2html67"
208 HREF="4_Probe_points.html#SECTION00057000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">7</SPAN> PROCFS probes</A>
209<LI><A ID="tex2html68"
210 HREF="4_Probe_points.html#SECTION00058000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">8</SPAN> Marker probes</A>
211<LI><A ID="tex2html69"
212 HREF="4_Probe_points.html#SECTION00059000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">9</SPAN> Tracepoints</A>
213<LI><A ID="tex2html70"
214 HREF="4_Probe_points.html#SECTION000510000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">10</SPAN> Syscall probes</A>
215<LI><A ID="tex2html71"
216 HREF="4_Probe_points.html#SECTION000511000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">11</SPAN> Timer probes</A>
217<LI><A ID="tex2html72"
218 HREF="4_Probe_points.html#SECTION000512000000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN> Special probe points</A>
219<UL>
220<LI><A ID="tex2html73"
221 HREF="4_Probe_points.html#SECTION000512100000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">1</SPAN> begin</A>
222<LI><A ID="tex2html74"
223 HREF="4_Probe_points.html#SECTION000512200000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">2</SPAN> end</A>
224<LI><A ID="tex2html75"
225 HREF="4_Probe_points.html#SECTION000512300000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">3</SPAN> error</A>
226<LI><A ID="tex2html76"
227 HREF="4_Probe_points.html#SECTION000512400000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">4</SPAN> begin, end, and error probe sequence</A>
228<LI><A ID="tex2html77"
229 HREF="4_Probe_points.html#SECTION000512500000000000000"><SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">12</SPAN>.<SPAN CLASS="arabic">5</SPAN> never</A>
230</UL>
231</UL>
232<BR>
233<LI><A ID="tex2html78"
234 HREF="5_Language_elements.html"><SPAN CLASS="arabic">5</SPAN> Language elements</A>
235<UL>
236<LI><A ID="tex2html79"
237 HREF="5_Language_elements.html#SECTION00061000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">1</SPAN> Identifiers</A>
238<LI><A ID="tex2html80"
239 HREF="5_Language_elements.html#SECTION00062000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN> Data types</A>
240<UL>
241<LI><A ID="tex2html81"
242 HREF="5_Language_elements.html#SECTION00062100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">1</SPAN> Literals</A>
243<LI><A ID="tex2html82"
244 HREF="5_Language_elements.html#SECTION00062200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">2</SPAN> Integers</A>
245<LI><A ID="tex2html83"
246 HREF="5_Language_elements.html#SECTION00062300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">3</SPAN> Strings</A>
247<LI><A ID="tex2html84"
248 HREF="5_Language_elements.html#SECTION00062400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">4</SPAN> Associative arrays</A>
249<LI><A ID="tex2html85"
250 HREF="5_Language_elements.html#SECTION00062500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">2</SPAN>.<SPAN CLASS="arabic">5</SPAN> Statistics</A>
251</UL>
252<LI><A ID="tex2html86"
253 HREF="5_Language_elements.html#SECTION00063000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">3</SPAN> Semicolons</A>
254<LI><A ID="tex2html87"
255 HREF="5_Language_elements.html#SECTION00064000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">4</SPAN> Comments</A>
256<LI><A ID="tex2html88"
257 HREF="5_Language_elements.html#SECTION00065000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">5</SPAN> Whitespace</A>
258<LI><A ID="tex2html89"
259 HREF="5_Language_elements.html#SECTION00066000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN> Expressions</A>
260<UL>
261<LI><A ID="tex2html90"
262 HREF="5_Language_elements.html#SECTION00066100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN> Binary numeric operators</A>
263<LI><A ID="tex2html91"
264 HREF="5_Language_elements.html#SECTION00066200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN> Binary string operators</A>
265<LI><A ID="tex2html92"
266 HREF="5_Language_elements.html#SECTION00066300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN> Numeric assignment operators</A>
267<LI><A ID="tex2html93"
268 HREF="5_Language_elements.html#SECTION00066400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN> String assignment operators</A>
269<LI><A ID="tex2html94"
270 HREF="5_Language_elements.html#SECTION00066500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN> Unary numeric operators</A>
271<LI><A ID="tex2html95"
272 HREF="5_Language_elements.html#SECTION00066600000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN> Numeric &amp; string comparison, regular expression matching operators</A>
273<LI><A ID="tex2html96"
274 HREF="5_Language_elements.html#SECTION00066700000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN> Ternary operator</A>
275<LI><A ID="tex2html97"
276 HREF="5_Language_elements.html#SECTION00066800000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN> Grouping operator</A>
277<LI><A ID="tex2html98"
278 HREF="5_Language_elements.html#SECTION00066900000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN> Function call</A>
279<LI><A ID="tex2html99"
280 HREF="5_Language_elements.html#SECTION000661000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN> $ptr-&gt;member</A>
281<LI><A ID="tex2html100"
282 HREF="5_Language_elements.html#SECTION000661100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN> Pointer typecasting</A>
283<LI><A ID="tex2html101"
284 HREF="5_Language_elements.html#SECTION000661200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN> &lt;value&gt; in &lt;array_name&gt;</A>
285<LI><A ID="tex2html102"
286 HREF="5_Language_elements.html#SECTION000661300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">13</SPAN> [ &lt;value&gt;, ... ] in &lt;array_name&gt;</A>
287</UL>
288<LI><A ID="tex2html103"
289 HREF="5_Language_elements.html#SECTION00067000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN> Literals passed in from the stap command line</A>
290<UL>
291<LI><A ID="tex2html104"
292 HREF="5_Language_elements.html#SECTION00067100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN> $1 ... $&lt;NN&gt; for literal pasting</A>
293<LI><A ID="tex2html105"
294 HREF="5_Language_elements.html#SECTION00067200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">2</SPAN> @1 ... @&lt;NN&gt; for strings</A>
295<LI><A ID="tex2html106"
296 HREF="5_Language_elements.html#SECTION00067300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">3</SPAN> Examples</A>
297</UL>
298<LI><A ID="tex2html107"
299 HREF="5_Language_elements.html#SECTION00068000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN> Conditional compilation</A>
300<UL>
301<LI><A ID="tex2html108"
302 HREF="5_Language_elements.html#SECTION00068100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN> Conditions</A>
303<LI><A ID="tex2html109"
304 HREF="5_Language_elements.html#SECTION00068200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN> Conditions based on available target variables</A>
305<LI><A ID="tex2html110"
306 HREF="5_Language_elements.html#SECTION00068300000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN> Conditions based on kernel version: kernel_v, kernel_vr</A>
307<LI><A ID="tex2html111"
308 HREF="5_Language_elements.html#SECTION00068400000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN> Conditions based on architecture: arch</A>
309<LI><A ID="tex2html112"
310 HREF="5_Language_elements.html#SECTION00068500000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN> Conditions based on privilege level: systemtap_privilege</A>
311<LI><A ID="tex2html113"
312 HREF="5_Language_elements.html#SECTION00068600000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">6</SPAN> True and False Tokens</A>
313</UL>
314<LI><A ID="tex2html114"
315 HREF="5_Language_elements.html#SECTION00069000000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN> Preprocessor macros</A>
316<UL>
317<LI><A ID="tex2html115"
318 HREF="5_Language_elements.html#SECTION00069100000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN> Local macros</A>
319<LI><A ID="tex2html116"
320 HREF="5_Language_elements.html#SECTION00069200000000000000"><SPAN CLASS="arabic">5</SPAN>.<SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN> Library macros</A>
321</UL>
322</UL>
323<BR>
324<LI><A ID="tex2html117"
325 HREF="6_Statement_types.html"><SPAN CLASS="arabic">6</SPAN> Statement types</A>
326<UL>
327<LI><A ID="tex2html118"
328 HREF="6_Statement_types.html#SECTION00071000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">1</SPAN> break and continue</A>
329<LI><A ID="tex2html119"
330 HREF="6_Statement_types.html#SECTION00072000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">2</SPAN> try/catch</A>
331<LI><A ID="tex2html120"
332 HREF="6_Statement_types.html#SECTION00073000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">3</SPAN> delete</A>
333<LI><A ID="tex2html121"
334 HREF="6_Statement_types.html#SECTION00074000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">4</SPAN> EXP (expression)</A>
335<LI><A ID="tex2html122"
336 HREF="6_Statement_types.html#SECTION00075000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">5</SPAN> for</A>
337<LI><A ID="tex2html123"
338 HREF="6_Statement_types.html#SECTION00076000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">6</SPAN> foreach</A>
339<LI><A ID="tex2html124"
340 HREF="6_Statement_types.html#SECTION00077000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">7</SPAN> if</A>
341<LI><A ID="tex2html125"
342 HREF="6_Statement_types.html#SECTION00078000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">8</SPAN> next</A>
343<LI><A ID="tex2html126"
344 HREF="6_Statement_types.html#SECTION00079000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">9</SPAN> ; (null statement)</A>
345<LI><A ID="tex2html127"
346 HREF="6_Statement_types.html#SECTION000710000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">10</SPAN> return</A>
347<LI><A ID="tex2html128"
348 HREF="6_Statement_types.html#SECTION000711000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">11</SPAN> { } (statement block)</A>
349<LI><A ID="tex2html129"
350 HREF="6_Statement_types.html#SECTION000712000000000000000"><SPAN CLASS="arabic">6</SPAN>.<SPAN CLASS="arabic">12</SPAN> while</A>
351</UL>
352<BR>
353<LI><A ID="tex2html130"
354 HREF="7_Associative_arrays.html"><SPAN CLASS="arabic">7</SPAN> Associative arrays</A>
355<UL>
356<LI><A ID="tex2html131"
357 HREF="7_Associative_arrays.html#SECTION00081000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">1</SPAN> Examples</A>
358<LI><A ID="tex2html132"
359 HREF="7_Associative_arrays.html#SECTION00082000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">2</SPAN> Types of values</A>
360<LI><A ID="tex2html133"
361 HREF="7_Associative_arrays.html#SECTION00083000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">3</SPAN> Array capacity</A>
362<LI><A ID="tex2html134"
363 HREF="7_Associative_arrays.html#SECTION00084000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">4</SPAN> Array wrapping</A>
364<LI><A ID="tex2html135"
365 HREF="7_Associative_arrays.html#SECTION00085000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">5</SPAN> Iteration, foreach</A>
366<LI><A ID="tex2html136"
367 HREF="7_Associative_arrays.html#SECTION00086000000000000000"><SPAN CLASS="arabic">7</SPAN>.<SPAN CLASS="arabic">6</SPAN> Deletion</A>
368</UL>
369<BR>
370<LI><A ID="tex2html137"
371 HREF="8_Statistics_aggregates.html"><SPAN CLASS="arabic">8</SPAN> Statistics (aggregates)</A>
372<UL>
373<LI><A ID="tex2html138"
374 HREF="8_Statistics_aggregates.html#SECTION00091000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">1</SPAN> The aggregation (&lt; &lt; &lt;) operator</A>
375<LI><A ID="tex2html139"
376 HREF="8_Statistics_aggregates.html#SECTION00092000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">2</SPAN> Extraction functions</A>
377<LI><A ID="tex2html140"
378 HREF="8_Statistics_aggregates.html#SECTION00093000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN> Integer extractors</A>
379<UL>
380<LI><A ID="tex2html141"
381 HREF="8_Statistics_aggregates.html#SECTION00093100000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">1</SPAN> @count(s)</A>
382<LI><A ID="tex2html142"
383 HREF="8_Statistics_aggregates.html#SECTION00093200000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">2</SPAN> @sum(s)</A>
384<LI><A ID="tex2html143"
385 HREF="8_Statistics_aggregates.html#SECTION00093300000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">3</SPAN> @min(s)</A>
386<LI><A ID="tex2html144"
387 HREF="8_Statistics_aggregates.html#SECTION00093400000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">4</SPAN> @max(s)</A>
388<LI><A ID="tex2html145"
389 HREF="8_Statistics_aggregates.html#SECTION00093500000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">3</SPAN>.<SPAN CLASS="arabic">5</SPAN> @avg(s)</A>
390</UL>
391<LI><A ID="tex2html146"
392 HREF="8_Statistics_aggregates.html#SECTION00094000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN> Histogram extractors</A>
393<UL>
394<LI><A ID="tex2html147"
395 HREF="8_Statistics_aggregates.html#SECTION00094100000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">1</SPAN> @hist_linear</A>
396<LI><A ID="tex2html148"
397 HREF="8_Statistics_aggregates.html#SECTION00094200000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">4</SPAN>.<SPAN CLASS="arabic">2</SPAN> @hist_log</A>
398</UL>
399<LI><A ID="tex2html149"
400 HREF="8_Statistics_aggregates.html#SECTION00095000000000000000"><SPAN CLASS="arabic">8</SPAN>.<SPAN CLASS="arabic">5</SPAN> Deletion</A>
401</UL>
402<BR>
403<LI><A ID="tex2html150"
404 HREF="9_Formatted_output.html"><SPAN CLASS="arabic">9</SPAN> Formatted output</A>
405<UL>
406<LI><A ID="tex2html151"
407 HREF="9_Formatted_output.html#SECTION000101000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">1</SPAN> print</A>
408<LI><A ID="tex2html152"
409 HREF="9_Formatted_output.html#SECTION000102000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">2</SPAN> printf</A>
410<LI><A ID="tex2html153"
411 HREF="9_Formatted_output.html#SECTION000103000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">3</SPAN> printd</A>
412<LI><A ID="tex2html154"
413 HREF="9_Formatted_output.html#SECTION000104000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">4</SPAN> printdln</A>
414<LI><A ID="tex2html155"
415 HREF="9_Formatted_output.html#SECTION000105000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">5</SPAN> println</A>
416<LI><A ID="tex2html156"
417 HREF="9_Formatted_output.html#SECTION000106000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">6</SPAN> sprint</A>
418<LI><A ID="tex2html157"
419 HREF="9_Formatted_output.html#SECTION000107000000000000000"><SPAN CLASS="arabic">9</SPAN>.<SPAN CLASS="arabic">7</SPAN> sprintf</A>
420</UL>
421<BR>
422<LI><A ID="tex2html158"
423 HREF="10_Tapset_defined_functions.html"><SPAN CLASS="arabic">10</SPAN> Tapset-defined functions</A>
424<LI><A ID="tex2html159"
425 HREF="11_Further_Reference.html"><SPAN CLASS="arabic">11</SPAN> For Further Reference</A>
426<LI><A ID="tex2html160"
427 HREF="Index.html">Index</A>
428<LI><A ID="tex2html161"
429 HREF="About_this_document.html">About this document ...</A>
430</UL>
431<!--End of Table of Child-Links-->
432<BR><HR>
433
434</BODY>
435</HTML>
generated by cgit (git 2.34.1) at 2025-11-03 07:17:29 +0000