2 files changed, 356 insertions, 0 deletions

diff --git a/scripts/nvgpu_debug_hal.py b/scripts/nvgpu_debug_hal.py
new file mode 100755
index 00000000..a56d66e3
--- /dev/null
+++ b/scripts/nvgpu_debug_hal.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms and conditions of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope 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.
+#
+# usage: nvgpu_debug_hal.py [-h] [--csv] [--gk20a GK20A] [gops_filename]
+#
+# Analyze the HAL debugfs interface's output. With no arguments, prints out
+# statistics on the gpu_ops struct based on analysis of gk20a.h
+#
+# positional arguments:
+#   gops_filename  debugfs interface output file (from /d/gpu.0/hal/gops)
+#
+# optional arguments:
+#   -h, --help     show this help message and exit
+#   --csv          csv formatted output
+#   --gk20a GK20A  path to gk20a.h
+
+import argparse
+import re
+from os import environ
+
+description_str = ('Analyze the HAL debugfs interface\'s output. '
+'With no arguments, prints out statistics on the gpu_ops struct based on '
+'analysis of gk20a.h')
+
+parser = argparse.ArgumentParser(description=description_str);
+parser.add_argument("--csv", help="csv formatted output", action="store_true");
+parser.add_argument("--gk20a", help="path to gk20a.h");
+parser.add_argument("gops_filename", help="debugfs interface output file (from /d/gpu.0/hal/gops)", nargs='?');
+args = parser.parse_args();
+
+if args.gk20a:
+        gk20a_h_path = args.gk20a
+else:
+        top = environ.get('TOP');
+        if top is None:
+                print("$TOP is undefined, unable to find gk20a.h");
+                exit(-1);
+        gk20a_h_path = top + "/kernel/nvgpu/drivers/gpu/nvgpu/gk20a/gk20a.h"
+
+def get_function_pointer_name(line):
+        matches = re.search('.*\(\*(?P<function_name>\w+)\)\(', line);
+        if matches is None:
+                return None
+        else:
+                return matches.group("function_name");
+
+# Build the list of gpu_ops member function pointers from gk20a.h
+non_function_pointer_members = [];
+formatted_members = [];
+gops_members = dict();
+substruct_names = [];
+lone_members = [];
+with open(gk20a_h_path) as gk20a_h:
+        # Skip to start of gpu_ops struct
+        while gk20a_h.readline() != "struct gpu_ops {\n":
+                continue;
+
+        line = gk20a_h.readline();
+        while line != "};\n":
+                # If this is a substruct
+                if re.match('\t+struct.+\{', line):
+                        # Read the contents of the substruct
+                        line = gk20a_h.readline();
+                        struct_contents = ""
+                        while not re.match("\t*\} (\w+);", line):
+                                struct_contents += line;
+                                line = gk20a_h.readline();
+                        # Split out the substruct name and the function pointer names
+                        struct_name = re.match("\t*\} (?P<struct_name>\w+);", line).group("struct_name");
+                        struct_members = re.findall(r".+?\(\s*\*\s*(\w+)\s*\).+?;", struct_contents, flags=re.DOTALL)
+
+                        # Store the substruct as an entry
+                        substruct_names.append(struct_name);
+                        gops_members[struct_name] = struct_members;
+                        # Format members
+                        for member in struct_members:
+                                formatted_members.append(struct_name + "." + member);
+                else:
+                        # Lone members (function pointers or stuff not in a substruct)
+                        match = re.match(".*\(\*(?P<function_name>\w+)\)\(", line);
+                        if match is not None:
+                                # It's a function pointer, keep track of it
+                                lone_members.append(match.group("function_name"));
+                                formatted_members.append(match.group("function_name"));
+                        else:
+                                # Not a function pointer, may also catch comments etc.
+                                non_function_pointer_members.append(line.strip());
+                line = gk20a_h.readline();
+if args.gops_filename:
+        # Interpret gops file
+        with open(args.gops_filename) as gops:
+                i = 0;
+                # Option for csv output
+                if args.csv:
+                        format_string = '{0},{1}';
+                else:
+                        format_string = '{0:<60} = {1}';
+                for line in gops:
+                        print(format_string.format(formatted_members[i], line[:-1]));
+                        i += 1;
+else:
+        # Just print some stats on the gpu_ops struct
+        total = 0;
+        print("----- Lone Function Pointers -----");
+        print("Count =", len(lone_members));
+        total += len(lone_members);
+        for line in lone_members:
+                print(line);
+        print("----- Substruct Counts -----");
+        for name in substruct_names:
+                print(name, "=", len(gops_members[name]));
+                total += len(gops_members[name])
+        print("\n Total =", total);
diff --git a/scripts/rfr b/scripts/rfr
new file mode 100755
index 00000000..bca32d3b
--- /dev/null
+++ b/scripts/rfr
@@ -0,0 +1,233 @@
+#!/usr/bin/python
+#
+# Simple script for formatting RFR messages for nvgpu changes.
+#
+
+import os
+import re
+import json
+import argparse
+import subprocess
+
+VERSION = '1.0.0'
+
+# Gerrit commit URL formats. These are regular expressions to match the
+# incoming URLs against.
+gr_fmts = [ r'http://git-master/r/(\d+)',
+            r'http://git-master/r/#/c/(\d+)/',
+            r'http://git-master.nvidia.com/r/(\d+)',
+            r'http://git-master.nvidia.com/r/#/c/(\d+)/',
+            r'https://git-master/r/(\d+)',
+            r'https://git-master/r/#/c/(\d+)/',
+            r'https://git-master.nvidia.com/r/(\d+)',
+            r'https://git-master.nvidia.com/r/#/c/(\d+)/' ]
+
+# The user to use. May be overridden but the default comes from the environment.
+user = os.environ['USER']
+
+# Gerrit query command to obtain the patch URL. The substitution will be the
+# gerrit Change-ID parsed from the git commit message.
+gr_query_cmd = 'ssh %s@git-master -p 29418 gerrit query --format json %s'
+
+def parse_args():
+    """
+    Parse arguments to rfr.
+    """
+
+    ep="""This program will format commit messages into something that can be
+sent to the nvgpu mailing list for review
+"""
+    help_msg="""Git or gerrit commits to describe. Can be either a git or gerrit
+commit ID. If the ID starts with a 'I' then it will be treated as a gerrit ID.
+If the commit ID looks like a gerrit URL then it is treated as a gerrit URL.
+Otherwise it's treated as a git commit ID.
+"""
+    parser = argparse.ArgumentParser(description='RFR formatting tool',
+                                     epilog=ep)
+
+    parser.add_argument('-V', '--version', action='store_true', default=False,
+                        help='print the program version')
+    parser.add_argument('-m', '--msg', action='store', default=None,
+                        help='Custom message to add to the RFR email')
+
+    # Positionals: the gerrit URLs.
+    parser.add_argument('commits', metavar='Commit-IDs',
+                        nargs='+',
+                        help=help_msg)
+
+    arg_parser = parser.parse_args()
+
+    return arg_parser
+
+def get_gerrit_url_id(cmt):
+    """
+    Determines if the passed cmt is a gerrit commit URL. If it is then this
+    returns the URL ID; otherwise it returns None.
+    """
+
+    for fmt in gr_fmts:
+        p = re.compile(fmt)
+        m = p.search(cmt)
+        if m:
+            return m.group(1)
+
+    return None
+
+def gerrit_query(change):
+    """
+    Query gerrit for the JSON change information. Return a python object
+    describing the JSON data.
+
+    change can either be a Change-Id or the numeric change number from a URL.
+
+    Note there is an interesting limitation with this: gerrit can have multiple
+    changes with the same Change-Id (./sigh). So if you query a change ID that
+    points to multiple changes you get back all of them.
+
+    This script just uses the first. Ideally one could filter by branch or by
+    some other distinguishing factor.
+    """
+
+    query_cmd = gr_query_cmd % (user, change)
+
+    prog = subprocess.Popen(query_cmd, shell=True,
+                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    stdout_data, stderr_data = prog.communicate()
+    if prog.returncode != 0:
+        print('`%s\' failed!' % query_cmd)
+        return False
+
+    commit = json.loads(stdout_data.decode('utf-8').splitlines()[0])
+    if 'id' not in commit:
+        print('%s is not a gerrit commit!?' % change)
+        print('Most likely you need to push the change.')
+        return None
+
+    return commit
+
+def commit_info_from_gerrit_change_id(change_id):
+    """
+    Return a dict with all the gerrit info from a gerrit change ID.
+    """
+
+    return gerrit_query(change_id)
+
+def commit_info_from_git_sha1(rev):
+    """
+    Return a dict with all the gerrit info from a git sha1 rev.
+    """
+
+    return gerrit_query(rev)
+
+def commit_info_from_gerrit_cl(cmt):
+    """
+    Return a dict with all the gerrit info from a Gerrit URL.
+    """
+
+    cl = get_gerrit_url_id(cmt)
+    if not cl:
+        return None
+
+    return gerrit_query(cl)
+
+def git_sha1_from_commit(commit_ish):
+    """
+    Return sha1 revision from a commit-ish string, or None if this doesn't
+    appear to be a commit.
+    """
+
+    prog = subprocess.Popen('git rev-parse %s' % commit_ish, shell=True,
+                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    stdout_data, stderr_data = prog.communicate()
+    if prog.returncode != 0:
+        print('`git rev-parse %s\' failed?!' % commit_ish)
+        return None
+
+    return stdout_data.decode('utf-8')
+
+def indent_lines(text, ind):
+    """
+    Prepend each new line in the passed text with ind.
+    """
+    return ''.join(ind + l + '\n' for l in text.splitlines())
+
+def display_commits(commits_info, extra_message):
+    """
+    Takes a list of the commit info objects to print.
+    """
+
+    whole_template = """
+Hi All,
+
+I would like you to review the following changes.
+{extra_message}
+{cmt_descriptions}
+Thanks!
+{cmt_verbose}"""
+
+    cmt_template = """
++----------------------------------------
+| {url}
+| Author: {author}
+
+{cmtmsg}"""
+
+    cmt_descriptions = ''
+    for c in commits_info:
+        cmt_descriptions += "  %s - %s\n" % (c['url'], c['subject'])
+
+    # Add new lines around the extra_message, if applicable. Otherwise we don't
+    # want anything to show up for extra_message.
+    if extra_message:
+        extra_message = '\n%s\n' % extra_message
+    else:
+        extra_message = ''
+
+    cmt_verbose = ''
+    for c in commits_info:
+        cmt_verbose += cmt_template.format(url=c['url'],
+                                           author=c['owner']['name'],
+                                           cmtmsg=indent_lines(
+                                               c['commitMessage'], '  '))
+
+    print(whole_template.format(cmt_descriptions=cmt_descriptions,
+                                extra_message=extra_message,
+                                cmt_verbose=cmt_verbose))
+
+def main():
+    """
+    The magic happens here.
+    """
+
+    arg_parser = parse_args()
+    commits_info = [ ]
+
+    if arg_parser.version:
+        print('Version: %s' % VERSION)
+        exit(0)
+
+    # Builds a dictionary of Gerrit Change-Ids. From the Change-Ids we can then
+    # get the commit message and URL.
+    #
+    # This also builds an array of those same commit IDs to track the ordering
+    # of the commits so that the user can choose the order of the patches based
+    # on the order in which they pass the commits.
+    for cmt in arg_parser.commits:
+        if cmt[0] == 'I':
+            info = commit_info_from_gerrit_change_id(cmt)
+        elif get_gerrit_url_id(cmt):
+            info = commit_info_from_gerrit_cl(cmt)
+        else:
+            info = commit_info_from_git_sha1(git_sha1_from_commit(cmt))
+
+        if info:
+            commits_info.append(info)
+        else:
+            print('Warning: \'%s\' doesn\'t appear to be a commit!' % cmt)
+
+    display_commits(commits_info, arg_parser.msg)
+
+if __name__ == '__main__':
+    main()