STAPREF(1)

JMÉNO
stapref - referenční příručka pro skriptovací jazyk systemtapu

POUŽiTÍ

stapref

POPIS

Referenční příručka pro skriptovací jazyk systemtapu.

JAZYK
Klíčová slova
    • break
    • continue
    • delete
    • else
    • exit
    • foreach
    • for
    • function
    • global
    • private
    • if
    • in
    • next
    • probe
    • return
    • try/catch
    • while

    Datové typy a operátory
        Celá čísla
        • var1 = 5
        • global var2 = 10

        Řetězce
        • var1 = "string1"
        • global var2 = "string2"

        Asociativní pole
        • global array1[]
        • global array2[SIZE]
        • array[index] = 5

        Kontextové proměnné
        • $var
        • $var$ ("pěkný výpis" řetězce)

        Binární číselné operátory
        • * / % + - << >> & ^ | && ||

        Binární řetězcové operátory
        • . (spojení řetězců)

        Operátory pro číselné přiřazení
        • = += -= *= /= %= >>= <<= &= ^= |=

        Přiřazovací operátory pro řetězce
        • = .=

        Unární číselné operátory
        • + - ! ~ ++ --

        Operátory pro porovnávání čísel a řetězců
        • < > <= >= == !=

        Operátory pro srovnání proti regulárnímu výrazu
        • =~ !~

        Ternární operátor
        • cond ? exp1 : exp2

        Seskupovací operátor
        • ( expression )

        Operátory nad poli
        • array[index] (array read/write)
        • [index] in array

        Agregační operátor.
        • var <<< value

        Příkazy
            Skok
            • continue
            • break
            • next
            • return expression
            • try přikaz catch (zpráva)
                Příkazy větvení
                • if (výraz) příkaz
                • else příkaz
                    Příkazy pro iterování
                    • foreach (proměnná in pole) příkaz
                    • foreach ([var1,var2,...] in pole) příkaz
                    • for (výraz; výraz; výraz) příkaz
                    • while (výraz) příkaz
                        Deklarace
                        • function jméno (proměnná : type, ...) { příkaz }
                        • function jméno : type (proměnná : type, ...) { příkaz }
                        • function jméno : type (proměnná : type, ...) %{ c_příkaz %}
                        • probe sondážní_bod { příkaz }
                        • probe label = sondážní_bod { příkaz }

                        Lexikální struktury
                            Komentáře
                            • # ... komentář
                            • // ... komentář
                            • /* ... komentář ... */
                                Značky pro preprocesor
                                • %( výraz %? true_tokens %: false_tokens %)
                                • @define značka (proměnná, ...) %{ příkaz %}

                                Vestavěné funkce
                                    Vestavěné agregační funkce
                                    • @avg (proměnná)
                                    • @count (proměnná)
                                    • @hist_linear (proměnná, N, N, N)
                                    • @hist_log (proměnná)
                                    • @max (proměnná)
                                    • @min (proměnná)
                                    • @sum (proměnná)
                                        Vestavěné funkce pro výstup
                                        • print (proměnná)
                                        • printf (formát:řetězec, proměnná, ...)
                                          kde formát má tvar: %[flags][šířka][.přesnost][délka]specifiáktor
                                        • printd (oddělovač:řetězec, proměnná, ...)
                                        • printdln (oddělovač:řetězec, proměnná, ...)
                                        • println ()
                                        • sprint:řetězec (proměnná)
                                        • sprintf:řetězec (formát:řetězec, proměnná, ...)
                                            Vestavěné funkce pro přístup k proměnným
                                            • @cast (variable, "type_name"[, "module"])
                                            • @defined (variable)

                                            Sondážní body
                                                Některé běžné sondážní body
                                                • kernel.function(PATTERN) kernel.function(PATTERN).call
                                                • kernel.function(PATTERN).return
                                                • kernel.FUNCTION (PATTERN).return.maxactive(VALUE)
                                                • kernel.FUNCTION (PATTERN).inline
                                                • kernel.FUNCTION (PATTERN).label(LPATTERN)
                                                • module(MPATTERN).FUNCTION (PATTERN)
                                                • module(MPATTERN).FUNCTION (PATTERN).call
                                                • module(MPATTERN).FUNCTION (PATTERN).return.maxactive(VALUE)
                                                • module(MPATTERN).FUNCTION (PATTERN).inline
                                                • kernel.statement(PATTERN)
                                                • kernel.statement(ADDRESS).absolute
                                                • module(MPATTERN).statement(PATTERN)
                                                • kprobe.FUNCTION (FUNCTION)
                                                • kprobe.FUNCTION (FUNCTION).return
                                                • kprobe.module(NAME).FUNCTION (FUNCTION)
                                                • kprobe.module(NAME).FUNCTION (FUNCTION).return
                                                • kprobe.statement(ADDRESS).absolute
                                                • process.begin process("PATH").begin
                                                • process(PID).begin process.thread.begin
                                                • process("PATH").thread.begin
                                                • process(PID).thread.begin
                                                • process.end
                                                • process("PATH").end
                                                • process(PID).end
                                                • process.thread.end
                                                • process("PATH").thread.end
                                                • process(PID).thread.end
                                                • process("PATH").syscall
                                                • process(PID).syscall
                                                • process.syscall.return
                                                • process("PATH").syscall.return
                                                • process(PID).syscall.return
                                                • process("PATH").FUNCTION ("NAME")
                                                • process("PATH").statement("*@FILE.c:123")
                                                • process("PATH").FUNCTION ("*").return
                                                • process("PATH").FUNCTION ("myfun").label("foo")
                                                • process("PATH").mark("LABEL")
                                                • java("PNAME").class("CLASSNAME").method("PATTERN")
                                                • java("PNAME").class("CLASSNAME").method("PATTERN").return
                                                • java(PID).class("CLASSNAME").method("PATTERN")
                                                • java(PID).class("CLASSNAME").method("PATTERN").return
                                                • python2.module("MODULENAME").function("PATTERN")
                                                • python2.module("MODULENAME").function("PATTERN").return
                                                • python3.module("MODULENAME").function("PATTERN")
                                                • python3.module("MODULENAME").function("PATTERN").return

                                                Funkce standardního tapsetu
                                                    Některé běžnější funkce standardního tapsetu
                                                    • addr:long ()
                                                    • backtrace:string ()
                                                    • caller:string ()
                                                    • caller_addr:long ()
                                                    • cmdline_arg:string (N:long)
                                                    • cmdline_args:string (N:long,m:long,delim:string)
                                                    • cmdline_str:string ()
                                                    • env_var:string (name:string)
                                                    • execname:string ()
                                                    • int_arg:long (N:long)
                                                    • isinstr:long(s1:string,s2:string)
                                                    • long_arg:long (N:long)
                                                    • modname:string ()
                                                    • module_name:string ()
                                                    • pid:long ()
                                                    • pn:string ()
                                                    • pointer_arg:string (N:long)
                                                    • pp:string ()
                                                    • print_backtrace ()
                                                    • probefunc:string ()
                                                    • register:long(name:string)
                                                    • str_replace:string(prnt_str:string,srch_str:string,rplc_str:string)
                                                    • stringat:long(str:string,pos:long)
                                                    • strlen:long(str:string)
                                                    • strtol:long(str:string,base:long)
                                                    • substr:string(str:string,start:long,length:long)
                                                    • user_long:long(addr:long)
                                                    • user_string:string(addr:long)

VIZ TÉŽ
stap(1)

CHYBY
Použijte projektovou bugzillu, nebo mailing list. http://sourceware.org/systemtap/, <systemtap@sourceware.org>.

error::reporting(7stap), https://sourceware.org/systemtap/wiki/HowToReportBugs