xpcom/threads/nsProcessCommon.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /*****************************************************************************
   8  *
   9  * nsProcess is used to execute new processes and specify if you want to
  10  * wait (blocking) or continue (non-blocking).
  11  *
  12  *****************************************************************************
  13  */
  14
  15 #include "mozilla/ArrayUtils.h"
  16
  17 #include "nsCOMPtr.h"
  18 #include "nsIFile.h"
  19 #include "nsProcess.h"
  20 #include "prio.h"
  21 #include "prenv.h"
  22 #include "nsCRT.h"
  23 #include "nsThreadUtils.h"
  24 #include "nsIObserverService.h"
  25 #include "nsXULAppAPI.h"
  26 #include "mozilla/Services.h"
  27
  28 #include <stdlib.h>
  29
  30 #if defined(PROCESSMODEL_WINAPI)
  31 #  include "nsString.h"
  32 #  include "nsLiteralString.h"
  33 #  include "nsReadableUtils.h"
  34 #  include "mozilla/AssembleCmdLine.h"
  35 #  include "mozilla/UniquePtrExtensions.h"
  36 #else
  37 #  ifdef XP_MACOSX
  38 #    include <crt_externs.h>
  39 #    include <spawn.h>
  40 #  endif
  41 #  ifdef XP_UNIX
  42 #    ifndef XP_MACOSX
  43 #      include "base/process_util.h"
  44 #    endif
  45 #    include <sys/wait.h>
  46 #    include <sys/errno.h>
  47 #  endif
  48 #  include <sys/types.h>
  49 #  include <signal.h>
  50 #endif
  51
  52 using namespace mozilla;
  53
  54 //-------------------------------------------------------------------//
  55 // nsIProcess implementation
  56 //-------------------------------------------------------------------//
  57 NS_IMPL_ISUPPORTS(nsProcess, nsIProcess, nsIObserver)
  58
  59 // Constructor
  60 nsProcess::nsProcess()
  61     : mThread(nullptr),
  62       mLock("nsProcess.mLock"),
  63       mShutdown(false),
  64       mBlocking(false),
  65       mStartHidden(false),
  66       mNoShell(false),
  67       mPid(-1),
  68       mExitValue(-1)
  69 #if !defined(XP_UNIX)
  70       ,
  71       mProcess(nullptr)
  72 #endif
  73 {
  74 }
  75
  76 // Destructor
  77 nsProcess::~nsProcess() = default;
  78
  79 NS_IMETHODIMP
  80 nsProcess::Init(nsIFile* aExecutable) {
  81   if (mExecutable) {
  82     return NS_ERROR_ALREADY_INITIALIZED;
  83   }
  84
  85   if (NS_WARN_IF(!aExecutable)) {
  86     return NS_ERROR_INVALID_ARG;
  87   }
  88   bool isFile;
  89
  90   // First make sure the file exists
  91   nsresult rv = aExecutable->IsFile(&isFile);
  92   if (NS_FAILED(rv)) {
  93     return rv;
  94   }
  95   if (!isFile) {
  96     return NS_ERROR_FAILURE;
  97   }
  98
  99   // Store the nsIFile in mExecutable
 100   mExecutable = aExecutable;
 101   // Get the path because it is needed by the NSPR process creation
 102 #ifdef XP_WIN
 103   rv = mExecutable->GetTarget(mTargetPath);
 104   if (NS_FAILED(rv) || mTargetPath.IsEmpty())
 105 #endif
 106     rv = mExecutable->GetPath(mTargetPath);
 107
 108   return rv;
 109 }
 110
 111 void nsProcess::Monitor(void* aArg) {
 112   RefPtr<nsProcess> process = dont_AddRef(static_cast<nsProcess*>(aArg));
 113
 114   if (!process->mBlocking) {
 115     NS_SetCurrentThreadName("RunProcess");
 116   }
 117
 118 #if defined(PROCESSMODEL_WINAPI)
 119   HANDLE processHandle;
 120   {
 121     // The mutex region cannot include WaitForSingleObject otherwise we'll
 122     // block calls such as Kill. So lock on access and store a local.
 123     MutexAutoLock lock(process->mLock);
 124     processHandle = process->mProcess;
 125   }
 126
 127   DWORD dwRetVal;
 128   unsigned long exitCode = -1;
 129
 130   dwRetVal = WaitForSingleObject(processHandle, INFINITE);
 131   if (dwRetVal != WAIT_FAILED) {
 132     if (GetExitCodeProcess(processHandle, &exitCode) == FALSE) {
 133       exitCode = -1;
 134     }
 135   }
 136
 137   // Lock in case Kill or GetExitCode are called during this.
 138   {
 139     MutexAutoLock lock(process->mLock);
 140     CloseHandle(process->mProcess);
 141     process->mProcess = nullptr;
 142     process->mExitValue = exitCode;
 143     if (process->mShutdown) {
 144       return;
 145     }
 146   }
 147 #else
 148 #  ifdef XP_UNIX
 149   int exitCode = -1;
 150   int status = 0;
 151   pid_t result;
 152   do {
 153     result = waitpid(process->mPid, &status, 0);
 154   } while (result == -1 && errno == EINTR);
 155   if (result == process->mPid) {
 156     if (WIFEXITED(status)) {
 157       exitCode = WEXITSTATUS(status);
 158     } else if (WIFSIGNALED(status)) {
 159       exitCode = 256;  // match NSPR's signal exit status
 160     }
 161   }
 162 #  else
 163   int32_t exitCode = -1;
 164   PRProcess* prProcess;
 165   {
 166     // The mutex region cannot include PR_WaitProcess otherwise we'll
 167     // block calls such as Kill. So lock on access and store a local.
 168     MutexAutoLock lock(process->mLock);
 169     prProcess = process->mProcess;
 170   }
 171   if (PR_WaitProcess(prProcess, &exitCode) != PR_SUCCESS) {
 172     exitCode = -1;
 173   }
 174 #  endif
 175
 176   // Lock in case Kill or GetExitCode are called during this
 177   {
 178     MutexAutoLock lock(process->mLock);
 179 #  if !defined(XP_UNIX)
 180     process->mProcess = nullptr;
 181 #  endif
 182     process->mExitValue = exitCode;
 183     if (process->mShutdown) {
 184       return;
 185     }
 186   }
 187 #endif
 188
 189   // If we ran a background thread for the monitor then notify on the main
 190   // thread
 191   if (NS_IsMainThread()) {
 192     process->ProcessComplete();
 193   } else {
 194     NS_DispatchToMainThread(NewRunnableMethod(
 195         "nsProcess::ProcessComplete", process, &nsProcess::ProcessComplete));
 196   }
 197 }
 198
 199 void nsProcess::ProcessComplete() {
 200   if (mThread) {
 201     nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
 202     if (os) {
 203       os->RemoveObserver(this, "xpcom-shutdown");
 204     }
 205     PR_JoinThread(mThread);
 206     mThread = nullptr;
 207   }
 208
 209   const char* topic;
 210   {
 211     MutexAutoLock lock(mLock);
 212     if (mExitValue != 0) {
 213       topic = "process-failed";
 214     } else {
 215       topic = "process-finished";
 216     }
 217   }
 218
 219   mPid = -1;
 220   nsCOMPtr<nsIObserver> observer = mObserver.GetValue();
 221   mObserver = nullptr;
 222
 223   if (observer) {
 224     observer->Observe(NS_ISUPPORTS_CAST(nsIProcess*, this), topic, nullptr);
 225   }
 226 }
 227
 228 // XXXldb |aArgs| has the wrong const-ness
 229 NS_IMETHODIMP
 230 nsProcess::Run(bool aBlocking, const char** aArgs, uint32_t aCount) {
 231   return CopyArgsAndRunProcess(aBlocking, aArgs, aCount, nullptr, false);
 232 }
 233
 234 // XXXldb |aArgs| has the wrong const-ness
 235 NS_IMETHODIMP
 236 nsProcess::RunAsync(const char** aArgs, uint32_t aCount, nsIObserver* aObserver,
 237                     bool aHoldWeak) {
 238   return CopyArgsAndRunProcess(false, aArgs, aCount, aObserver, aHoldWeak);
 239 }
 240
 241 nsresult nsProcess::CopyArgsAndRunProcess(bool aBlocking, const char** aArgs,
 242                                           uint32_t aCount,
 243                                           nsIObserver* aObserver,
 244                                           bool aHoldWeak) {
 245   // Add one to the aCount for the program name and one for null termination.
 246   char** my_argv = nullptr;
 247   my_argv = (char**)moz_xmalloc(sizeof(char*) * (aCount + 2));
 248
 249   my_argv[0] = ToNewUTF8String(mTargetPath);
 250
 251   for (uint32_t i = 0; i < aCount; ++i) {
 252     my_argv[i + 1] = const_cast<char*>(aArgs[i]);
 253   }
 254
 255   my_argv[aCount + 1] = nullptr;
 256
 257   nsresult rv = RunProcess(aBlocking, my_argv, aObserver, aHoldWeak, false);
 258
 259   free(my_argv[0]);
 260   free(my_argv);
 261   return rv;
 262 }
 263
 264 // XXXldb |aArgs| has the wrong const-ness
 265 NS_IMETHODIMP
 266 nsProcess::Runw(bool aBlocking, const char16_t** aArgs, uint32_t aCount) {
 267   return CopyArgsAndRunProcessw(aBlocking, aArgs, aCount, nullptr, false);
 268 }
 269
 270 // XXXldb |aArgs| has the wrong const-ness
 271 NS_IMETHODIMP
 272 nsProcess::RunwAsync(const char16_t** aArgs, uint32_t aCount,
 273                      nsIObserver* aObserver, bool aHoldWeak) {
 274   return CopyArgsAndRunProcessw(false, aArgs, aCount, aObserver, aHoldWeak);
 275 }
 276
 277 nsresult nsProcess::CopyArgsAndRunProcessw(bool aBlocking,
 278                                            const char16_t** aArgs,
 279                                            uint32_t aCount,
 280                                            nsIObserver* aObserver,
 281                                            bool aHoldWeak) {
 282   // Add one to the aCount for the program name and one for null termination.
 283   char** my_argv = nullptr;
 284   my_argv = (char**)moz_xmalloc(sizeof(char*) * (aCount + 2));
 285
 286   my_argv[0] = ToNewUTF8String(mTargetPath);
 287
 288   for (uint32_t i = 0; i < aCount; i++) {
 289     my_argv[i + 1] = ToNewUTF8String(nsDependentString(aArgs[i]));
 290   }
 291
 292   my_argv[aCount + 1] = nullptr;
 293
 294   nsresult rv = RunProcess(aBlocking, my_argv, aObserver, aHoldWeak, true);
 295
 296   for (uint32_t i = 0; i <= aCount; ++i) {
 297     free(my_argv[i]);
 298   }
 299   free(my_argv);
 300   return rv;
 301 }
 302
 303 nsresult nsProcess::RunProcess(bool aBlocking, char** aMyArgv,
 304                                nsIObserver* aObserver, bool aHoldWeak,
 305                                bool aArgsUTF8) {
 306   NS_WARNING_ASSERTION(!XRE_IsContentProcess(),
 307                        "No launching of new processes in the content process");
 308
 309   if (NS_WARN_IF(!mExecutable)) {
 310     return NS_ERROR_NOT_INITIALIZED;
 311   }
 312   if (NS_WARN_IF(mThread)) {
 313     return NS_ERROR_ALREADY_INITIALIZED;
 314   }
 315
 316   if (aObserver) {
 317     if (aHoldWeak) {
 318       nsresult rv = NS_OK;
 319       mObserver = do_GetWeakReference(aObserver, &rv);
 320       NS_ENSURE_SUCCESS(rv, rv);
 321     } else {
 322       mObserver = aObserver;
 323     }
 324   }
 325
 326   {
 327     MutexAutoLock lock(mLock);
 328     mExitValue = -1;
 329     mPid = -1;
 330   }
 331
 332 #if defined(PROCESSMODEL_WINAPI)
 333   BOOL retVal;
 334   UniqueFreePtr<wchar_t> cmdLine;
 335
 336   // |aMyArgv| is null-terminated and always starts with the program path. If
 337   // the second slot is non-null then arguments are being passed.
 338   if (aMyArgv[1] || mNoShell) {
 339     // Pass the executable path as argv[0] to the launched program when calling
 340     // CreateProcess().
 341     char** argv = mNoShell ? aMyArgv : aMyArgv + 1;
 342
 343     wchar_t* assembledCmdLine = nullptr;
 344     if (assembleCmdLine(argv, &assembledCmdLine,
 345                         aArgsUTF8 ? CP_UTF8 : CP_ACP) == -1) {
 346       return NS_ERROR_FILE_EXECUTION_FAILED;
 347     }
 348     cmdLine.reset(assembledCmdLine);
 349   }
 350
 351   // The program name in aMyArgv[0] is always UTF-8
 352   NS_ConvertUTF8toUTF16 wideFile(aMyArgv[0]);
 353
 354   if (mNoShell) {
 355     STARTUPINFO startupInfo;
 356     ZeroMemory(&startupInfo, sizeof(startupInfo));
 357     startupInfo.cb = sizeof(startupInfo);
 358     startupInfo.dwFlags = STARTF_USESHOWWINDOW;
 359     startupInfo.wShowWindow = mStartHidden ? SW_HIDE : SW_SHOWNORMAL;
 360
 361     PROCESS_INFORMATION processInfo;
 362     retVal = CreateProcess(/* lpApplicationName = */ wideFile.get(),
 363                            /* lpCommandLine */ cmdLine.get(),
 364                            /* lpProcessAttributes = */ NULL,
 365                            /* lpThreadAttributes = */ NULL,
 366                            /* bInheritHandles = */ FALSE,
 367                            /* dwCreationFlags = */ 0,
 368                            /* lpEnvironment = */ NULL,
 369                            /* lpCurrentDirectory = */ NULL,
 370                            /* lpStartupInfo = */ &startupInfo,
 371                            /* lpProcessInformation */ &processInfo);
 372
 373     if (!retVal) {
 374       return NS_ERROR_FILE_EXECUTION_FAILED;
 375     }
 376
 377     CloseHandle(processInfo.hThread);
 378
 379     // TODO(bug 1763051): assess if we need further work around this locking.
 380     MutexAutoLock lock(mLock);
 381     mProcess = processInfo.hProcess;
 382   } else {
 383     SHELLEXECUTEINFOW sinfo;
 384     memset(&sinfo, 0, sizeof(SHELLEXECUTEINFOW));
 385     sinfo.cbSize = sizeof(SHELLEXECUTEINFOW);
 386     sinfo.hwnd = nullptr;
 387     sinfo.lpFile = wideFile.get();
 388     sinfo.nShow = mStartHidden ? SW_HIDE : SW_SHOWNORMAL;
 389
 390     /* The SEE_MASK_NO_CONSOLE flag is important to prevent console windows
 391      * from appearing. This makes behavior the same on all platforms. The flag
 392      * will not have any effect on non-console applications.
 393      */
 394     sinfo.fMask =
 395         SEE_MASK_FLAG_DDEWAIT | SEE_MASK_NO_CONSOLE | SEE_MASK_NOCLOSEPROCESS;
 396
 397     if (cmdLine) {
 398       sinfo.lpParameters = cmdLine.get();
 399     }
 400
 401     retVal = ShellExecuteExW(&sinfo);
 402     if (!retVal) {
 403       return NS_ERROR_FILE_EXECUTION_FAILED;
 404     }
 405
 406     MutexAutoLock lock(mLock);
 407     mProcess = sinfo.hProcess;
 408   }
 409
 410   {
 411     MutexAutoLock lock(mLock);
 412     mPid = GetProcessId(mProcess);
 413   }
 414 #elif defined(XP_MACOSX)
 415   // Note: |aMyArgv| is already null-terminated as required by posix_spawnp.
 416   pid_t newPid = 0;
 417   int result = posix_spawnp(&newPid, aMyArgv[0], nullptr, nullptr, aMyArgv,
 418                             *_NSGetEnviron());
 419   mPid = static_cast<int32_t>(newPid);
 420
 421   if (result != 0) {
 422     return NS_ERROR_FAILURE;
 423   }
 424 #elif defined(XP_UNIX)
 425   base::LaunchOptions options;
 426   std::vector<std::string> argvVec;
 427   for (char** arg = aMyArgv; *arg != nullptr; ++arg) {
 428     argvVec.push_back(*arg);
 429   }
 430   pid_t newPid;
 431   if (base::LaunchApp(argvVec, std::move(options), &newPid).isOk()) {
 432     static_assert(sizeof(pid_t) <= sizeof(int32_t),
 433                   "mPid is large enough to hold a pid");
 434     mPid = static_cast<int32_t>(newPid);
 435   } else {
 436     return NS_ERROR_FAILURE;
 437   }
 438 #else
 439   {
 440     PRProcess* prProcess =
 441         PR_CreateProcess(aMyArgv[0], aMyArgv, nullptr, nullptr);
 442     if (!prProcess) {
 443       return NS_ERROR_FAILURE;
 444     }
 445     {
 446       MutexAutoLock lock(mLock);
 447       mProcess = prProcess;
 448     }
 449     struct MYProcess {
 450       uint32_t pid;
 451     };
 452     MYProcess* ptrProc = (MYProcess*)mProcess;
 453     mPid = ptrProc->pid;
 454   }
 455 #endif
 456
 457   NS_ADDREF_THIS();
 458   mBlocking = aBlocking;
 459   if (aBlocking) {
 460     Monitor(this);
 461     MutexAutoLock lock(mLock);
 462     if (mExitValue < 0) {
 463       return NS_ERROR_FILE_EXECUTION_FAILED;
 464     }
 465   } else {
 466     mThread = CreateMonitorThread();
 467     if (!mThread) {
 468       NS_RELEASE_THIS();
 469       return NS_ERROR_FAILURE;
 470     }
 471
 472     // It isn't a failure if we just can't watch for shutdown
 473     nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
 474     if (os) {
 475       os->AddObserver(this, "xpcom-shutdown", false);
 476     }
 477   }
 478
 479   return NS_OK;
 480 }
 481
 482 // We don't guarantee that monitor threads are joined before Gecko exits, which
 483 // can cause TSAN to complain about thread leaks. We handle this with a TSAN
 484 // suppression, and route thread creation through this helper so that the
 485 // suppression is as narrowly-scoped as possible.
 486 PRThread* nsProcess::CreateMonitorThread() {
 487   return PR_CreateThread(PR_SYSTEM_THREAD, Monitor, this, PR_PRIORITY_NORMAL,
 488                          PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
 489 }
 490
 491 NS_IMETHODIMP
 492 nsProcess::GetIsRunning(bool* aIsRunning) {
 493   if (mThread) {
 494     *aIsRunning = true;
 495   } else {
 496     *aIsRunning = false;
 497   }
 498
 499   return NS_OK;
 500 }
 501
 502 NS_IMETHODIMP
 503 nsProcess::GetStartHidden(bool* aStartHidden) {
 504   *aStartHidden = mStartHidden;
 505   return NS_OK;
 506 }
 507
 508 NS_IMETHODIMP
 509 nsProcess::SetStartHidden(bool aStartHidden) {
 510   mStartHidden = aStartHidden;
 511   return NS_OK;
 512 }
 513
 514 NS_IMETHODIMP
 515 nsProcess::GetNoShell(bool* aNoShell) {
 516   *aNoShell = mNoShell;
 517   return NS_OK;
 518 }
 519
 520 NS_IMETHODIMP
 521 nsProcess::SetNoShell(bool aNoShell) {
 522   mNoShell = aNoShell;
 523   return NS_OK;
 524 }
 525
 526 NS_IMETHODIMP
 527 nsProcess::GetPid(uint32_t* aPid) {
 528   if (!mThread) {
 529     return NS_ERROR_FAILURE;
 530   }
 531   if (mPid < 0) {
 532     return NS_ERROR_NOT_IMPLEMENTED;
 533   }
 534   *aPid = mPid;
 535   return NS_OK;
 536 }
 537
 538 NS_IMETHODIMP
 539 nsProcess::Kill() {
 540   if (!mThread) {
 541     return NS_ERROR_FAILURE;
 542   }
 543
 544   {
 545     MutexAutoLock lock(mLock);
 546 #if defined(PROCESSMODEL_WINAPI)
 547     if (TerminateProcess(mProcess, 0) == 0) {
 548       return NS_ERROR_FAILURE;
 549     }
 550 #elif defined(XP_UNIX)
 551     if (kill(mPid, SIGKILL) != 0) {
 552       return NS_ERROR_FAILURE;
 553     }
 554 #else
 555     if (!mProcess || (PR_KillProcess(mProcess) != PR_SUCCESS)) {
 556       return NS_ERROR_FAILURE;
 557     }
 558 #endif
 559   }
 560
 561   // We must null out mThread if we want IsRunning to return false immediately
 562   // after this call.
 563   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
 564   if (os) {
 565     os->RemoveObserver(this, "xpcom-shutdown");
 566   }
 567   PR_JoinThread(mThread);
 568   mThread = nullptr;
 569
 570   return NS_OK;
 571 }
 572
 573 NS_IMETHODIMP
 574 nsProcess::GetExitValue(int32_t* aExitValue) {
 575   MutexAutoLock lock(mLock);
 576
 577   *aExitValue = mExitValue;
 578
 579   return NS_OK;
 580 }
 581
 582 NS_IMETHODIMP
 583 nsProcess::Observe(nsISupports* aSubject, const char* aTopic,
 584                    const char16_t* aData) {
 585   // Shutting down, drop all references
 586   if (mThread) {
 587     nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
 588     if (os) {
 589       os->RemoveObserver(this, "xpcom-shutdown");
 590     }
 591     mThread = nullptr;
 592   }
 593
 594   mObserver = nullptr;
 595
 596   MutexAutoLock lock(mLock);
 597   mShutdown = true;
 598
 599   return NS_OK;
 600 }