zygote: Redirect 64-bit libc localtime and localtime_r routines.

content/zygote/zygote_main_linux.cc

 // Copyright (c) 2012 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.
 
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
@@ skipping 155 matching lines @@
 typedef struct tm* (*LocaltimeFunction)(const time_t* timep);
 typedef struct tm* (*LocaltimeRFunction)(const time_t* timep,
                                          struct tm* result);
 typedef FILE* (*FopenFunction)(const char* path, const char* mode);
 typedef int (*XstatFunction)(int version, const char *path, struct stat *buf);
 typedef int (*Xstat64Function)(int version, const char *path,
                                struct stat64 *buf);
 
 static pthread_once_t g_libc_localtime_funcs_guard = PTHREAD_ONCE_INIT;
 static LocaltimeFunction g_libc_localtime;
+static LocaltimeFunction g_libc_localtime64;
 static LocaltimeRFunction g_libc_localtime_r;
+static LocaltimeRFunction g_libc_localtime64_r;
 
 static pthread_once_t g_libc_file_io_funcs_guard = PTHREAD_ONCE_INIT;
 static FopenFunction g_libc_fopen;
 static FopenFunction g_libc_fopen64;
 static XstatFunction g_libc_xstat;
 static Xstat64Function g_libc_xstat64;
 
 static void InitLibcLocaltimeFunctions() {
   g_libc_localtime = reinterpret_cast<LocaltimeFunction>(
       dlsym(RTLD_NEXT, "localtime"));
+  g_libc_localtime64 = reinterpret_cast<LocaltimeFunction>(
+      dlsym(RTLD_NEXT, "localtime64"));
   g_libc_localtime_r = reinterpret_cast<LocaltimeRFunction>(
       dlsym(RTLD_NEXT, "localtime_r"));
+  g_libc_localtime64_r = reinterpret_cast<LocaltimeRFunction>(
+      dlsym(RTLD_NEXT, "localtime64_r"));
 
   if (!g_libc_localtime || !g_libc_localtime_r) {

[Jorge Lucangeli Obes, 2012/05/16 02:59:45]

Shouldn't you add checks for the *64 versions of the functions, since you're
calling them in the new code? Are we sure the bug below does not apply in this
case?

[hshi1, 2012/05/16 17:36:16]

Done.

     // http://code.google.com/p/chromium/issues/detail?id=16800
     //
     // Nvidia's libGL.so overrides dlsym for an unknown reason and replaces
     // it with a version which doesn't work. In this case we'll get a NULL
     // result. There's not a lot we can do at this point, so we just bodge it!
     LOG(ERROR) << "Your system is broken: dlsym doesn't work! This has been "
                   "reported to be caused by Nvidia's libGL. You should expect"
                   " time related functions to misbehave. "
                   "http://code.google.com/p/chromium/issues/detail?id=16800";
   }
 
   if (!g_libc_localtime)
     g_libc_localtime = gmtime;
   if (!g_libc_localtime_r)
     g_libc_localtime_r = gmtime_r;
 }
 
-struct tm* localtime(const time_t* timep) {
+__attribute__ ((__visibility__("default")))

[Jorge Lucangeli Obes, 2012/05/16 02:59:45]

Why do we need the visibility annotations?

[hshi1, 2012/05/16 03:04:09]

This is a copy&paste based on the fopen/fopen64 code. I'm not sure if it is
really needed or not...

On 2012/05/16 02:59:45, Jorge Lucangeli Obes wrote:

[hshi1, 2012/05/16 17:36:16]

It appears to be useless. I would assume that visiblity is "default" by default!

On 2012/05/16 03:04:09, hshi1 wrote:

[hshi1, 2012/05/16 17:44:57]

Sorry, I take this back. It appears that the visibility setting is indeed
necessary. Without this line I will get a system hang at boot time. I am guess
that is why this is used in the tricks for fopen and fopen64 below.

+struct tm* localtime_override(const time_t* timep) __asm__ ("localtime");
+
+__attribute__ ((__visibility__("default")))
+struct tm* localtime_override(const time_t* timep) {
   if (g_am_zygote_or_renderer) {
     static struct tm time_struct;
     static char timezone_string[64];
     ProxyLocaltimeCallToBrowser(*timep, &time_struct, timezone_string,
                                 sizeof(timezone_string));
     return &time_struct;
   } else {
     CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
                              InitLibcLocaltimeFunctions));
     return g_libc_localtime(timep);
   }
 }
 
-struct tm* localtime_r(const time_t* timep, struct tm* result) {
+__attribute__ ((__visibility__("default")))
+struct tm* localtime64_override(const time_t* timep) __asm__ ("localtime64");
+
+__attribute__ ((__visibility__("default")))
+struct tm* localtime64_override(const time_t* timep) {
+  if (g_am_zygote_or_renderer) {
+    static struct tm time_struct;
+    static char timezone_string[64];
+    ProxyLocaltimeCallToBrowser(*timep, &time_struct, timezone_string,
+                                sizeof(timezone_string));
+    return &time_struct;
+  } else {
+    CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
+                             InitLibcLocaltimeFunctions));
+    return g_libc_localtime64(timep);
+  }
+}
+
+__attribute__ ((__visibility__("default")))
+struct tm* localtime_r_override(const time_t* timep,
+                                struct tm* result) __asm__ ("localtime_r");
+
+__attribute__ ((__visibility__("default")))
+struct tm* localtime_r_override(const time_t* timep, struct tm* result) {
   if (g_am_zygote_or_renderer) {
     ProxyLocaltimeCallToBrowser(*timep, result, NULL, 0);
     return result;
   } else {
     CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
                              InitLibcLocaltimeFunctions));
     return g_libc_localtime_r(timep, result);
   }
 }
 
+__attribute__ ((__visibility__("default")))
+struct tm* localtime64_r_override(const time_t* timep,
+                                  struct tm* result) __asm__ ("localtime64_r");
+
+__attribute__ ((__visibility__("default")))
+struct tm* localtime64_r_override(const time_t* timep, struct tm* result) {
+  if (g_am_zygote_or_renderer) {
+    ProxyLocaltimeCallToBrowser(*timep, result, NULL, 0);
+    return result;
+  } else {
+    CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
+                             InitLibcLocaltimeFunctions));
+    return g_libc_localtime64_r(timep, result);
+  }
+}
+
 // TODO(sergeyu): Currently this code doesn't work properly under ASAN
 // - it crashes content_unittests. Make sure it works properly and
 // enable it here. http://crbug.com/123263
 #if !defined(ADDRESS_SANITIZER)
 
 static void InitLibcFileIOFunctions() {
   g_libc_fopen = reinterpret_cast<FopenFunction>(
       dlsym(RTLD_NEXT, "fopen"));
   g_libc_fopen64 = reinterpret_cast<FopenFunction>(
       dlsym(RTLD_NEXT, "fopen64"));
@@ skipping 291 matching lines @@
     }
   }
 #endif  // SECCOMP_SANDBOX
 
   Zygote zygote(sandbox_flags, forkdelegate, proc_fd_for_seccomp);
   // This function call can return multiple times, once per fork().
   return zygote.ProcessRequests();
 }
 
 }  // namespace content