MemorySanitizer: remove msan_unpoison_string() from zygote_main_linux.cc

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 "content/zygote/zygote_main.h"
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
@@ skipping 163 matching lines @@
   if (!g_libc_localtime)
     g_libc_localtime = gmtime;
   if (!g_libc_localtime64)
     g_libc_localtime64 = g_libc_localtime;
   if (!g_libc_localtime_r)
     g_libc_localtime_r = gmtime_r;
   if (!g_libc_localtime64_r)
     g_libc_localtime64_r = g_libc_localtime_r;
 }
 
-#if defined(MEMORY_SANITIZER)
-void msan_unpoison_string(const char *s) {
-  if (!s) return;
-  // Can't call strlen() on an uninitialized string. Instead, unpoison byte by
-  // byte until the string is over.
-  do {
-    __msan_unpoison(s, sizeof(*s));
-  } while(*(s++));
-}
-#endif
-
 // Define localtime_override() function with asm name "localtime", so that all
 // references to localtime() will resolve to this function. Notice that we need
 // to set visibility attribute to "default" to export the symbol, as it is set
 // to "hidden" by default in chrome per build/common.gypi.
 __attribute__ ((__visibility__("default")))
 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));
     struct tm* res = g_libc_localtime(timep);
 #if defined(MEMORY_SANITIZER)
     if (res) __msan_unpoison(res, sizeof(*res));
-    if (res->tm_zone) msan_unpoison_string(res->tm_zone);
+    if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
 #endif
     return res;
   }
 }
 
 // Use same trick to override localtime64(), localtime_r() and localtime64_r().
 __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));
     struct tm* res = g_libc_localtime64(timep);
 #if defined(MEMORY_SANITIZER)
     if (res) __msan_unpoison(res, sizeof(*res));
-    if (res->tm_zone) msan_unpoison_string(res->tm_zone);
+    if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
 #endif
     return res;
   }
 }
 
 __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));
     struct tm* res = g_libc_localtime_r(timep, result);
 #if defined(MEMORY_SANITIZER)
     if (res) __msan_unpoison(res, sizeof(*res));
-    if (res->tm_zone) msan_unpoison_string(res->tm_zone);
+    if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
 #endif
     return res;
   }
 }
 
 __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));
     struct tm* res = g_libc_localtime64_r(timep, result);
 #if defined(MEMORY_SANITIZER)
     if (res) __msan_unpoison(res, sizeof(*res));
-    if (res->tm_zone) msan_unpoison_string(res->tm_zone);
+    if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
 #endif
     return res;
   }
 }
 
 #if defined(ENABLE_PLUGINS)
 // Loads the (native) libraries but does not initialize them (i.e., does not
 // call PPP_InitializeModule). This is needed by the zygote on Linux to get
 // access to the plugins before entering the sandbox.
 void PreloadPepperPlugins() {
@@ skipping 184 matching lines @@
   int sandbox_flags = linux_sandbox->GetStatus();
   bool setuid_sandbox_engaged = sandbox_flags & kSandboxLinuxSUID;
   CHECK_EQ(must_enable_setuid_sandbox, setuid_sandbox_engaged);
 
   Zygote zygote(sandbox_flags, fork_delegates.Pass());
   // This function call can return multiple times, once per fork().
   return zygote.ProcessRequests();
 }
 
 }  // namespace content