Stackable IRT

src/untrusted/nacl/nacl_irt_init.c

 /*
  * Copyright (c) 2013 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "native_client/src/include/elf_auxv.h"
 #include "native_client/src/include/elf32.h"
 #include "native_client/src/untrusted/nacl/nacl_irt.h"
 
 static int __libnacl_irt_mprotect(void *addr, size_t len, int prot) {
   return ENOSYS;
 }
 
+#if 0
+void __libnacl_irt_init_module(void) {
+  size_t count;
+  size_t i;
+
+  count = 0;
+  while (NULL != nacl_irt_array[count].module_init) {
+    ++count;
+  }
+
+  for (i = 0; i < count; ++i) {
+    if (NULL != nacl_irt_array[i].module_init) {
+      nacl_irt_array[i].module_init();
+    }
+  }
+}
+
+void __libnacl_irt_fini_module(void) {
+  size_t count;
+  size_t i;
+
+  count = 0;
+  while (NULL != nacl_irt_array[count].module_init) {
+    ++count;
+  }
+
+  for (i = 0; i < count; ++i) {
+    if (NULL != nacl_irt_array[i].module_fini) {
+      nacl_irt_array[i].module_fini();
+    }
+  }
+}
+
+int nacl_irt_module_register(TYPE_nacl_irt_module_ctor ctor) {
+  TYPE_nacl_irt_query irt_query = NULL;
+  if ((irt_query = ctor(__nacl_irt_query)) != NULL) {
+    __nacl_irt_query = irt_query;
+    return 1;
+  }
+  return 0;
+}
+#endif
+
+#if 0
+extern void (*__libnacl_irt_init_array_start []) (void) __attribute__((weak));
+extern void (*__libnacl_irt_init_array_end []) (void) __attribute__((weak));
+
+/* Iterate over all the init routines.  */
+void __libnacl_irt_init_array(void) {
+  size_t count;
+  size_t i;
+
+  _init();
+
+  count = __init_array_end - __init_array_start;
+  for (i = 0; i < count; i++) {
+    __init_array_start[i] ();
+  }
+}
+#endif
+
 /*
  * Scan the auxv for AT_SYSINFO, which is the pointer to the IRT query function.
  * Stash that for later use.
  */
 static void grok_auxv(const Elf32_auxv_t *auxv) {
   const Elf32_auxv_t *av;
   for (av = auxv; av->a_type != AT_NULL; ++av) {
     if (av->a_type == AT_SYSINFO) {
       __nacl_irt_query = (TYPE_nacl_irt_query) av->a_un.a_val;
     }
   }
 }
 
 #define DO_QUERY(ident, name)                                   \
   __libnacl_mandatory_irt_query(ident, &__libnacl_irt_##name,   \
                                 sizeof(__libnacl_irt_##name))
 
 /*
  * Initialize all our IRT function tables using the query function.
  * The query function's address is passed via AT_SYSINFO in auxv.
  */
-void __libnacl_irt_init(Elf32_auxv_t *auxv) {
+void __libnacl_irt_init(int argc, char **argv, Elf32_auxv_t *auxv) {
   grok_auxv(auxv);
 
+#if 0
+  {
+    struct nacl_irt *irt = nacl_irt_new(NULL, __nacl_irt_query, NULL);
+    if (irt != NULL) {
+      nacl_irt_layer_init(irt->layer);
+    }
+  }
+  DO_QUERY(NACL_IRT_INSTANCE_v0_1, instance);
+
+  atexit(__libnacl_irt_instance.destroy);
+  __libnacl_irt_instance.init();
+#endif
+
   /*
    * The "fdio" interface doesn't do anything useful in Chromium (with the
    * exception that write() sometimes produces useful debugging output for
    * stdout/stderr), so don't abort if the it is not available.
    *
    * We query for "fdio" early on so that write() can produce a useful
    * debugging message if any other IRT queries fail.
    */
   if (!__libnacl_irt_query(NACL_IRT_FDIO_v0_1, &__libnacl_irt_fdio,
                            sizeof(__libnacl_irt_fdio))) {
@@ skipping 16 matching lines @@
                                     &old_irt_memory,
                                     sizeof(struct nacl_irt_memory_v0_1));
       __libnacl_irt_memory.mprotect = __libnacl_irt_mprotect;
     }
     __libnacl_irt_memory.mmap = old_irt_memory.mmap;
     __libnacl_irt_memory.munmap = old_irt_memory.munmap;
   }
 
   DO_QUERY(NACL_IRT_TLS_v0_1, tls);
 }