5 files changed, 293 insertions, 24 deletions

diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index 6a2153891592..5d900307de3e 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -212,16 +212,10 @@ cmd_modversions =							\
         fi;
 endif
 
-ifdef CONFIG_64BIT
-arch_bits = 64
-else
-arch_bits = 32
-endif
-
 ifdef CONFIG_FTRACE_MCOUNT_RECORD
-cmd_record_mcount = perl $(srctree)/scripts/recordmcount.pl \
-        "$(ARCH)" "$(arch_bits)" "$(OBJDUMP)" "$(OBJCOPY)" "$(CC)" "$(LD)" \
-        "$(NM)" "$(RM)" "$(MV)" "$(@)";
+cmd_record_mcount = perl $(srctree)/scripts/recordmcount.pl "$(ARCH)" \
+        "$(if $(CONFIG_64BIT),64,32)" \
+        "$(OBJDUMP)" "$(OBJCOPY)" "$(CC)" "$(LD)" "$(NM)" "$(RM)" "$(MV)" "$(@)";
 endif
 
 define rule_cc_o_c
diff --git a/scripts/bootgraph.pl b/scripts/bootgraph.pl
index d2c61efc216f..f0af9aa9b243 100644
--- a/scripts/bootgraph.pl
+++ b/scripts/bootgraph.pl
@@ -78,11 +78,13 @@ while (<>) {
 }
 
 if ($count == 0) {
-        print "No data found in the dmesg. Make sure that 'printk.time=1' and\n";
-        print "'initcall_debug' are passed on the kernel command line.\n\n";
-        print "Usage: \n";
-        print "      dmesg | perl scripts/bootgraph.pl > output.svg\n\n";
-        exit;
+    print STDERR <<END;
+No data found in the dmesg. Make sure that 'printk.time=1' and
+'initcall_debug' are passed on the kernel command line.
+Usage:
+      dmesg | perl scripts/bootgraph.pl > output.svg
+END
+    exit 1;
 }
 
 print "<?xml version=\"1.0\" standalone=\"no\"?> \n";
@@ -109,8 +111,8 @@ my $stylecounter = 0;
 my %rows;
 my $rowscount = 1;
 my @initcalls = sort { $start{$a} <=> $start{$b} } keys(%start);
-my $key;
-foreach $key (@initcalls) {
+
+foreach my $key (@initcalls) {
         my $duration = $end{$key} - $start{$key};
 
         if ($duration >= $threshold) {
diff --git a/scripts/recordmcount.pl b/scripts/recordmcount.pl
index 6b9fe3eb8360..fe831412bea9 100755
--- a/scripts/recordmcount.pl
+++ b/scripts/recordmcount.pl
@@ -112,6 +112,9 @@ my ($arch, $bits, $objdump, $objcopy, $cc,
 # Acceptable sections to record.
 my %text_sections = (
      ".text" => 1,
+     ".sched.text" => 1,
+     ".spinlock.text" => 1,
+     ".irqentry.text" => 1,
 );
 
 $objdump = "objdump" if ((length $objdump) == 0);
@@ -130,10 +133,13 @@ my %weak;		# List of weak functions
 my %convert;            # List of local functions used that needs conversion
 
 my $type;
+my $nm_regex;           # Find the local functions (return function)
 my $section_regex;      # Find the start of a section
 my $function_regex;     # Find the name of a function
                         #    (return offset and func name)
 my $mcount_regex;       # Find the call site to mcount (return offset)
+my $alignment;          # The .align value to use for $mcount_section
+my $section_type;       # Section header plus possible alignment command
 
 if ($arch eq "x86") {
     if ($bits == 64) {
@@ -143,11 +149,21 @@ if ($arch eq "x86") {
     }
 }
 
+#
+# We base the defaults off of i386, the other archs may
+# feel free to change them in the below if statements.
+#
+$nm_regex = "^[0-9a-fA-F]+\\s+t\\s+(\\S+)";
+$section_regex = "Disassembly of section\\s+(\\S+):";
+$function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:";
+$mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount\$";
+$section_type = '@progbits';
+$type = ".long";
+
 if ($arch eq "x86_64") {
-    $section_regex = "Disassembly of section\\s+(\\S+):";
-    $function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:";
     $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount([+-]0x[0-9a-zA-Z]+)?\$";
     $type = ".quad";
+    $alignment = 8;
 
     # force flags for this arch
     $ld .= " -m elf_x86_64";
@@ -156,10 +172,7 @@ if ($arch eq "x86_64") {
     $cc .= " -m64";
 
 } elsif ($arch eq "i386") {
-    $section_regex = "Disassembly of section\\s+(\\S+):";
-    $function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:";
-    $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount\$";
-    $type = ".long";
+    $alignment = 4;
 
     # force flags for this arch
     $ld .= " -m elf_i386";
@@ -167,6 +180,27 @@ if ($arch eq "x86_64") {
     $objcopy .= " -O elf32-i386";
     $cc .= " -m32";
 
+} elsif ($arch eq "sh") {
+    $alignment = 2;
+
+    # force flags for this arch
+    $ld .= " -m shlelf_linux";
+    $objcopy .= " -O elf32-sh-linux";
+    $cc .= " -m32";
+
+} elsif ($arch eq "powerpc") {
+    $nm_regex = "^[0-9a-fA-F]+\\s+t\\s+(\\.?\\S+)";
+    $function_regex = "^([0-9a-fA-F]+)\\s+<(\\.?.*?)>:";
+    $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s\\.?_mcount\$";
+
+    if ($bits == 64) {
+        $type = ".quad";
+    }
+
+} elsif ($arch eq "arm") {
+    $alignment = 2;
+    $section_type = '%progbits';
+
 } else {
     die "Arch $arch is not supported with CONFIG_FTRACE_MCOUNT_RECORD";
 }
@@ -236,7 +270,7 @@ if (!$found_version) {
 #
 open (IN, "$nm $inputfile|") || die "error running $nm";
 while (<IN>) {
-    if (/^[0-9a-fA-F]+\s+t\s+(\S+)/) {
+    if (/$nm_regex/) {
         $locals{$1} = 1;
     } elsif (/^[0-9a-fA-F]+\s+([wW])\s+(\S+)/) {
         $weak{$2} = $1;
@@ -287,7 +321,8 @@ sub update_funcs
         if (!$opened) {
             open(FILE, ">$mcount_s") || die "can't create $mcount_s\n";
             $opened = 1;
-            print FILE "\t.section $mcount_section,\"a\",\@progbits\n";
+            print FILE "\t.section $mcount_section,\"a\",$section_type\n";
+            print FILE "\t.align $alignment\n" if (defined($alignment));
         }
         printf FILE "\t%s %s + %d\n", $type, $ref_func, $offsets[$i] - $offset;
     }
diff --git a/scripts/trace/power.pl b/scripts/trace/power.pl
new file mode 100644
index 000000000000..4f729b3501e0
--- /dev/null
+++ b/scripts/trace/power.pl
@@ -0,0 +1,108 @@
+#!/usr/bin/perl
+
+# Copyright 2008, Intel Corporation
+#
+# This file is part of the Linux kernel
+#
+# This program file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program in a file named COPYING; if not, write to the
+# Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor,
+# Boston, MA 02110-1301 USA
+#
+# Authors:
+#       Arjan van de Ven <arjan@linux.intel.com>
+
+
+#
+# This script turns a cstate ftrace output into a SVG graphic that shows
+# historic C-state information
+#
+#
+#       cat /sys/kernel/debug/tracing/trace | perl power.pl > out.svg
+#
+
+my @styles;
+my $base = 0;
+
+my @pstate_last;
+my @pstate_level;
+
+$styles[0] = "fill:rgb(0,0,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+$styles[1] = "fill:rgb(0,255,0);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+$styles[2] = "fill:rgb(255,0,20);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+$styles[3] = "fill:rgb(255,255,20);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+$styles[4] = "fill:rgb(255,0,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+$styles[5] = "fill:rgb(0,255,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+$styles[6] = "fill:rgb(0,128,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+$styles[7] = "fill:rgb(0,255,128);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+$styles[8] = "fill:rgb(0,25,20);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+
+
+print "<?xml version=\"1.0\" standalone=\"no\"?> \n";
+print "<svg width=\"10000\" height=\"100%\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n";
+
+my $scale = 30000.0;
+while (<>) {
+        my $line = $_;
+        if ($line =~ /([0-9\.]+)\] CSTATE: Going to C([0-9]) on cpu ([0-9]+) for ([0-9\.]+)/) {
+                if ($base == 0) {
+                        $base = $1;
+                }
+                my $time = $1 - $base;
+                $time = $time * $scale;
+                my $C = $2;
+                my $cpu = $3;
+                my $y = 400 * $cpu;
+                my $duration = $4 * $scale;
+                my $msec = int($4 * 100000)/100.0;
+                my $height = $C * 20;
+                $style = $styles[$C];
+
+                $y = $y + 140 - $height;
+
+                $x2 = $time + 4;
+                $y2 = $y + 4;
+
+
+                print "<rect x=\"$time\" width=\"$duration\" y=\"$y\" height=\"$height\" style=\"$style\"/>\n";
+                print "<text transform=\"translate($x2,$y2) rotate(90)\">C$C $msec</text>\n";
+        }
+        if ($line =~ /([0-9\.]+)\] PSTATE: Going to P([0-9]) on cpu ([0-9]+)/) {
+                my $time = $1 - $base;
+                my $state = $2;
+                my $cpu = $3;
+
+                if (defined($pstate_last[$cpu])) {
+                        my $from = $pstate_last[$cpu];
+                        my $oldstate = $pstate_state[$cpu];
+                        my $duration = ($time-$from) * $scale;
+
+                        $from = $from * $scale;
+                        my $to = $from + $duration;
+                        my $height = 140 - ($oldstate * (140/8));
+
+                        my $y = 400 * $cpu + 200 + $height;
+                        my $y2 = $y+4;
+                        my $style = $styles[8];
+
+                        print "<rect x=\"$from\" y=\"$y\" width=\"$duration\" height=\"5\" style=\"$style\"/>\n";
+                        print "<text transform=\"translate($from,$y2)\">P$oldstate (cpu $cpu)</text>\n";
+                };
+
+                $pstate_last[$cpu] = $time;
+                $pstate_state[$cpu] = $state;
+        }
+}
+
+
+print "</svg>\n";
diff --git a/scripts/tracing/draw_functrace.py b/scripts/tracing/draw_functrace.py
new file mode 100644
index 000000000000..902f9a992620
--- /dev/null
+++ b/scripts/tracing/draw_functrace.py
@@ -0,0 +1,130 @@
+#!/usr/bin/python
+
+"""
+Copyright 2008 (c) Frederic Weisbecker <fweisbec@gmail.com>
+Licensed under the terms of the GNU GPL License version 2
+
+This script parses a trace provided by the function tracer in
+kernel/trace/trace_functions.c
+The resulted trace is processed into a tree to produce a more human
+view of the call stack by drawing textual but hierarchical tree of
+calls. Only the functions's names and the the call time are provided.
+
+Usage:
+        Be sure that you have CONFIG_FUNCTION_TRACER
+        # mkdir /debugfs
+        # mount -t debug debug /debug
+        # echo function > /debug/tracing/current_tracer
+        $ cat /debug/tracing/trace_pipe > ~/raw_trace_func
+        Wait some times but not too much, the script is a bit slow.
+        Break the pipe (Ctrl + Z)
+        $ scripts/draw_functrace.py < raw_trace_func > draw_functrace
+        Then you have your drawn trace in draw_functrace
+"""
+
+
+import sys, re
+
+class CallTree:
+        """ This class provides a tree representation of the functions
+                call stack. If a function has no parent in the kernel (interrupt,
+                syscall, kernel thread...) then it is attached to a virtual parent
+                called ROOT.
+        """
+        ROOT = None
+
+        def __init__(self, func, time = None, parent = None):
+                self._func = func
+                self._time = time
+                if parent is None:
+                        self._parent = CallTree.ROOT
+                else:
+                        self._parent = parent
+                self._children = []
+
+        def calls(self, func, calltime):
+                """ If a function calls another one, call this method to insert it
+                        into the tree at the appropriate place.
+                        @return: A reference to the newly created child node.
+                """
+                child = CallTree(func, calltime, self)
+                self._children.append(child)
+                return child
+
+        def getParent(self, func):
+                """ Retrieve the last parent of the current node that
+                        has the name given by func. If this function is not
+                        on a parent, then create it as new child of root
+                        @return: A reference to the parent.
+                """
+                tree = self
+                while tree != CallTree.ROOT and tree._func != func:
+                        tree = tree._parent
+                if tree == CallTree.ROOT:
+                        child = CallTree.ROOT.calls(func, None)
+                        return child
+                return tree
+
+        def __repr__(self):
+                return self.__toString("", True)
+
+        def __toString(self, branch, lastChild):
+                if self._time is not None:
+                        s = "%s----%s (%s)\n" % (branch, self._func, self._time)
+                else:
+                        s = "%s----%s\n" % (branch, self._func)
+
+                i = 0
+                if lastChild:
+                        branch = branch[:-1] + " "
+                while i < len(self._children):
+                        if i != len(self._children) - 1:
+                                s += "%s" % self._children[i].__toString(branch +\
+                                                                "    |", False)
+                        else:
+                                s += "%s" % self._children[i].__toString(branch +\
+                                                                "    |", True)
+                        i += 1
+                return s
+
+class BrokenLineException(Exception):
+        """If the last line is not complete because of the pipe breakage,
+           we want to stop the processing and ignore this line.
+        """
+        pass
+
+class CommentLineException(Exception):
+        """ If the line is a comment (as in the beginning of the trace file),
+            just ignore it.
+        """
+        pass
+
+
+def parseLine(line):
+        line = line.strip()
+        if line.startswith("#"):
+                raise CommentLineException
+        m = re.match("[^]]+?\\] +([0-9.]+): (\\w+) <-(\\w+)", line)
+        if m is None:
+                raise BrokenLineException
+        return (m.group(1), m.group(2), m.group(3))
+
+
+def main():
+        CallTree.ROOT = CallTree("Root (Nowhere)", None, None)
+        tree = CallTree.ROOT
+
+        for line in sys.stdin:
+                try:
+                        calltime, callee, caller = parseLine(line)
+                except BrokenLineException:
+                        break
+                except CommentLineException:
+                        continue
+                tree = tree.getParent(caller)
+                tree = tree.calls(callee, calltime)
+
+        print CallTree.ROOT
+
+if __name__ == "__main__":
+        main()