diff --git a/tools/argdist.py b/tools/argdist.py
index 3bcf43a47740..f5422d90c827 100755
--- a/tools/argdist.py
+++ b/tools/argdist.py
@@ -258,7 +258,7 @@ def _generate_streq_function(self, string):
         char needle[] = %s;
         char haystack[sizeof(needle)];
         bpf_probe_read(&haystack, sizeof(haystack), (void *)str);
-        for (int i = 0; i < sizeof(needle); ++i) {
+        for (int i = 0; i < sizeof(needle) - 1; ++i) {
                 if (needle[i] != haystack[i]) {
                         return false;
                 }
diff --git a/tools/tplist.py b/tools/tplist.py
index 627f20ed35a0..c7656a68bff9 100755
--- a/tools/tplist.py
+++ b/tools/tplist.py
@@ -68,7 +68,7 @@ def print_tracepoints():
 def print_usdt_argument_details(location):
         for idx in xrange(0, location.num_arguments):
                 arg = location.get_argument(idx)
-                print("    argument #%d %s" % (idx, arg))
+                print("    argument #%d %s" % (idx+1, arg))
 
 def print_usdt_details(probe):
         if args.verbosity > 0:
@@ -76,7 +76,7 @@ def print_usdt_details(probe):
                 if args.verbosity > 1:
                         for idx in xrange(0, probe.num_locations):
                                 loc = probe.get_location(idx)
-                                print("  location #%d %s" % (idx, loc))
+                                print("  location #%d %s" % (idx+1, loc))
                                 print_usdt_argument_details(loc)
                 else:
                         print("  %d location(s)" % probe.num_locations)
diff --git a/tools/trace.py b/tools/trace.py
index 8ac92010f159..52fc99d10146 100755
--- a/tools/trace.py
+++ b/tools/trace.py
@@ -217,11 +217,11 @@ def _generate_streq_function(self, string):
                 fname = "streq_%d" % Probe.streq_index
                 Probe.streq_index += 1
                 self.streq_functions += """
-static inline bool %s(char const *ignored, unsigned long str) {
+static inline bool %s(char const *ignored, uintptr_t str) {
         char needle[] = %s;
         char haystack[sizeof(needle)];
         bpf_probe_read(&haystack, sizeof(haystack), (void *)str);
-        for (int i = 0; i < sizeof(needle); ++i) {
+        for (int i = 0; i < sizeof(needle) - 1; ++i) {
                 if (needle[i] != haystack[i]) {
                         return false;
                 }
@@ -354,33 +354,35 @@ def _generate_field_assign(self, idx):
 
         def _generate_usdt_filter_read(self):
             text = ""
-            if self.probe_type == "u":
-                    for arg, _ in Probe.aliases.items():
-                        if not (arg.startswith("arg") and
-                                (arg in self.filter)):
-                                continue
-                        arg_index = int(arg.replace("arg", ""))
-                        arg_ctype = self.usdt.get_probe_arg_ctype(
-                                self.usdt_name, arg_index)
-                        if not arg_ctype:
-                                self._bail("Unable to determine type of {} "
-                                           "in the filter".format(arg))
-                        text += """
+            if self.probe_type != "u":
+                    return text
+            for arg, _ in Probe.aliases.items():
+                    if not (arg.startswith("arg") and
+                            (arg in self.filter)):
+                            continue
+                    arg_index = int(arg.replace("arg", ""))
+                    arg_ctype = self.usdt.get_probe_arg_ctype(
+                            self.usdt_name, arg_index - 1)
+                    if not arg_ctype:
+                            self._bail("Unable to determine type of {} "
+                                       "in the filter".format(arg))
+                    text += """
         {} {}_filter;
         bpf_usdt_readarg({}, ctx, &{}_filter);
-                        """.format(arg_ctype, arg, arg_index, arg)
-                        self.filter = self.filter.replace(
-                                arg, "{}_filter".format(arg))
+                    """.format(arg_ctype, arg, arg_index, arg)
+                    self.filter = self.filter.replace(
+                            arg, "{}_filter".format(arg))
             return text
 
         def generate_program(self, include_self):
                 data_decl = self._generate_data_decl()
-                # kprobes don't have built-in pid filters, so we have to add
-                # it to the function body:
-                if len(self.library) == 0 and Probe.pid != -1:
+                if Probe.pid != -1:
                         pid_filter = """
         if (__pid != %d) { return 0; }
                 """ % Probe.pid
+                # uprobes can have a built-in tgid filter passed to
+                # attach_uprobe, hence the check here -- for kprobes, we
+                # need to do the tgid test by hand:
                 elif len(self.library) == 0 and Probe.tgid != -1:
                         pid_filter = """
         if (__tgid != %d) { return 0; }
@@ -542,12 +544,12 @@ def _attach_u(self, bpf):
                         bpf.attach_uretprobe(name=libpath,
                                              sym=self.function,
                                              fn_name=self.probe_name,
-                                             pid=Probe.pid)
+                                             pid=Probe.tgid)
                 else:
                         bpf.attach_uprobe(name=libpath,
                                           sym=self.function,
                                           fn_name=self.probe_name,
-                                          pid=Probe.pid)
+                                          pid=Probe.tgid)
 
 class Tool(object):
         examples = """