flang/runtime/execute.cpp

   1 //===-- runtime/execute.cpp -----------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "flang/Runtime/execute.h"
  10 #include "environment.h"
  11 #include "stat.h"
  12 #include "terminator.h"
  13 #include "tools.h"
  14 #include "flang/Runtime/descriptor.h"
  15 #include <cstdlib>
  16 #include <errno.h>
  17 #include <future>
  18 #include <limits>
  19
  20 #ifdef _WIN32
  21 #include "flang/Common/windows-include.h"
  22 #else
  23 #include <signal.h>
  24 #include <sys/wait.h>
  25 #include <unistd.h>
  26 #endif
  27
  28 namespace Fortran::runtime {
  29
  30 // cmdstat specified in 16.9.73
  31 // −1 if the processor does not support command line execution,
  32 // a processor-dependent positive value if an error condition occurs
  33 // −2 if no error condition occurs but WAIT is present with the value false
  34 // and the processor does not support asynchronous execution. Otherwise it is
  35 // assigned the value 0
  36 enum CMD_STAT {
  37   ASYNC_NO_SUPPORT_ERR = -2, // system returns -1 with ENOENT
  38   NO_SUPPORT_ERR = -1, // Linux setsid() returns -1
  39   CMD_EXECUTED = 0, // command executed with no error
  40   FORK_ERR = 1, // Linux fork() returns < 0
  41   EXECL_ERR = 2, // system returns -1 with other errno
  42   COMMAND_EXECUTION_ERR = 3, // exit code 1
  43   COMMAND_CANNOT_EXECUTE_ERR = 4, // Linux exit code 126
  44   COMMAND_NOT_FOUND_ERR = 5, // Linux exit code 127
  45   INVALID_CL_ERR = 6, // cover all other non-zero exit code
  46   SIGNAL_ERR = 7
  47 };
  48
  49 // Override CopyCharsToDescriptor in tools.h, pass string directly
  50 void CopyCharsToDescriptor(const Descriptor &value, const char *rawValue) {
  51   CopyCharsToDescriptor(value, rawValue, std::strlen(rawValue));
  52 }
  53
  54 void CheckAndCopyCharsToDescriptor(
  55     const Descriptor *value, const char *rawValue) {
  56   if (value) {
  57     CopyCharsToDescriptor(*value, rawValue);
  58   }
  59 }
  60
  61 void CheckAndStoreIntToDescriptor(
  62     const Descriptor *intVal, std::int64_t value, Terminator &terminator) {
  63   if (intVal) {
  64     StoreIntToDescriptor(intVal, value, terminator);
  65   }
  66 }
  67
  68 // If a condition occurs that would assign a nonzero value to CMDSTAT but
  69 // the CMDSTAT variable is not present, error termination is initiated.
  70 std::int64_t TerminationCheck(std::int64_t status, const Descriptor *cmdstat,
  71     const Descriptor *cmdmsg, Terminator &terminator) {
  72   // On both Windows and Linux, errno is set when system returns -1.
  73   if (status == -1) {
  74     // On Windows, ENOENT means the command interpreter can't be found.
  75     // On Linux, system calls execl with filepath "/bin/sh", ENOENT means the
  76     // file pathname does not exist.
  77     if (errno == ENOENT) {
  78       if (!cmdstat) {
  79         terminator.Crash("Command line execution is not supported, system "
  80                          "returns -1 with errno ENOENT.");
  81       } else {
  82         StoreIntToDescriptor(cmdstat, NO_SUPPORT_ERR, terminator);
  83         CheckAndCopyCharsToDescriptor(cmdmsg,
  84             "Command line execution is not supported, system returns -1 with "
  85             "errno ENOENT.");
  86       }
  87     } else {
  88       char err_buffer[30];
  89       char msg[]{"Execution error with system status code: -1, errno: "};
  90 #ifdef _WIN32
  91       if (strerror_s(err_buffer, sizeof(err_buffer), errno) != 0)
  92 #else
  93       if (strerror_r(errno, err_buffer, sizeof(err_buffer)) != 0)
  94 #endif
  95         terminator.Crash("errno to char msg failed.");
  96       char *newMsg{static_cast<char *>(AllocateMemoryOrCrash(
  97           terminator, std::strlen(msg) + std::strlen(err_buffer) + 1))};
  98       std::strcat(newMsg, err_buffer);
  99
 100       if (!cmdstat) {
 101         terminator.Crash(newMsg);
 102       } else {
 103         StoreIntToDescriptor(cmdstat, EXECL_ERR, terminator);
 104         CheckAndCopyCharsToDescriptor(cmdmsg, newMsg);
 105       }
 106       FreeMemory(newMsg);
 107     }
 108   }
 109
 110 #ifdef _WIN32
 111   // On WIN32 API std::system returns exit status directly
 112   std::int64_t exitStatusVal{status};
 113   if (exitStatusVal != 0) {
 114     if (!cmdstat) {
 115       terminator.Crash(
 116           "Invalid command quit with exit status code: %d", exitStatusVal);
 117     } else {
 118       StoreIntToDescriptor(cmdstat, INVALID_CL_ERR, terminator);
 119       CheckAndCopyCharsToDescriptor(cmdmsg, "Invalid command line");
 120     }
 121   }
 122 #else
 123   std::int64_t exitStatusVal{WEXITSTATUS(status)};
 124   if (exitStatusVal == 1) {
 125     if (!cmdstat) {
 126       terminator.Crash("Command line execution failed with exit code: 1.");
 127     } else {
 128       StoreIntToDescriptor(cmdstat, COMMAND_EXECUTION_ERR, terminator);
 129       CheckAndCopyCharsToDescriptor(
 130           cmdmsg, "Command line execution failed with exit code: 1.");
 131     }
 132   } else if (exitStatusVal == 126) {
 133     if (!cmdstat) {
 134       terminator.Crash("Command cannot be executed with exit code: 126.");
 135     } else {
 136       StoreIntToDescriptor(cmdstat, COMMAND_CANNOT_EXECUTE_ERR, terminator);
 137       CheckAndCopyCharsToDescriptor(
 138           cmdmsg, "Command cannot be executed with exit code: 126.");
 139     }
 140   } else if (exitStatusVal == 127) {
 141     if (!cmdstat) {
 142       terminator.Crash("Command not found with exit code: 127.");
 143     } else {
 144       StoreIntToDescriptor(cmdstat, COMMAND_NOT_FOUND_ERR, terminator);
 145       CheckAndCopyCharsToDescriptor(
 146           cmdmsg, "Command not found with exit code: 127.");
 147     }
 148     // capture all other nonzero exit code
 149   } else if (exitStatusVal != 0) {
 150     if (!cmdstat) {
 151       terminator.Crash(
 152           "Invalid command quit with exit status code: %d", exitStatusVal);
 153     } else {
 154       StoreIntToDescriptor(cmdstat, INVALID_CL_ERR, terminator);
 155       CheckAndCopyCharsToDescriptor(cmdmsg, "Invalid command line");
 156     }
 157   }
 158 #endif
 159
 160 #if defined(WIFSIGNALED) && defined(WTERMSIG)
 161   if (WIFSIGNALED(status)) {
 162     if (!cmdstat) {
 163       terminator.Crash("Killed by signal: %d", WTERMSIG(status));
 164     } else {
 165       StoreIntToDescriptor(cmdstat, SIGNAL_ERR, terminator);
 166       CheckAndCopyCharsToDescriptor(cmdmsg, "Killed by signal");
 167     }
 168   }
 169 #endif
 170
 171 #if defined(WIFSTOPPED) && defined(WSTOPSIG)
 172   if (WIFSTOPPED(status)) {
 173     if (!cmdstat) {
 174       terminator.Crash("Stopped by signal: %d", WSTOPSIG(status));
 175     } else {
 176       StoreIntToDescriptor(cmdstat, SIGNAL_ERR, terminator);
 177       CheckAndCopyCharsToDescriptor(cmdmsg, "Stopped by signal");
 178     }
 179   }
 180 #endif
 181   return exitStatusVal;
 182 }
 183
 184 void RTNAME(ExecuteCommandLine)(const Descriptor &command, bool wait,
 185     const Descriptor *exitstat, const Descriptor *cmdstat,
 186     const Descriptor *cmdmsg, const char *sourceFile, int line) {
 187   Terminator terminator{sourceFile, line};
 188   char *newCmd{EnsureNullTerminated(
 189       command.OffsetElement(), command.ElementBytes(), terminator)};
 190
 191   if (exitstat) {
 192     RUNTIME_CHECK(terminator, IsValidIntDescriptor(exitstat));
 193   }
 194
 195   if (cmdstat) {
 196     RUNTIME_CHECK(terminator, IsValidIntDescriptor(cmdstat));
 197     // Assigned 0 as specifed in standard, if error then overwrite
 198     StoreIntToDescriptor(cmdstat, CMD_EXECUTED, terminator);
 199   }
 200
 201   if (cmdmsg) {
 202     RUNTIME_CHECK(terminator, IsValidCharDescriptor(cmdmsg));
 203   }
 204
 205   if (wait) {
 206     // either wait is not specified or wait is true: synchronous mode
 207     std::int64_t status{std::system(newCmd)};
 208     std::int64_t exitStatusVal{
 209         TerminationCheck(status, cmdstat, cmdmsg, terminator)};
 210     // If sync, assigned processor-dependent exit status. Otherwise unchanged
 211     CheckAndStoreIntToDescriptor(exitstat, exitStatusVal, terminator);
 212   } else {
 213 // Asynchronous mode
 214 #ifdef _WIN32
 215     STARTUPINFO si;
 216     PROCESS_INFORMATION pi;
 217     ZeroMemory(&si, sizeof(si));
 218     si.cb = sizeof(si);
 219     ZeroMemory(&pi, sizeof(pi));
 220
 221     // add "cmd.exe /c " to the beginning of command
 222     const char *prefix{"cmd.exe /c "};
 223     char *newCmdWin{static_cast<char *>(AllocateMemoryOrCrash(
 224         terminator, std::strlen(prefix) + std::strlen(newCmd) + 1))};
 225     std::strcpy(newCmdWin, prefix);
 226     std::strcat(newCmdWin, newCmd);
 227
 228     // Convert the char to wide char
 229     const size_t sizeNeeded{mbstowcs(NULL, newCmdWin, 0) + 1};
 230     wchar_t *wcmd{static_cast<wchar_t *>(
 231         AllocateMemoryOrCrash(terminator, sizeNeeded * sizeof(wchar_t)))};
 232     if (std::mbstowcs(wcmd, newCmdWin, sizeNeeded) == static_cast<size_t>(-1)) {
 233       terminator.Crash("Char to wide char failed for newCmd");
 234     }
 235     FreeMemory(newCmdWin);
 236
 237     if (CreateProcess(nullptr, wcmd, nullptr, nullptr, FALSE, 0, nullptr,
 238             nullptr, &si, &pi)) {
 239       // Close handles so it will be removed when terminated
 240       CloseHandle(pi.hProcess);
 241       CloseHandle(pi.hThread);
 242     } else {
 243       if (!cmdstat) {
 244         terminator.Crash(
 245             "CreateProcess failed with error code: %lu.", GetLastError());
 246       } else {
 247         StoreIntToDescriptor(cmdstat, ASYNC_NO_SUPPORT_ERR, terminator);
 248         CheckAndCopyCharsToDescriptor(cmdmsg, "CreateProcess failed.");
 249       }
 250     }
 251     FreeMemory(wcmd);
 252 #else
 253     pid_t pid{fork()};
 254     if (pid < 0) {
 255       if (!cmdstat) {
 256         terminator.Crash("Fork failed with pid: %d.", pid);
 257       } else {
 258         StoreIntToDescriptor(cmdstat, FORK_ERR, terminator);
 259         CheckAndCopyCharsToDescriptor(cmdmsg, "Fork failed");
 260       }
 261     } else if (pid == 0) {
 262       // Create a new session, let init process take care of zombie child
 263       if (setsid() == -1) {
 264         if (!cmdstat) {
 265           terminator.Crash("setsid() failed with errno: %d, asynchronous "
 266                            "process initiation failed.",
 267               errno);
 268         } else {
 269           StoreIntToDescriptor(cmdstat, ASYNC_NO_SUPPORT_ERR, terminator);
 270           CheckAndCopyCharsToDescriptor(cmdmsg,
 271               "setsid() failed, asynchronous process initiation failed.");
 272         }
 273         exit(EXIT_FAILURE);
 274       }
 275       std::int64_t status{std::system(newCmd)};
 276       TerminationCheck(status, cmdstat, cmdmsg, terminator);
 277       exit(status);
 278     }
 279 #endif
 280   }
 281   // Deallocate memory if EnsureNullTerminated dynamically allocated memory
 282   if (newCmd != command.OffsetElement()) {
 283     FreeMemory(newCmd);
 284   }
 285 }
 286
 287 } // namespace Fortran::runtime