GN: aix port along with linux_s390x, linux_ppc64 and linux_ppc64le support.

base/process/launch_posix.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 "base/process/launch.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sched.h>
@@ skipping 26 matching lines @@
 #include "base/process/process.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/third_party/valgrind/valgrind.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_AIX)
 #include <sys/prctl.h>
 #endif
 
 #if defined(OS_CHROMEOS)
 #include <sys/ioctl.h>
 #endif
 
 #if defined(OS_FREEBSD)
 #include <sys/event.h>
 #include <sys/ucontext.h>
@@ skipping 48 matching lines @@
   // but Android's pthread_sigmask() was broken until 4.1:
   // https://code.google.com/p/android/issues/detail?id=15337
   // http://stackoverflow.com/questions/13777109/pthread-sigmask-on-android-not-working
   RAW_CHECK(sigprocmask(SIG_SETMASK, &new_sigmask, &old_sigmask) == 0);
 #else
   RAW_CHECK(pthread_sigmask(SIG_SETMASK, &new_sigmask, &old_sigmask) == 0);
 #endif
   return old_sigmask;
 }
 
-#if !defined(OS_LINUX) || \
+#if (!defined(OS_LINUX) && !defined(OS_AIX)) || \
     (!defined(__i386__) && !defined(__x86_64__) && !defined(__arm__))
 void ResetChildSignalHandlersToDefaults() {
   // The previous signal handlers are likely to be meaningless in the child's
   // context so we reset them to the defaults for now. http://crbug.com/44953
   // These signal handlers are set up at least in browser_main_posix.cc:
   // BrowserMainPartsPosix::PreEarlyInitialization and stack_trace_posix.cc:
   // EnableInProcessStackDumping.
   signal(SIGHUP, SIG_DFL);
   signal(SIGINT, SIG_DFL);
   signal(SIGILL, SIG_DFL);
@@ skipping 77 matching lines @@
 struct ScopedDIRClose {
   inline void operator()(DIR* x) const {
     if (x)
       closedir(x);
   }
 };
 
 // Automatically closes |DIR*|s.
 typedef std::unique_ptr<DIR, ScopedDIRClose> ScopedDIR;
 
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_AIX)
 static const char kFDDir[] = "/proc/self/fd";
 #elif defined(OS_MACOSX)
 static const char kFDDir[] = "/dev/fd";
 #elif defined(OS_SOLARIS)
 static const char kFDDir[] = "/dev/fd";
 #elif defined(OS_FREEBSD)
 static const char kFDDir[] = "/dev/fd";
 #elif defined(OS_OPENBSD)
 static const char kFDDir[] = "/dev/fd";
 #elif defined(OS_ANDROID)
@@ skipping 109 matching lines @@
   sigset_t full_sigset;
   sigfillset(&full_sigset);
   const sigset_t orig_sigmask = SetSignalMask(full_sigset);
 
   const char* current_directory = nullptr;
   if (!options.current_directory.empty()) {
     current_directory = options.current_directory.value().c_str();
   }
 
   pid_t pid;
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_AIX)
   if (options.clone_flags) {
     // Signal handling in this function assumes the creation of a new
     // process, so we check that a thread is not being created by mistake
     // and that signal handling follows the process-creation rules.
     RAW_CHECK(
         !(options.clone_flags & (CLONE_SIGHAND | CLONE_THREAD | CLONE_VM)));
 
     // We specify a null ptid and ctid.
     RAW_CHECK(
         !(options.clone_flags &
@@ skipping 114 matching lines @@
       SetEnvironment(new_environ.get());
 
     // fd_shuffle1 is mutated by this call because it cannot malloc.
     if (!ShuffleFileDescriptors(&fd_shuffle1))
       _exit(127);
 
     CloseSuperfluousFds(fd_shuffle2);
 
     // Set NO_NEW_PRIVS by default. Since NO_NEW_PRIVS only exists in kernel
     // 3.5+, do not check the return value of prctl here.
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_AIX)
 #ifndef PR_SET_NO_NEW_PRIVS
 #define PR_SET_NO_NEW_PRIVS 38
 #endif
     if (!options.allow_new_privs) {
       if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) && errno != EINVAL) {
         // Only log if the error is not EINVAL (i.e. not supported).
         RAW_LOG(FATAL, "prctl(PR_SET_NO_NEW_PRIVS) failed");
       }
     }
 
@@ skipping 184 matching lines @@
 bool GetAppOutputWithExitCode(const CommandLine& cl,
                               std::string* output,
                               int* exit_code) {
   // Run |execve()| with the current environment.
   return GetAppOutputInternal(cl.argv(), nullptr, false, output, true,
                               exit_code);
 }
 
 #endif  // !defined(OS_NACL_NONSFI)
 
-#if defined(OS_LINUX) || defined(OS_NACL_NONSFI)
+#if defined(OS_LINUX) || defined(OS_NACL_NONSFI) || defined(OS_AIX)
 namespace {
 
 bool IsRunningOnValgrind() {
   return RUNNING_ON_VALGRIND;
 }
 
 // This function runs on the stack specified on the clone call. It uses longjmp
 // to switch back to the original stack so the child can return from sys_clone.
 int CloneHelper(void* arg) {
   jmp_buf* env_ptr = reinterpret_cast<jmp_buf*>(arg);
@@ skipping 71 matching lines @@
   jmp_buf env;
   if (setjmp(env) == 0) {
     return CloneAndLongjmpInChild(flags, ptid, ctid, &env);
   }
 
   return 0;
 }
 #endif  // defined(OS_LINUX) || defined(OS_NACL_NONSFI)
 
 }  // namespace base