react-native-windows 0.84.0 → 0.84.2

package/external/folly/folly/system/MemoryMapping.h

@@ -0,0 +1,287 @@
+/*
+ * 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 <cassert>
+
+#include <folly/File.h>
+#include <folly/Range.h>
+#include <folly/portability/Unistd.h>
+
+namespace folly {
+
+/**
+ * Maps files in memory (read-only).
+ */
+class MemoryMapping {
+ public:
+  /**
+   * Lock the pages in memory?
+   * TRY_LOCK  = try to lock, log warning if permission denied
+   * MUST_LOCK = lock, fail assertion if permission denied.
+   */
+  enum class LockMode {
+    TRY_LOCK,
+    MUST_LOCK,
+  };
+
+  struct LockFlags {
+    LockFlags() {}
+
+    bool operator==(const LockFlags& other) const;
+
+    /**
+     * Instead of locking all the pages in the mapping before the call returns,
+     * only lock those that are currently resident and mark the others to be
+     * locked at the time they're populated by their first page fault.
+     *
+     * Uses mlock2(flags=MLOCK_ONFAULT). Requires Linux >= 4.4.
+     */
+    bool lockOnFault = false;
+  };
+
+  /**
+   * Map a portion of the file indicated by filename in memory, causing SIGABRT
+   * on error.
+   *
+   * By default, map the whole file.  length=-1: map from offset to EOF.
+   * Unlike the mmap() system call, offset and length don't need to be
+   * page-aligned.  length is clipped to the end of the file if it's too large.
+   *
+   * The mapping will be destroyed (and the memory pointed-to by data() will
+   * likely become inaccessible) when the MemoryMapping object is destroyed.
+   */
+  struct Options {
+    Options() {}
+
+    // Convenience methods; return *this for chaining.
+    Options& setPageSize(off_t v) {
+      pageSize = v;
+      return *this;
+    }
+    Options& setShared(bool v) {
+      shared = v;
+      return *this;
+    }
+    Options& setPrefault(bool v) {
+      prefault = v;
+      return *this;
+    }
+    Options& setReadable(bool v) {
+      readable = v;
+      return *this;
+    }
+    Options& setWritable(bool v) {
+      writable = v;
+      return *this;
+    }
+    Options& setGrow(bool v) {
+      grow = v;
+      return *this;
+    }
+
+    // Page size. 0 = use appropriate page size.
+    // (On Linux, we use a huge page size if the file is on a hugetlbfs
+    // file system, and the default page size otherwise)
+    off64_t pageSize = 0;
+
+    // If shared (default), the memory mapping is shared with other processes
+    // mapping the same file (or children); if not shared (private), each
+    // process has its own mapping. Changes in writable, private mappings are
+    // not reflected to the underlying file. See the discussion of
+    // MAP_PRIVATE vs MAP_SHARED in the mmap(2) manual page.
+    bool shared = true;
+
+    // Populate page tables; subsequent accesses should not be blocked
+    // by page faults. This is a hint, as it may not be supported.
+    bool prefault = false;
+
+    // Map the pages readable. Note that mapping pages without read permissions
+    // is not universally supported (not supported on hugetlbfs on Linux, for
+    // example)
+    bool readable = true;
+
+    // Map the pages writable.
+    bool writable = false;
+
+    // When mapping a file in writable mode, grow the file to the requested
+    // length (using ftruncate()) before mapping; if false, truncate the
+    // mapping to the actual file size instead.
+    bool grow = false;
+
+    // Fix map at this address, if not nullptr. Must be aligned to a multiple
+    // of the appropriate page size.
+    void* address = nullptr;
+  };
+
+  // Options to emulate the old WritableMemoryMapping: readable and writable,
+  // allow growing the file if mapping past EOF.
+  static Options writable() {
+    return Options().setWritable(true).setGrow(true);
+  }
+
+  enum AnonymousType {
+    kAnonymous,
+  };
+
+  /**
+   * Create an anonymous mapping.
+   */
+  MemoryMapping(AnonymousType, off64_t length, Options options = Options());
+
+  explicit MemoryMapping(
+      File file,
+      off64_t offset = 0,
+      off64_t length = -1,
+      Options options = Options());
+
+  explicit MemoryMapping(
+      const char* name,
+      off64_t offset = 0,
+      off64_t length = -1,
+      Options options = Options());
+
+  explicit MemoryMapping(
+      int fd,
+      off64_t offset = 0,
+      off64_t length = -1,
+      Options options = Options());
+
+  MemoryMapping(const MemoryMapping&) = delete;
+  MemoryMapping(MemoryMapping&&) noexcept;
+
+  ~MemoryMapping();
+
+  MemoryMapping& operator=(const MemoryMapping&) = delete;
+  MemoryMapping& operator=(MemoryMapping&&);
+
+  void swap(MemoryMapping& other) noexcept;
+
+  /**
+   * Lock the pages in memory
+   */
+  bool mlock(LockMode mode, LockFlags flags = {});
+
+  /**
+   * Unlock the pages.
+   * If dontneed is true, the kernel is instructed to release these pages
+   * (per madvise(MADV_DONTNEED)).
+   */
+  void munlock(bool dontneed = false);
+
+  /**
+   * Hint that these pages will be scanned linearly.
+   * madvise(MADV_SEQUENTIAL)
+   */
+  void hintLinearScan();
+
+  /**
+   * Advise the kernel about memory access.
+   */
+  void advise(int advice) const;
+  void advise(int advice, size_t offset, size_t length) const;
+
+  /**
+   * A bitwise cast of the mapped bytes as range of values. Only intended for
+   * use with POD or in-place usable types.
+   */
+  template <class T>
+  Range<const T*> asRange() const {
+    size_t count = data_.size() / sizeof(T);
+    return Range<const T*>(
+        static_cast<const T*>(static_cast<const void*>(data_.data())), count);
+  }
+
+  /**
+   * A range of bytes mapped by this mapping.
+   */
+  ByteRange range() const { return data_; }
+
+  /**
+   * A bitwise cast of the mapped bytes as range of mutable values. Only
+   * intended for use with POD or in-place usable types.
+   */
+  template <class T>
+  Range<T*> asWritableRange() const {
+    assert(options_.writable); // you'll segfault anyway...
+    size_t count = data_.size() / sizeof(T);
+    return Range<T*>(static_cast<T*>(static_cast<void*>(data_.data())), count);
+  }
+
+  /**
+   * A range of mutable bytes mapped by this mapping.
+   */
+  MutableByteRange writableRange() const {
+    assert(options_.writable); // you'll segfault anyway...
+    return data_;
+  }
+
+  /**
+   * Return the memory area where the file was mapped.
+   * Deprecated; use range() instead.
+   */
+  StringPiece data() const { return asRange<const char>(); }
+
+  bool mlocked() const { return locked_; }
+
+  int fd() const { return file_.fd(); }
+
+ private:
+  MemoryMapping();
+
+  enum InitFlags {
+    kGrow = 1 << 0,
+    kAnon = 1 << 1,
+  };
+  void init(off64_t offset, off64_t length);
+
+  File file_;
+  void* mapStart_ = nullptr;
+  off64_t mapLength_ = 0;
+  Options options_;
+  bool locked_ = false;
+  MutableByteRange data_;
+};
+
+void swap(MemoryMapping&, MemoryMapping&) noexcept;
+
+/**
+ * A special case of memcpy() that always copies memory forwards.
+ * (libc's memcpy() is allowed to copy memory backwards, and will do so
+ * when using SSSE3 instructions).
+ *
+ * Assumes src and dest are aligned to alignof(unsigned long).
+ *
+ * Useful when copying from/to memory mappings after hintLinearScan();
+ * copying backwards renders any prefetching useless (even harmful).
+ */
+void alignedForwardMemcpy(void* dst, const void* src, size_t size);
+
+/**
+ * Copy a file using mmap(). Overwrites dest.
+ */
+void mmapFileCopy(const char* src, const char* dest, mode_t mode = 0666);
+
+/**
+ * mlock2 is Linux-only and exists since Linux 4.4
+ * On Linux pre-4.4 and other platforms fail with ENOSYS.
+ * glibc added the mlock2 wrapper in 2.27
+ * https://lists.gnu.org/archive/html/info-gnu/2018-02/msg00000.html
+ */
+int mlock2wrapper(const void* addr, size_t len, MemoryMapping::LockFlags flags);
+
+} // namespace folly

package/external/folly/folly/system/Pid.cpp

@@ -0,0 +1,87 @@
+/*
+ * 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/system/Pid.h>
+
+#include <atomic>
+
+#include <glog/logging.h>
+
+#include <folly/portability/Unistd.h>
+#include <folly/system/AtFork.h>
+
+namespace folly {
+
+namespace {
+
+enum class State : uint8_t { INVALID, LOCKED, VALID };
+
+class PidState {
+  std::atomic<State> value_{State::INVALID};
+
+ public:
+  FOLLY_ALWAYS_INLINE State load() noexcept {
+    return value_.load(std::memory_order_acquire);
+  }
+
+  void store(State state) noexcept {
+    value_.store(state, std::memory_order_release);
+  }
+
+  bool cas(State& expected, State newstate) noexcept {
+    return value_.compare_exchange_strong(
+        expected,
+        newstate,
+        std::memory_order_relaxed,
+        std::memory_order_relaxed);
+  }
+}; // PidState
+
+class PidCache {
+  PidState state_;
+  pid_t pid_;
+
+ public:
+  FOLLY_ALWAYS_INLINE pid_t get() {
+    DCHECK(!valid() || pid_ == getpid());
+    return valid() ? pid_ : init();
+  }
+
+ private:
+  bool valid() { return state_.load() == State::VALID; }
+
+  [[FOLLY_ATTR_GNU_COLD]] pid_t init() {
+    pid_t pid = getpid();
+    auto s = state_.load();
+    if (s == State::INVALID && state_.cas(s, State::LOCKED)) {
+      folly::AtFork::registerHandler(
+          this, [] { return true; }, [] {}, [this] { pid_ = getpid(); });
+      pid_ = pid;
+      state_.store(State::VALID);
+    }
+    return pid;
+  }
+}; // PidCache
+
+static PidCache cache_;
+
+} // namespace
+
+pid_t get_cached_pid() {
+  return cache_.get();
+}
+
+} // namespace folly

package/external/folly/folly/system/Pid.h

@@ -0,0 +1,34 @@
+/*
+ * 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 <folly/portability/SysTypes.h>
+
+namespace folly {
+
+/**
+ * Calls getpid() and returns the returned value, with a thread-safe
+ * cache in front. The cache is updated in the child after fork().
+ *
+ * Thread-safety: MT-safe.
+ *
+ * Async-signal-safety: The first call is AS-unsafe but subsequent
+ * calls are AS-safe.
+ */
+pid_t get_cached_pid();
+
+} // namespace folly

package/external/folly/folly/system/Shell.cpp

@@ -0,0 +1,33 @@
+/*
+ * 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/system/Shell.h>
+
+namespace folly {
+
+std::string shellQuote(StringPiece argument) {
+  std::string quoted = "'";
+  for (auto c : argument) {
+    if (c == '\'') {
+      quoted += "'\\''";
+    } else {
+      quoted += c;
+    }
+  }
+  return quoted + "'";
+}
+
+} // namespace folly

package/external/folly/folly/system/Shell.h

@@ -0,0 +1,93 @@
+/*
+ * 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.
+ */
+
+/**
+ * `Shell` provides a collection of functions to use with `Subprocess` that make
+ * it easier to safely run processes in a unix shell.
+ *
+ * Note: use this rarely and carefully. By default you should use `Subprocess`
+ * with a vector of arguments.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <folly/Conv.h>
+#include <folly/Format.h>
+#include <folly/Range.h>
+
+namespace folly {
+
+/**
+ * Quotes an argument to make it suitable for use as shell command arguments.
+ */
+std::string shellQuote(StringPiece argument);
+
+namespace detail {
+template <typename... Arguments>
+std::vector<std::string> shellify(
+    StringPiece format, Arguments&&... arguments) {
+  auto command = sformat(
+      format,
+      shellQuote(to<std::string>(std::forward<Arguments>(arguments)))...);
+  return {"/bin/sh", "-c", command};
+}
+
+struct ShellCmdFormat {
+  StringPiece format;
+  template <typename... Arguments>
+  std::vector<std::string> operator()(Arguments&&... arguments) const {
+    return ::folly::detail::shellify(
+        format, std::forward<Arguments>(arguments)...);
+  }
+};
+
+} // namespace detail
+
+inline namespace literals {
+inline namespace shell_literals {
+constexpr detail::ShellCmdFormat operator""_shellify(
+    char const* name, std::size_t length) {
+  return {folly::StringPiece(name, length)};
+}
+} // namespace shell_literals
+} // namespace literals
+
+/**
+ * Create argument array for `Subprocess()` for a process running in a
+ * shell.
+ *
+ * The shell to use is always going to be `/bin/sh`.
+ *
+ * This is deprecated in favour of the user-defined-literal `_shellify`
+ * from namespace `folly::shell_literals` because that requires that the format
+ * string is a compile-time constant which can be inspected during code reviews
+ */
+// clang-format off
+template <typename... Arguments>
+[[deprecated(
+    "Use `\"command {} {} ...\"_shellify(argument1, argument2 ...)` from "
+    "namespace `folly::literals::shell_literals`")]]
+std::vector<std::string> shellify(
+    StringPiece format,
+    Arguments&&... arguments) {
+  return detail::shellify(format, std::forward<Arguments>(arguments)...);
+}
+// clang-format on
+
+} // namespace folly

package/external/folly/folly/system/ThreadId.cpp

@@ -0,0 +1,89 @@
+/*
+ * 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/system/ThreadId.h>
+
+#include <folly/Likely.h>
+#include <folly/portability/PThread.h>
+#include <folly/portability/SysSyscall.h>
+#include <folly/portability/Unistd.h>
+#include <folly/portability/Windows.h>
+#include <folly/synchronization/RelaxedAtomic.h>
+#include <folly/system/AtFork.h>
+
+namespace folly {
+
+uint64_t getCurrentThreadID() {
+#if defined(__APPLE__)
+  return uint64_t(pthread_mach_thread_np(pthread_self()));
+#elif defined(_WIN32)
+  return uint64_t(GetCurrentThreadId());
+#else
+  return uint64_t(pthread_self());
+#endif
+}
+
+namespace detail {
+
+uint64_t getOSThreadIDSlow() {
+#if defined(__APPLE__)
+  uint64_t tid;
+  pthread_threadid_np(nullptr, &tid);
+  return tid;
+#elif defined(_WIN32)
+  return uint64_t(GetCurrentThreadId());
+#elif defined(__FreeBSD__)
+  long tid;
+  thr_self(&tid);
+  return uint64_t(tid);
+#elif defined(__EMSCRIPTEN__)
+  return 0;
+#else
+  return uint64_t(syscall(FOLLY_SYS_gettid));
+#endif
+}
+
+} // namespace detail
+
+namespace {
+
+struct CacheState {
+  CacheState() {
+    AtFork::registerHandler(this, [] { return true; }, [] {}, [] { ++epoch; });
+  }
+  ~CacheState() { AtFork::unregisterHandler(this); }
+
+  // Used to invalidate all caches in the child process on fork. Start at 1 so
+  // that 0 is always invalid.
+  static relaxed_atomic<uint64_t> epoch;
+};
+
+relaxed_atomic<uint64_t> CacheState::epoch{1};
+
+CacheState gCacheState;
+
+} // namespace
+
+uint64_t getOSThreadID() {
+  thread_local std::pair<uint64_t, uint64_t> cache{0, 0};
+  auto epoch = CacheState::epoch.load();
+  if (FOLLY_UNLIKELY(epoch != cache.first)) {
+    cache = {epoch, detail::getOSThreadIDSlow()};
+  }
+  return cache.second;
+}
+
+} // namespace folly

package/external/folly/folly/system/ThreadId.h

@@ -0,0 +1,62 @@
+/*
+ * 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 <cstdint>
+
+namespace folly {
+
+/**
+ * Get a process-specific identifier for the current thread.
+ *
+ * The return value will uniquely identify the thread within the current
+ * process.
+ *
+ * Note that the return value does not necessarily correspond to an operating
+ * system thread ID.  The return value is also only unique within the current
+ * process: getCurrentThreadID() may return the same value for two concurrently
+ * running threads in separate processes.
+ *
+ * The thread ID may be reused once the thread it corresponds to has been
+ * joined.
+ */
+uint64_t getCurrentThreadID();
+
+/**
+ * Get the operating-system level thread ID for the current thread.
+ *
+ * The returned value will uniquely identify this thread on the system.
+ *
+ * This makes it more suitable for logging or displaying in user interfaces
+ * than the result of getCurrentThreadID().
+ *
+ * In theory there is no guarantee that application threads map one-to-one to
+ * kernel threads.  An application threading implementation could potentially
+ * share one OS thread across multiple application threads, and/or it could
+ * potentially move application threads between different OS threads over time.
+ * However, in practice all of the platforms we currently support have a
+ * one-to-one mapping between userspace threads and operating system threads.
+ *
+ * On Linux the returned value is a pid_t, and can be used in contexts
+ * requiring a thread pid_t.
+ *
+ * The thread ID may be reused once the thread it corresponds to has been
+ * joined.
+ */
+uint64_t getOSThreadID();
+
+} // namespace folly