tor-browser

system_utils_posix.cpp (11683B)

---

//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// system_utils_posix.cpp: Implementation of POSIX OS-specific functions.

#include "common/debug.h"
#include "system_utils.h"

#include <array>
#include <iostream>

#include <dlfcn.h>
#include <grp.h>
#include <inttypes.h>
#include <pwd.h>
#include <signal.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#include "common/string_utils.h"

#ifdef ANGLE_PLATFORM_FUCHSIA
#    include <zircon/process.h>
#    include <zircon/syscalls.h>
#else
#    include <sys/resource.h>
#endif

namespace angle
{

namespace
{
std::string GetModulePath(void *moduleOrSymbol)
{
   Dl_info dlInfo;
   if (dladdr(moduleOrSymbol, &dlInfo) == 0)
   {
       return "";
   }

   return dlInfo.dli_fname;
}

void *OpenPosixLibrary(const std::string &fullPath, int extraFlags, std::string *errorOut)
{
   void *module = dlopen(fullPath.c_str(), RTLD_NOW | extraFlags);
   if (module)
   {
       if (errorOut)
       {
           *errorOut = fullPath;
       }
   }
   else if (errorOut)
   {
       *errorOut = "dlopen(";
       *errorOut += fullPath;
       *errorOut += ") failed with error: ";
       *errorOut += dlerror();
       struct stat sfile;
       if (-1 == stat(fullPath.c_str(), &sfile))
       {
           *errorOut += ", stat() call failed.";
       }
       else
       {
           *errorOut += ", stat() info: ";
           struct passwd *pwuser = getpwuid(sfile.st_uid);
           if (pwuser)
           {
               *errorOut += "owner: ";
               *errorOut += pwuser->pw_name;
               *errorOut += ", ";
           }
           struct group *grpnam = getgrgid(sfile.st_gid);
           if (grpnam)
           {
               *errorOut += "group: ";
               *errorOut += grpnam->gr_name;
               *errorOut += ", ";
           }
           *errorOut += "perms: ";
           *errorOut += std::to_string(sfile.st_mode);
           *errorOut += ", links: ";
           *errorOut += std::to_string(sfile.st_nlink);
           *errorOut += ", size: ";
           *errorOut += std::to_string(sfile.st_size);
       }
   }
   return module;
}
}  // namespace

Optional<std::string> GetCWD()
{
   std::array<char, 4096> pathBuf;
   char *result = getcwd(pathBuf.data(), pathBuf.size());
   if (result == nullptr)
   {
       return Optional<std::string>::Invalid();
   }
   return std::string(pathBuf.data());
}

bool SetCWD(const char *dirName)
{
   return (chdir(dirName) == 0);
}

bool UnsetEnvironmentVar(const char *variableName)
{
   return (unsetenv(variableName) == 0);
}

bool SetEnvironmentVar(const char *variableName, const char *value)
{
   return (setenv(variableName, value, 1) == 0);
}

std::string GetEnvironmentVar(const char *variableName)
{
   const char *value = getenv(variableName);
   return (value == nullptr ? std::string() : std::string(value));
}

const char *GetPathSeparatorForEnvironmentVar()
{
   return ":";
}

std::string GetModuleDirectoryAndGetError(std::string *errorOut)
{
   std::string directory;
   static int placeholderSymbol = 0;
   std::string moduleName       = GetModulePath(&placeholderSymbol);
   if (!moduleName.empty())
   {
       directory = moduleName.substr(0, moduleName.find_last_of('/') + 1);
   }

   // Ensure we return the full path to the module, not the relative path
   if (!IsFullPath(directory))
   {
       if (errorOut)
       {
           *errorOut += "Directory: '";
           *errorOut += directory;
           *errorOut += "' is not full path";
       }
       Optional<std::string> cwd = GetCWD();
       if (cwd.valid())
       {
           directory = ConcatenatePath(cwd.value(), directory);
           if (errorOut)
           {
               *errorOut += ", so it has been modified to: '";
               *errorOut += directory;
               *errorOut += "'. ";
           }
       }
       else if (errorOut)
       {
           *errorOut += " and getcwd was invalid. ";
       }
   }
   return directory;
}

std::string GetModuleDirectory()
{
   return GetModuleDirectoryAndGetError(nullptr);
}

void *OpenSystemLibraryWithExtensionAndGetError(const char *libraryName,
                                               SearchType searchType,
                                               std::string *errorOut)
{
   std::string directory;
   if (searchType == SearchType::ModuleDir)
   {
#if ANGLE_PLATFORM_IOS
       // On iOS, shared libraries must be loaded from within the app bundle.
       directory = GetExecutableDirectory() + "/Frameworks/";
#elif ANGLE_PLATFORM_FUCHSIA
       // On Fuchsia the dynamic loader always looks up libraries in /pkg/lib
       // and disallows loading of libraries via absolute paths.
       directory = "";
#else
       directory = GetModuleDirectoryAndGetError(errorOut);
#endif
   }

   int extraFlags = 0;
   if (searchType == SearchType::AlreadyLoaded)
   {
       extraFlags = RTLD_NOLOAD;
   }

   std::string fullPath = directory + libraryName;
   return OpenPosixLibrary(fullPath, extraFlags, errorOut);
}

void *GetLibrarySymbol(void *libraryHandle, const char *symbolName)
{
   if (!libraryHandle)
   {
       return nullptr;
   }

   return dlsym(libraryHandle, symbolName);
}

std::string GetLibraryPath(void *libraryHandle)
{
   if (!libraryHandle)
   {
       return "";
   }

   return GetModulePath(libraryHandle);
}

void CloseSystemLibrary(void *libraryHandle)
{
   if (libraryHandle)
   {
       dlclose(libraryHandle);
   }
}

bool IsDirectory(const char *filename)
{
   struct stat st;
   int result = stat(filename, &st);
   return result == 0 && ((st.st_mode & S_IFDIR) == S_IFDIR);
}

bool IsDebuggerAttached()
{
   // This could have a fuller implementation.
   // See https://cs.chromium.org/chromium/src/base/debug/debugger_posix.cc
   return false;
}

void BreakDebugger()
{
   // This could have a fuller implementation.
   // See https://cs.chromium.org/chromium/src/base/debug/debugger_posix.cc
   abort();
}

const char *GetExecutableExtension()
{
   return "";
}

char GetPathSeparator()
{
   return '/';
}

std::string GetRootDirectory()
{
   return "/";
}

Optional<std::string> GetTempDirectory()
{
   const char *tmp = getenv("TMPDIR");
   if (tmp != nullptr)
   {
       return std::string(tmp);
   }

#if defined(ANGLE_PLATFORM_ANDROID)
   // Not used right now in the ANGLE test runner.
   // return PathService::Get(DIR_CACHE, path);
   return Optional<std::string>::Invalid();
#else
   return std::string("/tmp");
#endif
}

Optional<std::string> CreateTemporaryFileInDirectory(const std::string &directory)
{
   std::string tempFileTemplate = directory + "/.angle.XXXXXX";

   char tempFile[1000];
   strcpy(tempFile, tempFileTemplate.c_str());

   int fd = mkstemp(tempFile);
   close(fd);

   if (fd != -1)
   {
       return std::string(tempFile);
   }

   return Optional<std::string>::Invalid();
}

double GetCurrentProcessCpuTime()
{
#ifdef ANGLE_PLATFORM_FUCHSIA
   static zx_handle_t me = zx_process_self();
   zx_info_task_runtime_t task_runtime;
   zx_object_get_info(me, ZX_INFO_TASK_RUNTIME, &task_runtime, sizeof(task_runtime), nullptr,
                      nullptr);
   return static_cast<double>(task_runtime.cpu_time) * 1e-9;
#else
   // We could also have used /proc/stat, but that requires us to read the
   // filesystem and convert from jiffies. /proc/stat also relies on jiffies
   // (lower resolution) while getrusage can potentially use a sched_clock()
   // underneath that has higher resolution.
   struct rusage usage;
   getrusage(RUSAGE_SELF, &usage);
   double userTime = usage.ru_utime.tv_sec + usage.ru_utime.tv_usec * 1e-6;
   double systemTime = usage.ru_stime.tv_sec + usage.ru_stime.tv_usec * 1e-6;
   return userTime + systemTime;
#endif
}

namespace
{
bool SetMemoryProtection(uintptr_t start, size_t size, int protections)
{
   int ret = mprotect(reinterpret_cast<void *>(start), size, protections);
   if (ret < 0)
   {
       perror("mprotect failed");
   }
   return ret == 0;
}

class PosixPageFaultHandler : public PageFaultHandler
{
 public:
   PosixPageFaultHandler(PageFaultCallback callback) : PageFaultHandler(callback) {}
   ~PosixPageFaultHandler() override {}

   bool enable() override;
   bool disable() override;
   void handle(int sig, siginfo_t *info, void *unused);

 private:
   struct sigaction mDefaultBusAction  = {};
   struct sigaction mDefaultSegvAction = {};
};

PosixPageFaultHandler *gPosixPageFaultHandler = nullptr;
void SegfaultHandlerFunction(int sig, siginfo_t *info, void *unused)
{
   gPosixPageFaultHandler->handle(sig, info, unused);
}

void PosixPageFaultHandler::handle(int sig, siginfo_t *info, void *unused)
{
   bool found = false;
   if ((sig == SIGSEGV || sig == SIGBUS) &&
       (info->si_code == SEGV_ACCERR || info->si_code == SEGV_MAPERR))
   {
       found = mCallback(reinterpret_cast<uintptr_t>(info->si_addr)) ==
               PageFaultHandlerRangeType::InRange;
   }

   // Fall back to default signal handler
   if (!found)
   {
       if (sig == SIGSEGV)
       {
           mDefaultSegvAction.sa_sigaction(sig, info, unused);
       }
       else if (sig == SIGBUS)
       {
           mDefaultBusAction.sa_sigaction(sig, info, unused);
       }
       else
       {
           UNREACHABLE();
       }
   }
}

bool PosixPageFaultHandler::disable()
{
   return sigaction(SIGSEGV, &mDefaultSegvAction, nullptr) == 0 &&
          sigaction(SIGBUS, &mDefaultBusAction, nullptr) == 0;
}

bool PosixPageFaultHandler::enable()
{
   struct sigaction sigAction = {};
   sigAction.sa_flags         = SA_SIGINFO;
   sigAction.sa_sigaction     = &SegfaultHandlerFunction;
   sigemptyset(&sigAction.sa_mask);

   // Some POSIX implementations use SIGBUS for mprotect faults
   return sigaction(SIGSEGV, &sigAction, &mDefaultSegvAction) == 0 &&
          sigaction(SIGBUS, &sigAction, &mDefaultBusAction) == 0;
}
}  // namespace

// Set write protection
bool ProtectMemory(uintptr_t start, size_t size)
{
   return SetMemoryProtection(start, size, PROT_READ);
}

// Allow reading and writing
bool UnprotectMemory(uintptr_t start, size_t size)
{
   return SetMemoryProtection(start, size, PROT_READ | PROT_WRITE);
}

size_t GetPageSize()
{
   long pageSize = sysconf(_SC_PAGE_SIZE);
   if (pageSize < 0)
   {
       perror("Could not get sysconf page size");
       return 0;
   }
   return static_cast<size_t>(pageSize);
}

PageFaultHandler *CreatePageFaultHandler(PageFaultCallback callback)
{
   gPosixPageFaultHandler = new PosixPageFaultHandler(callback);
   return gPosixPageFaultHandler;
}

uint64_t GetProcessMemoryUsageKB()
{
   FILE *file = fopen("/proc/self/status", "r");

   if (!file)
   {
       return 0;
   }

   const char *kSearchString           = "VmRSS:";
   constexpr size_t kMaxLineSize       = 100;
   std::array<char, kMaxLineSize> line = {};

   uint64_t kb = 0;

   while (fgets(line.data(), line.size(), file) != nullptr)
   {
       if (strncmp(line.data(), kSearchString, strlen(kSearchString)) == 0)
       {
           std::vector<std::string> strings;
           SplitStringAlongWhitespace(line.data(), &strings);

           sscanf(strings[1].c_str(), "%" SCNu64, &kb);
           break;
       }
   }
   fclose(file);

   return kb;
}
}  // namespace angle