<h2>Edit File - dtrace</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/bin/dtrace">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">#!/usr/libexec/platform-python
# vim: et sta sts=4 sw=4 ts=8

# This handles the systemtap equivalent of
# $(DTRACE) $(DTRACEFLAGS) -G -s $^ -o $@
# $(DTRACE) $(DTRACEFLAGS) -h -s $^ -o $@
# which is a step that builds DTrace provider and probe definitions

# Copyright (C) 2009-2018 Red Hat Inc.
#
# This file is part of systemtap, and is free software.  You can
# redistribute it and/or modify it under the terms of the GNU General
# Public License (GPL); either version 2, or (at your option) any
# later version.

# ignore line too long, missing docstring, method could be a function,
#        too many public methods
# pylint: disable=C0301
# pylint: disable=C0111
# pylint: disable=R0201
# pylint: disable=R0904

import hashlib
import os
import sys
import time
import atexit
from shlex import split
from subprocess import call
try:
    from pyparsing import alphas, cStyleComment, delimitedList, Group, \
        Keyword, lineno, Literal, nestedExpr, nums, oneOf, OneOrMore, \
        Optional, ParseException, ParserElement, restOfLine, restOfLine, \
        Suppress, SkipTo, Word, ZeroOrMore
    HAVE_PYP = True
except ImportError:
    HAVE_PYP = False


# Common file creation methods for pyparsing and string pattern matching

class _HeaderCreator(object):
    def init_semaphores(self, fdesc):
        # dummy declaration just to make the object file non-empty
        fdesc.write(&quot;/* Generated by the Systemtap dtrace wrapper */\n\n&quot;)
        fdesc.write(&quot;static void __dtrace (void) __attribute__((unused));\n&quot;)
        fdesc.write(&quot;static void __dtrace (void) {}\n&quot;)
        fdesc.write(&quot;\n#include &lt;sys/sdt.h&gt;\n\n&quot;)

    def init_probes(self, fdesc):
        fdesc.write(&quot;/* Generated by the Systemtap dtrace wrapper */\n\n&quot;)
        fdesc.write(&quot;\n#define _SDT_HAS_SEMAPHORES 1\n\n&quot;)
        fdesc.write(&quot;\n#define STAP_HAS_SEMAPHORES 1 /* deprecated */\n\n&quot;)
        fdesc.write(&quot;\n#include &lt;sys/sdt.h&gt;\n\n&quot;)

    def add_semaphore(self, this_provider, this_probe):
        # NB: unsigned short is fixed in ABI
        semaphores_def = &#039;\n#if defined STAP_SDT_V1\n&#039;
        semaphores_def += &#039;#define %s_%s_semaphore %s_semaphore\n&#039; % \
                          (this_provider, this_probe, this_probe)
        semaphores_def += &#039;#endif\n&#039;
        semaphores_def += &#039;#if defined STAP_SDT_V1 || defined STAP_SDT_V2 \n&#039;
        semaphores_def += &quot;__extension__ unsigned short %s_%s_semaphore __attribute__ ((unused)) __attribute__ ((section (\&quot;.probes\&quot;)));\n&quot; % \
            (this_provider, this_probe)
        semaphores_def += &#039;#else\n&#039;
        semaphores_def += &quot;__extension__ unsigned short %s_%s_semaphore __attribute__ ((unused)) __attribute__ ((section (\&quot;.probes\&quot;))) __attribute__ ((visibility (\&quot;hidden\&quot;)));\n&quot; % \
            (this_provider, this_probe)
        semaphores_def += &#039;#endif\n&#039;
        return semaphores_def

    def add_probe(self, this_provider, this_probe, args):
        stap_str = &quot;&quot;
        this_probe_canon = this_provider.upper() + &quot;_&quot; + this_probe.replace(&quot;__&quot;, &quot;_&quot;).upper()
        define_str = &quot;#define %s(&quot; % (this_probe_canon)
        comment_str = &quot;/* %s (&quot; % (this_probe_canon)

        if len(args) == 0:
            stap_str += &quot;DTRACE_PROBE (&quot;
        else:
            stap_str += &quot;DTRACE_PROBE%d (&quot; % len(args)
        stap_str += &quot;%s, %s&quot; % (this_provider, this_probe)
        i = 0
        while i &lt; len(args):
            if i != 0:
                define_str += &quot;, &quot;
                comment_str += &quot;,&quot;
            define_str = define_str + &quot;arg%s&quot; % (i + 1)
            stap_str = stap_str + &quot;, arg%s&quot; % (i + 1)
            for argi in args[i]:
                if len(argi) &gt; 0:
                    comment_str += &quot; %s&quot; % argi
            i += 1
        stap_str += &quot;)&quot;
        comment_str += &quot; ) */&quot;
        define_str += &quot;) \\\n&quot;
        probe_def = &#039;%s\n&#039; % (comment_str)
        probe_def += (&#039;#if defined STAP_SDT_V1\n&#039;)
        probe_def += (&#039;#define %s_ENABLED() __builtin_expect (%s_semaphore, 0)\n&#039; % \
                      (this_probe_canon, this_probe))
        probe_def += (&#039;#define %s_%s_semaphore %s_semaphore\n&#039; % \
                      (this_provider, this_probe, this_probe))
        probe_def += (&#039;#else\n&#039;)
        probe_def += (&#039;#define %s_ENABLED() __builtin_expect (%s_%s_semaphore, 0)\n&#039; % \
                      (this_probe_canon, this_provider, this_probe))
        probe_def += (&#039;#endif\n&#039;)
        # NB: unsigned short is fixed in ABI
        probe_def += (&quot;__extension__ extern unsigned short %s_%s_semaphore __attribute__ ((unused)) __attribute__ ((section (\&quot;.probes\&quot;)));\n&quot; % \
                      (this_provider, this_probe))
        probe_def += (define_str + stap_str + &quot;\n\n&quot;)
        return probe_def

# Parse using pyparsing if it is available

class _PypProvider(_HeaderCreator):
    def __init__(self):
        self.ast = []
        self.bnf = None
        self.dtrace_statements = None

    def dtrace_bnf(self):
        self.current_probe = &quot;&quot;
        if self.dtrace_statements is not None:
            return
        ParserElement.setDefaultWhitespaceChars(&#039; \f\r\n\t\v&#039;)
        ident = Word(alphas+&quot;_&quot;, alphas+nums+&quot;_$&quot;)
        probe_ident = Word(alphas+nums+&quot;_$&quot;)
        semi = Literal(&quot;;&quot;).suppress()
        integer = Word( nums )
        lbrace = Literal(&quot;{&quot;).suppress()
        rbrace = Literal(&quot;}&quot;).suppress()
        type_name = ident
        varname = ident
        PROBE = Keyword(&quot;probe&quot;)
        PROVIDER = Keyword(&quot;provider&quot;)
        array_size = integer | ident  
        varname_spec = varname + Optional(&quot;[&quot; + array_size + &quot;]&quot;)
        struct_decl = Group(oneOf(&quot;struct union&quot;) + varname + Suppress(nestedExpr(&#039;{&#039;,&#039;}&#039;)) + semi)
        enum_decl = Group(&quot;enum&quot; + varname + Suppress(nestedExpr(&#039;{&#039;,&#039;}&#039;)) + semi)
        member_decl = Group((Optional(oneOf(&quot;struct unsigned const&quot;)) + type_name + Optional(Keyword(&quot;const&quot;)))
                            + Optional(Word(&quot;*&quot;), default=&quot;&quot;) + Optional(varname_spec))
        struct_typedef = Group(Literal(&quot;typedef&quot;) + Literal(&quot;struct&quot;) + varname
                               + Suppress(nestedExpr(&#039;{&#039;,&#039;}&#039;))) + Optional(varname) + semi
        typedef = ZeroOrMore(&quot;typedef&quot; + (member_decl)) + semi
        decls = OneOrMore(struct_typedef | struct_decl | typedef | enum_decl)
        def memoize_probe(instring, loc, tokens):
            self.current_probe = tokens[0][1]
            self.current_lineno = lineno(loc,instring)
        probe_decl = Group(PROBE + probe_ident + &quot;(&quot; + Optional(Group(delimitedList(member_decl))) + &quot;)&quot; + Optional(Group(Literal(&quot;:&quot;) + &quot;(&quot; + Optional(Group(delimitedList(member_decl))) + &quot;)&quot;)) + Optional(semi))
        probe_decl.setParseAction(memoize_probe)
        probe_decls = OneOrMore(probe_decl)

        provider_decl = (PROVIDER + Optional(ident)
                         + lbrace + Group(probe_decls) + rbrace + Optional(semi))
        dtrace_statement = Group (SkipTo(&quot;provider&quot;, include=False) + provider_decl)
        self.dtrace_statements = ZeroOrMore(dtrace_statement)

        cplusplus_linecomment = Literal(&quot;//&quot;) + restOfLine
        cpp_linecomment = Literal(&quot;#&quot;) + restOfLine

        self.dtrace_statements.ignore(cStyleComment)
        self.dtrace_statements.ignore(cplusplus_linecomment)
        self.dtrace_statements.ignore(cpp_linecomment)

        self.bnf = self.dtrace_statements

    def semaphore_write(self, fdesc):
        semaphores_def = &quot;&quot;
        self.init_semaphores(fdesc)
        for asti in self.ast:
            if len(asti) == 0:
                continue
            # ignore SkipTo token
            if asti[0] != &quot;provider&quot;:
                del asti[0]
            if asti[0] == &quot;provider&quot;:
                # list of probes
                for prb in asti[2]:
                    semaphores_def += self.add_semaphore(asti[1], prb[1])
        fdesc.write(semaphores_def)


    def probe_write(self, provider, header):
        hdr = open(header, mode=&#039;w&#039;)
        self.init_probes(hdr)
        self.dtrace_bnf()
        try:
            try:
                self.ast = self.bnf.parseFile(provider, parseAll=True).asList()
            except TypeError:
                # pyparsing-1.5.0 does not support parseAll
                self.ast = self.bnf.parseFile(provider).asList()
        except ParseException:
            err = sys.exc_info()[1]
            if len(self.current_probe):
                print(&quot;Warning: %s:%s:%d: syntax error near:\nprobe %s\n&quot; % (sys.argv[0], provider, self.current_lineno, self.current_probe))
            else:
                print(&quot;Warning: %s:%s:%d syntax error near:\n%s\n&quot; % (sys.argv[0], provider, err.lineno, err.line))
            raise err
  
        probes_def = &quot;&quot;
        for asti in self.ast:
            if len(asti) == 0:
                continue
            # ignore SkipTo token
            if asti[0] != &quot;provider&quot;:
                del asti[0]
            if asti[0] == &quot;provider&quot;:
                # list of probes
                for prb in asti[2]:
                    if prb[3] == &#039;)&#039;: # No parsed argument list
                        alist = []
                    else:
                        alist = prb[3]
                    probes_def += self.add_probe(asti[1], prb[1], alist)
        hdr.write(probes_def)
        hdr.close()


# Parse using regular expressions if pyparsing is not available

class _ReProvider(_HeaderCreator):
    def __init__(self):
        self.semaphores_def = &quot;\n&quot;
        self.provider = []

    def __semaphore_append(self, this_probe):
        self.semaphores_def += self.add_semaphore(self.provider, this_probe)

    def semaphore_write(self, fdesc):
        self.init_semaphores(fdesc)
        fdesc.write(self.semaphores_def)

    def probe_write(self, provider, header):
        have_provider = False
        fdesc = open(provider)
        hdr = open(header, mode=&#039;w&#039;)
        self.init_probes(hdr)
        in_comment = False
        probes_def = &quot;&quot;
        while True:
            line = fdesc.readline()
            if line == &quot;&quot;:
                break
            if line.find(&quot;/*&quot;) != -1:
                in_comment = True
            if line.find(&quot;*/&quot;) != -1:
                in_comment = False
                continue
            if in_comment:
                continue
            if line.find(&quot;provider&quot;) != -1:
                tokens = line.split()
                have_provider = True
                self.provider = tokens[1]
            elif have_provider and line.find(&quot;probe &quot;) != -1:
                while line.find(&quot;)&quot;) &lt; 0:
                    line += fdesc.readline()
                this_probe = line[line.find(&quot;probe &quot;)+5:line.find(&quot;(&quot;)].strip()
                argstr = (line[line.find(&quot;(&quot;)+1:line.find(&quot;)&quot;)])
                arg = &quot;&quot;
                i = 0
                args = []
                self.__semaphore_append(this_probe)
                while i &lt; len(argstr):
                    if argstr[i:i+1] == &quot;,&quot;:
                        args.append(arg.split())
                        arg = &quot;&quot;
                    else:
                        arg = arg + argstr[i]
                    i += 1
                if len(arg) &gt; 0:
                    args.append(arg.split())
                probes_def += self.add_probe(self.provider, this_probe, args)
            elif line.find(&quot;}&quot;) != -1 and have_provider:
                have_provider = False
        hdr.write(probes_def)
        hdr.close()


def mktemp_determ(sources, suffix):
    # for reproducible-builds purposes, use a predictable tmpfile path
    sha = hashlib.sha256()
    for source in sources:
        sha.update(source.encode(&#039;utf-8&#039;))
    fname = &quot;.dtrace-temp.&quot; + sha.hexdigest()[:8] + suffix
    tries = 0
    while True:
        tries += 1
        if tries &gt; 100: # if file exists due to previous crash or whatever
            raise Exception(&quot;cannot create temporary file \&quot;&quot;+fname+&quot;\&quot;&quot;)
        try:
            wxmode = &#039;x&#039; if sys.version_info &gt; (3,0) else &#039;wx&#039;
            fdesc = open(fname, mode=wxmode)
            break
        except FileExistsError:
            time.sleep(0.1) # vague estimate of elapsed time for concurrent identical gcc job
            pass # Try again

    return fdesc, fname


def usage():
    print(&quot;Usage &quot; + sys.argv[0] + &quot; [--help] [-h | -G] [-C [-I&lt;Path&gt;]] -s File.d [-o &lt;File&gt;]&quot;)


def dtrace_help():
    usage()
    print(&quot;Where -h builds a systemtap header file from the .d file&quot;)
    print(&quot;      -C when used with -h, also run cpp preprocessor&quot;)
    print(&quot;      -o specifies an explicit output file name,&quot;)
    print(&quot;         the default for -G is file.o and -h is file.h&quot;)
    print(&quot;      -I when running cpp pass through this -I include Path&quot;)
    print(&quot;      -s specifies the name of the .d input file&quot;)
    print(&quot;      -G builds a stub file.o from file.d,&quot;)
    print(&quot;         which is required by some packages that use dtrace.&quot;)
    sys.exit(1)


########################################################################
# main
########################################################################

def main():
    if len(sys.argv) &lt; 2:
        usage()
        return 1

    global HAVE_PYP
    i = 1
    build_header = False
    build_source = False
    keep_temps = False
    use_cpp = False
    suffix = &quot;&quot;
    filename = &quot;&quot;
    s_filename = &quot;&quot;
    includes = []
    defines = []
    ignore_options = [&quot;-64&quot;, &quot;-32&quot;, &quot;-fpic&quot;, &quot;-fPIC&quot;]
    ignore_options2 = [&quot;-x&quot;] # with parameter

    while i &lt; len(sys.argv):
        if sys.argv[i] == &quot;-o&quot;:
            i += 1
            filename = sys.argv[i]
        elif sys.argv[i] == &quot;-s&quot;:
            i += 1
            s_filename = sys.argv[i]
        elif sys.argv[i] == &quot;-C&quot;:
            use_cpp = True
        elif sys.argv[i].startswith(&quot;-D&quot;):
            defines.append(sys.argv[i])
        elif sys.argv[i] == &quot;-h&quot;:
            build_header = True
            suffix = &quot;.h&quot;
        elif sys.argv[i].startswith(&quot;-I&quot;):
            includes.append(sys.argv[i])
        elif sys.argv[i] == &quot;-G&quot;:
            build_source = True
            suffix = &quot;.o&quot;
        elif sys.argv[i] == &quot;-k&quot;:
            keep_temps = True
        elif sys.argv[i] == &quot;--no-pyparsing&quot;:
            HAVE_PYP = False
        elif sys.argv[i] == &quot;--types&quot;:
            print(sys.argv[0] + &quot;: note: obsolete option --types used&quot;)
        elif sys.argv[i] in ignore_options:
            pass                # dtrace users sometimes pass these flags
        elif sys.argv[i] in ignore_options2:
            i += 1
            pass                # dtrace users sometimes pass these flags
        elif sys.argv[i] == &quot;--help&quot;:
            dtrace_help()
        elif sys.argv[i][0] == &quot;-&quot;:
            print(sys.argv[0], &quot;invalid option&quot;, sys.argv[i])
            usage()
            return 1
        i += 1
    if not build_header and not build_source:
        usage()
        return 1

    if s_filename != &quot;&quot; and use_cpp:
        (ignore, fname) = mktemp_determ([&quot;use_cpp&quot;, s_filename], suffix=&quot;.d&quot;)
        cpp = os.environ.get(&quot;CPP&quot;, &quot;cpp&quot;)
        retcode = call(split(cpp) + includes + defines + [s_filename, &#039;-o&#039;, fname])
        if retcode != 0:
            print(&quot;\&quot;cpp includes s_filename\&quot; failed&quot;)
            usage()
            return 1
        s_filename = fname
    if filename == &quot;&quot;:
        if s_filename != &quot;&quot;:
            (filename, ignore) = os.path.splitext(s_filename)
            filename = os.path.basename(filename)
        else:
            usage()
            return 1
    else:
        suffix = &quot;&quot;

    if build_header:
        if HAVE_PYP:
            providers = _PypProvider()
        else:
            providers = _ReProvider()
        while True:
            try:
                providers.probe_write(s_filename, filename + suffix)
                break;
            # complex C declarations can fool the pyparsing grammar.  
            # we could increase the complexity of the grammar
            # instead we fall back to string pattern matching
            except ParseException:
                err = sys.exc_info()[1]
                print(&quot;Warning: Proceeding as if --no-pyparsing was given.\n&quot;)
                providers = _ReProvider()
    elif build_source:
        if HAVE_PYP:
            providers = _PypProvider()
        else:
            providers = _ReProvider()
        (fdesc, fname) = mktemp_determ([&quot;build_source&quot;, s_filename], suffix=&quot;.h&quot;)
        while True:
            try:
                providers.probe_write(s_filename, fname)
                break;
            except ParseException:
                err = sys.exc_info()[1]
                print(&quot;Warning: Proceeding as if --no-pyparsing was given.\n&quot;)
                providers = _ReProvider()
        if not keep_temps:
            os.remove(fname)
        else:
            print(&quot;header: &quot; + fname)

        (fdesc, fname) = mktemp_determ([&quot;build_source&quot;, s_filename, filename], suffix=&quot;.c&quot;)
        if not keep_temps:
            atexit.register(os.remove, fname) # delete generated source at exit, even if error
        providers.semaphore_write(fdesc)
        fdesc.close()
        cc1 = os.environ.get(&quot;CC&quot;, &quot;gcc&quot;)
        cflags = &quot;-g &quot; + os.environ.get(&quot;CFLAGS&quot;, &quot;&quot;).replace(&#039;\\\n&#039;, &#039; &#039;).replace(&#039;\\\r&#039;,&#039; &#039;)
        # sanitize any embedded \n etc. goo; PR21063
        retcode = call(split(cc1) + defines + includes + split(cflags) +
             [&quot;-fPIC&quot;, &quot;-I.&quot;, &quot;-I/usr/include&quot;, &quot;-c&quot;, fname, &quot;-o&quot;,
              filename + suffix], shell=False)
        if retcode != 0:
            print(&quot;\&quot;gcc &quot; + fname + &quot;\&quot; failed&quot;)
            usage()
            return 1
        if keep_temps:
            print(&quot;source: &quot; + fname)

    if use_cpp:
        if not keep_temps:
            os.remove(s_filename)
        else:
            print(&quot;cpp: &quot; + s_filename)

    return 0

if __name__ == &quot;__main__&quot;:
    sys.exit(main())

# Local Variables:
# mode: python
# End:
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>