Make nacl_helper easily debuggable

chrome/nacl/nacl_helper_bootstrap_linux.c

 /* Copyright (c) 2011 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * This is a standalone program that loads and runs the dynamic linker.
  * This program itself must be linked statically.  To keep it small, it's
  * written to avoid all dependencies on libc and standard startup code.
  * Hence, this should be linked using -nostartfiles.  It must be compiled
  * with -fno-stack-protector to ensure the compiler won't emit code that
  * presumes some special setup has been done.
  *
  * On ARM, the compiler will emit calls to some libc functions, so we
  * cannot link with -nostdlib.  The functions it does use (memset and
  * __aeabi_* functions for integer division) are sufficiently small and
  * self-contained in ARM's libc.a that we don't have any problem using
  * the libc definitions though we aren't using the rest of libc or doing
  * any of the setup it might expect.
  */
 
 #include <elf.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <link.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/mman.h>
 
 #define MAX_PHNUM               12
 
+/*
+ * This exact magic argument string is recognized in check_r_debug_arg, below.
+ */
+#define R_DEBUG_TEMPLATE_PREFIX "--r_debug=0x"
+#define R_DEBUG_TEMPLATE_DIGITS "XXXXXXXXXXXXXXXX"
+static const char kRDebugTemplate[] =
+    R_DEBUG_TEMPLATE_PREFIX R_DEBUG_TEMPLATE_DIGITS;
+static const size_t kRDebugPrefixLen = sizeof R_DEBUG_TEMPLATE_PREFIX - 1;

[Mark Seaborn, 2011/11/14 20:15:41]

consistency: elsewhere you use sizeof() (i.e. with brackets).

+
 
 /*
  * We're not using <string.h> functions here, to avoid dependencies.
  * In the x86 libc, even "simple" functions like memset and strlen can
  * depend on complex startup code, because in newer libc
  * implementations they are defined using STT_GNU_IFUNC.
  */
 
 static void my_bzero(void *buf, size_t n) {
   char *p = buf;
   while (n-- > 0)
     *p++ = 0;
 }
 
 static size_t my_strlen(const char *s) {
   size_t n = 0;
   while (*s++ != '\0')
     ++n;
   return n;
 }
 
+static int my_strcmp(const char *a, const char *b) {
+  while (*a == *b) {
+    if (*a == '\0')
+      return 0;
+    ++a;
+    ++b;
+  }
+  return (int) (unsigned char) *a - (int) (unsigned char) *b;
+}
+
 
 /*
  * Get inline functions for system calls.
  */
 static int my_errno;
 #define SYS_ERRNO my_errno
 #include "third_party/lss/linux_syscall_support.h"
 
 
 /*
@@ skipping 279 matching lines @@
 
   if (out_phdr != NULL)
     *out_phdr = (ehdr.e_phoff - first_load->p_offset +
                  first_load->p_vaddr + load_bias);
   if (out_phnum != NULL)
     *out_phnum = ehdr.e_phnum;
 
   return ehdr.e_entry + load_bias;
 }
 
+
+/*
+ * GDB looks for this symbol name when it cannot find PT_DYNAMIC->DT_DEBUG.
+ * We don't have a PT_DYNAMIC, so it will find this.  Now all we have to do
+ * is arrange for this space to be filled in with the dynamic linker's
+ * _r_debug contents after they're initialized.  That way, attaching GDB to
+ * this process or examining its core file will find the PIE we loaded, the
+ * dynamic linker, and all the shared libraries, making debugging pleasant.
+ */
+struct r_debug _r_debug __attribute__((nocommon, section(".r_debug")));
+
+/*
+ * If the argument matches the kRDebugTemplate string, then replace
+ * the 16 Xs with the hexadecimal address of our _r_debug variable.
+ */
+static int check_r_debug_arg(char *arg) {
+  if (!my_strcmp(arg, kRDebugTemplate)) {

[Mark Seaborn, 2011/11/14 20:15:41]

prefer "strcmp(x,y) == 0" since strcmp()'s result is not a boolean.

+    uintptr_t addr = (uintptr_t) &_r_debug;
+    size_t i = 16;
+    while (i-- > 0) {
+      arg[kRDebugPrefixLen + i] = "0123456789abcdef"[addr & 0xf];
+      addr >>= 4;
+    }
+    return 1;
+  }
+  return 0;
+}
+
+
 /*
  * This is the main loading code.  It's called with the starting stack pointer.
  * This points to a sequence of pointer-size words:
  *      [0]             argc
  *      [1..argc]       argv[0..argc-1]
  *      [1+argc]        NULL
  *      [2+argc..]      envp[0..]
  *                      NULL
  *                      auxv[0].a_type
  *                      auxv[1].a_un.a_val
@@ skipping 35 matching lines @@
    * that, envp and auxv will start one word back from where they were.
    */
   --argc;
   --envp;
   auxv = (ElfW(auxv_t) *) ep;
   stack[0] = argc;
   for (i = 1; i < stack_words; ++i)
     stack[i] = stack[i + 1];
 
   /*
+   * If one of our arguments is the kRDebugTemplate string, then
+   * we'll modify that argument string in place to specify the
+   * address of our _r_debug structure.
+   */
+  for (i = 1; i < argc; ++i) {
+    if (check_r_debug_arg(argv[i]))
+      break;
+  }
+
+  /*
    * Record the auxv entries that are specific to the file loaded.
    * The incoming entries point to our own static executable.
    */
   ElfW(auxv_t) *av_entry = NULL;
   ElfW(auxv_t) *av_phdr = NULL;
   ElfW(auxv_t) *av_phnum = NULL;
   size_t pagesize = 0;
 
   for (av = auxv;
        av_entry == NULL || av_phdr == NULL || av_phnum == NULL || pagesize == 0;
@@ skipping 90 matching lines @@
     "mov r4, sp\n"              /* Save starting SP in r4.  */
     "mov r0, sp\n"              /* Argument: stack block.  */
     "bl do_load\n"
     "mov sp, r4\n"              /* Restore the saved SP.  */
     "blx r0\n"                  /* Jump to the entry point.  */
     ".popsection"
     );
 #else
 # error "Need stack-preserving _start code for this architecture!"
 #endif