react-native-windows 0.84.0 → 0.84.2

package/external/folly/folly/portability/SysMman.cpp

@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/portability/SysMman.h>
+
+#ifdef _WIN32
+
+#include <cassert>
+
+#include <folly/Portability.h>
+#include <folly/portability/Windows.h>
+
+static bool mmap_to_page_protection(int prot, DWORD& ret, DWORD& acc) {
+  if (prot == PROT_NONE) {
+    ret = PAGE_NOACCESS;
+    acc = 0;
+  } else if (prot == PROT_READ) {
+    ret = PAGE_READONLY;
+    acc = FILE_MAP_READ;
+  } else if (prot == PROT_EXEC) {
+    ret = PAGE_EXECUTE;
+    acc = FILE_MAP_EXECUTE;
+  } else if (prot == (PROT_READ | PROT_EXEC)) {
+    ret = PAGE_EXECUTE_READ;
+    acc = FILE_MAP_READ | FILE_MAP_EXECUTE;
+  } else if (prot == (PROT_READ | PROT_WRITE)) {
+    ret = PAGE_READWRITE;
+    acc = FILE_MAP_READ | FILE_MAP_WRITE;
+  } else if (prot == (PROT_READ | PROT_WRITE | PROT_EXEC)) {
+    ret = PAGE_EXECUTE_READWRITE;
+    acc = FILE_MAP_READ | FILE_MAP_WRITE | FILE_MAP_EXECUTE;
+  } else {
+    return false;
+  }
+  return true;
+}
+
+static size_t alignToAllocationGranularity(size_t s) {
+  static size_t granularity = [] {
+    static SYSTEM_INFO inf;
+    GetSystemInfo(&inf);
+    return inf.dwAllocationGranularity;
+  }();
+  return (s + granularity - 1) / granularity * granularity;
+}
+
+extern "C" {
+int madvise(const void* /* addr */, size_t /* len */, int /* advise */) {
+  // We do nothing at all.
+  // Could probably implement dontneed via VirtualAlloc
+  // with the MEM_RESET and MEM_RESET_UNDO flags.
+  return 0;
+}
+
+int mlock(const void* addr, size_t len) {
+  // For some strange reason, it's allowed to
+  // lock a nullptr as long as length is zero.
+  // VirtualLock doesn't allow it, so handle
+  // it specially.
+  if (addr == nullptr && len == 0) {
+    return 0;
+  }
+  if (!VirtualLock((void*)addr, len)) {
+    return -1;
+  }
+  return 0;
+}
+
+namespace {
+constexpr uint32_t kMMapLengthMagic = 0xFACEB00C;
+struct MemMapDebugTrailer {
+  size_t length;
+  uint32_t magic;
+};
+
+void* mmapWinArgs(
+    void* addr,
+    size_t length,
+    int prot,
+    int flags,
+    int fd,
+    DWORD offHigh,
+    DWORD offLow) {
+  // Make sure it's something we support first.
+
+  // No Anon shared.
+  if ((flags & (MAP_ANONYMOUS | MAP_SHARED)) == (MAP_ANONYMOUS | MAP_SHARED)) {
+    return MAP_FAILED;
+  }
+  // No private copy on write.
+  // If the map isn't writable, we can let it go through as
+  // whether changes to the underlying file are reflected in the map
+  // is defined to be unspecified by the standard.
+  if ((flags & MAP_PRIVATE) == MAP_PRIVATE &&
+      (prot & PROT_WRITE) == PROT_WRITE && fd != -1) {
+    return MAP_FAILED;
+  }
+  // Map isn't anon, must be file backed.
+  if (!(flags & MAP_ANONYMOUS) && fd == -1) {
+    return MAP_FAILED;
+  }
+
+  DWORD newProt;
+  DWORD accessFlags;
+  if (!mmap_to_page_protection(prot, newProt, accessFlags)) {
+    return MAP_FAILED;
+  }
+
+  void* ret;
+  if (!(flags & MAP_ANONYMOUS) || (flags & MAP_SHARED)) {
+    HANDLE h = INVALID_HANDLE_VALUE;
+    if (!(flags & MAP_ANONYMOUS)) {
+      h = (HANDLE)_get_osfhandle(fd);
+    }
+
+    HANDLE fmh = CreateFileMapping(
+        h,
+        nullptr,
+        newProt,
+        (DWORD)((length >> 32) & 0xFFFFFFFF),
+        (DWORD)(length & 0xFFFFFFFF),
+        nullptr);
+    if (fmh == nullptr) {
+      return MAP_FAILED;
+    }
+    ret = MapViewOfFileEx(fmh, accessFlags, offHigh, offLow, 0, addr);
+    if (ret == nullptr) {
+      ret = MAP_FAILED;
+    }
+    CloseHandle(fmh);
+  } else {
+    auto baseLength = length;
+    if (folly::kIsDebug) {
+      // In debug mode we keep track of the length to make
+      // sure you're only munmapping the entire thing if
+      // we're using VirtualAlloc.
+      length += sizeof(MemMapDebugTrailer);
+    }
+
+    // VirtualAlloc rounds size down to a multiple
+    // of the system allocation granularity :(
+    length = alignToAllocationGranularity(length);
+    ret = VirtualAlloc(addr, length, MEM_COMMIT | MEM_RESERVE, newProt);
+    if (ret == nullptr) {
+      return MAP_FAILED;
+    }
+
+    if (folly::kIsDebug) {
+      auto deb = (MemMapDebugTrailer*)((char*)ret + baseLength);
+      deb->length = baseLength;
+      deb->magic = kMMapLengthMagic;
+    }
+  }
+
+  // TODO: Could technically implement MAP_POPULATE via PrefetchVirtualMemory
+  //       Should also see about implementing MAP_NORESERVE
+  return ret;
+}
+} // namespace
+
+void* mmap(void* addr, size_t length, int prot, int flags, int fd, off_t off) {
+  // offHigh is zero because off_t is only 32-bit on windows
+  return mmapWinArgs(
+      addr, length, prot, flags, fd, (DWORD)(0), (DWORD)(off & 0xFFFFFFFF));
+}
+
+void* mmap64(
+    void* addr, size_t length, int prot, int flags, int fd, off64_t off) {
+  return mmapWinArgs(
+      addr,
+      length,
+      prot,
+      flags,
+      fd,
+      (DWORD)(off >> 32) & 0xFFFFFFFF,
+      (DWORD)(off & 0xFFFFFFFF));
+}
+
+int mprotect(void* addr, size_t size, int prot) {
+  DWORD newProt;
+  DWORD access;
+  if (!mmap_to_page_protection(prot, newProt, access)) {
+    return -1;
+  }
+
+  DWORD oldProt;
+  BOOL res = VirtualProtect(addr, size, newProt, &oldProt);
+  if (!res) {
+    return -1;
+  }
+  return 0;
+}
+
+int munlock(const void* addr, size_t length) {
+  // See comment in mlock
+  if (addr == nullptr && length == 0) {
+    return 0;
+  }
+  if (!VirtualUnlock((void*)addr, length)) {
+    return -1;
+  }
+  return 0;
+}
+
+int munmap(void* addr, size_t length) {
+  // Try to unmap it as a file, otherwise VirtualFree.
+  if (!UnmapViewOfFile(addr)) {
+    if (folly::kIsDebug) {
+      // We can't do partial unmapping with Windows, so
+      // assert that we aren't trying to do that if we're
+      // in debug mode.
+      MEMORY_BASIC_INFORMATION inf;
+      VirtualQuery(addr, &inf, sizeof(inf));
+      assert(inf.AllocationBase == addr);
+
+      auto deb = (MemMapDebugTrailer*)((char*)addr + length);
+      assert(deb->length == length);
+      assert(deb->magic == kMMapLengthMagic);
+    }
+    if (!VirtualFree(addr, 0, MEM_RELEASE)) {
+      return -1;
+    }
+    return 0;
+  }
+  return 0;
+}
+}
+
+#endif

package/external/folly/folly/portability/SysMman.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#ifndef _WIN32
+
+#include <sys/mman.h>
+
+// MAP_ANONYMOUS is named MAP_ANON on OSX/BSD.
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+#endif
+
+#else
+
+#include <cstdint>
+
+#include <sys/types.h>
+
+using off64_t = int64_t;
+
+#define MAP_ANONYMOUS 1
+#define MAP_ANON MAP_ANONYMOUS
+#define MAP_SHARED 2
+#define MAP_PRIVATE 4
+#define MAP_POPULATE 8
+#define MAP_NORESERVE 16
+#define MAP_FIXED 32
+
+#define MAP_FAILED ((void*)-1)
+
+#define PROT_NONE 0
+#define PROT_READ 1
+#define PROT_WRITE 2
+#define PROT_EXEC 4
+
+#define MADV_NORMAL 0
+#define MADV_DONTNEED 0
+#define MADV_SEQUENTIAL 0
+
+extern "C" {
+int madvise(const void* addr, size_t len, int advise);
+int mlock(const void* addr, size_t len);
+void* mmap(void* addr, size_t length, int prot, int flags, int fd, off_t off);
+void* mmap64(
+    void* addr, size_t length, int prot, int flags, int fd, off64_t off);
+int mprotect(void* addr, size_t size, int prot);
+int munlock(const void* addr, size_t length);
+int munmap(void* addr, size_t length);
+}
+
+#endif

package/external/folly/folly/portability/SysResource.cpp

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/portability/SysResource.h>
+
+#include <cerrno>
+#include <cstring>
+
+#ifdef _WIN32
+#include <folly/portability/Windows.h>
+
+extern "C" {
+int getrlimit(int type, rlimit* dst) {
+  if (type == RLIMIT_STACK) {
+    NT_TIB* tib = (NT_TIB*)NtCurrentTeb();
+    dst->rlim_cur = (size_t)tib->StackBase - (size_t)tib->StackLimit;
+    dst->rlim_max = dst->rlim_cur;
+    return 0;
+  }
+  return -1;
+}
+
+int getrusage(int /* who */, rusage* usage) {
+  // You get NOTHING! Good day to you sir.
+  ZeroMemory(usage, sizeof(rusage));
+  return 0;
+}
+
+int setrlimit(int /* type */, rlimit* /* src */) {
+  // Do nothing for setting them for now.
+  // We couldn't set the stack size at runtime even if we wanted to.
+  return 0;
+}
+
+int getpriority(int which, int who) {
+  if (which != PRIO_PROCESS || who != 0) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  auto ret = GetPriorityClass(GetCurrentProcess());
+  switch (ret) {
+    case 0:
+      errno = EACCES;
+      return -1;
+    case IDLE_PRIORITY_CLASS:
+      return 39;
+    case BELOW_NORMAL_PRIORITY_CLASS:
+      return 30;
+    case NORMAL_PRIORITY_CLASS:
+      return 20;
+    case ABOVE_NORMAL_PRIORITY_CLASS:
+      return 10;
+    case HIGH_PRIORITY_CLASS:
+      return 0;
+    case REALTIME_PRIORITY_CLASS:
+      // I'd return -1 if it weren't an error :(
+      // Realtime priority processes can't be set
+      // through these APIs because it's a terrible idea.
+      return 0;
+    default:
+      errno = EINVAL;
+      return -1;
+  }
+}
+
+int setpriority(int which, int who, int value) {
+  if (which != PRIO_PROCESS || who != 0) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  auto newClass = [value] {
+    if (value >= 39) {
+      return IDLE_PRIORITY_CLASS;
+    } else if (value >= 30) {
+      return BELOW_NORMAL_PRIORITY_CLASS;
+    } else if (value >= 20) {
+      return NORMAL_PRIORITY_CLASS;
+    } else if (value >= 10) {
+      return ABOVE_NORMAL_PRIORITY_CLASS;
+    } else {
+      return HIGH_PRIORITY_CLASS;
+    }
+  }();
+
+  if (!SetPriorityClass(GetCurrentProcess(), newClass)) {
+    errno = EACCES;
+    return -1;
+  }
+  return 0;
+}
+}
+
+#endif

package/external/folly/folly/portability/SysResource.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#if !defined(_WIN32)
+#include <sys/resource.h>
+#else
+#include <cstdint>
+
+#include <folly/portability/SysTime.h>
+
+#define PRIO_PROCESS 1
+
+#define RLIMIT_CORE 0
+#define RLIMIT_NOFILE 0
+#define RLIMIT_DATA 0
+#define RLIMIT_STACK 3
+#define RLIM_INFINITY SIZE_MAX
+
+#define RUSAGE_SELF 0
+#define RUSAGE_CHILDREN 0
+#define RUSAGE_THREAD 0
+
+using rlim_t = size_t;
+struct rlimit {
+  rlim_t rlim_cur;
+  rlim_t rlim_max;
+};
+
+struct rusage {
+  timeval ru_utime;
+  timeval ru_stime;
+  long ru_maxrss;
+  long ru_ixrss;
+  long ru_idrss;
+  long ru_isrss;
+  long ru_minflt;
+  long ru_majflt;
+  long ru_nswap;
+  long ru_inblock;
+  long ru_oublock;
+  long ru_msgsnd;
+  long ru_msgrcv;
+  long ru_nsignals;
+  long ru_nvcsw;
+  long ru_nivcsw;
+};
+
+extern "C" {
+int getrlimit(int type, rlimit* dst);
+int getrusage(int who, rusage* usage);
+int setrlimit(int type, rlimit* src);
+
+int getpriority(int which, int who);
+int setpriority(int which, int who, int value);
+}
+#endif

package/external/folly/folly/portability/SysStat.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/portability/SysStat.h>
+
+#ifdef _WIN32
+#include <folly/portability/Windows.h>
+
+extern "C" {
+int chmod(char const* fn, int am) {
+  return _chmod(fn, am);
+}
+
+int fchmod(int fd, mode_t mode) {
+  HANDLE h = (HANDLE)_get_osfhandle(fd);
+  if (h == INVALID_HANDLE_VALUE) {
+    return -1;
+  }
+
+  FILE_ATTRIBUTE_TAG_INFO attr{};
+  if (!GetFileInformationByHandleEx(
+          h, FileAttributeTagInfo, &attr, sizeof(attr))) {
+    return -1;
+  }
+
+  if (mode & _S_IWRITE) {
+    attr.FileAttributes &= ~FILE_ATTRIBUTE_READONLY;
+  } else {
+    attr.FileAttributes |= FILE_ATTRIBUTE_READONLY;
+  }
+
+  if (!SetFileInformationByHandle(
+          h, FileAttributeTagInfo, &attr, sizeof(attr))) {
+    return -1;
+  }
+
+  return 0;
+}
+
+// Just return the result of a normal stat for now
+int lstat(const char* path, struct stat* st) {
+  return stat(path, st);
+}
+
+int mkdir(const char* fn, int /* mode */) {
+  return _mkdir(fn);
+}
+
+int umask(int md) {
+  return _umask(md);
+}
+}
+#endif

package/external/folly/folly/portability/SysStat.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <sys/stat.h>
+
+#ifdef _WIN32
+#include <folly/portability/SysTypes.h>
+
+// Windows gives weird names to these.
+#define S_IXUSR 0
+#define S_IWUSR _S_IWRITE
+#define S_IRUSR _S_IREAD
+// No group/other permissions so default to user.
+#define S_IXGRP S_IXUSR
+#define S_IWGRP S_IWUSR
+#define S_IRGRP S_IRUSR
+#define S_IXOTH S_IXUSR
+#define S_IWOTH S_IWUSR
+#define S_IROTH S_IRUSR
+#define S_IRWXU (S_IRUSR | S_IWUSR | S_IXUSR)
+#define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
+#define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH)
+
+#define S_ISDIR(mode) (((mode) & (_S_IFDIR)) == (_S_IFDIR) ? 1 : 0)
+#define S_ISREG(mode) (((mode) & (_S_IFREG)) == (_S_IFREG) ? 1 : 0)
+
+// This isn't defined anywhere, so give a sane value.
+#define MAXSYMLINKS 255
+
+extern "C" {
+int chmod(char const* fn, int am);
+int fchmod(int fd, mode_t mode);
+int lstat(const char* path, struct stat* st);
+int mkdir(const char* fn, int mode);
+int umask(int md);
+}
+#endif

package/external/folly/folly/portability/SysSyscall.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cerrno>
+
+#include <folly/CPortability.h>
+#include <folly/Portability.h>
+
+#if !defined(_WIN32)
+
+#include <unistd.h>
+
+#include <sys/syscall.h>
+
+#if defined(__APPLE__)
+#define FOLLY_SYS_gettid SYS_thread_selfid
+#elif defined(SYS_gettid)
+#define FOLLY_SYS_gettid SYS_gettid
+#else
+#define FOLLY_SYS_gettid __NR_gettid
+#endif
+
+#endif
+
+namespace folly {
+namespace detail {
+
+//  linux_syscall
+//
+//  Follows the interface of syscall(2), as described for linux. Other platforms
+//  offer compatible interfaces. Defined for all platforms, whereas syscall(2)
+//  is only defined on some platforms and is only exported by unistd.h on those
+//  platforms which have unistd.h.
+//
+//  Note: This uses C++ variadic args while syscall(2) uses C variadic args,
+//  which have different signatures and which use different calling conventions.
+//
+//  Note: Some syscall numbers are specified by POSIX but some are specific to
+//  each platform and vary by operating system and architecture. Caution is
+//  required.
+//
+//  mimic: syscall(2), linux
+template <typename... A>
+FOLLY_ERASE long linux_syscall(long number, A... a) {
+#if defined(_WIN32) || (defined(__EMSCRIPTEN__) && !defined(syscall))
+  errno = ENOSYS;
+  return -1;
+#else
+  // syscall is deprecated under iOS >= 10.0
+  FOLLY_PUSH_WARNING
+  FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations")
+  return syscall(number, a...);
+  FOLLY_POP_WARNING
+#endif
+}
+
+} // namespace detail
+} // namespace folly