#include <stdint.h>

#include <functional>

#include <memory>

#include <string>

#include "perfetto/base/build_config.h"

#include "perfetto/base/compiler.h"

#include "perfetto/ext/base/sys_types.h"

#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)

// Even if Windows has errno.h, the all syscall-restart behavior does not apply.

// Trying to handle EINTR can cause more harm than good if errno is left stale.

// Chromium does the same.

#define PERFETTO_EINTR(x) (x)

#else

// setenv(2)-equivalent. Deals with Windows vs Posix discrepancies.

void SetEnv(const std::string& key, const std::string& value);

// unsetenv(2)-equivalent. Deals with Windows vs Posix discrepancies.

void UnsetEnv(const std::string& key);

// Calls mallopt(M_PURGE, 0) on Android. Does nothing on other platforms.

// This forces the allocator to release freed memory. This is used to work

// around various Scudo inefficiencies. See b/170217718.

void MaybeReleaseAllocatorMemToOS();

// geteuid() on POSIX OSes, returns 0 on Windows (See comment in utils.cc).

uid_t GetCurrentUserId();

// Forks the process.

// Parent: prints the PID of the child, calls |parent_cb| and exits from the

//         process with its return value.

// Child: redirects stdio onto /dev/null, chdirs into / and returns.

void Daemonize(std::function<int()> parent_cb);

// Returns the path of the current executable, e.g. /foo/bar/exe.

std::string GetCurExecutablePath();

// Returns the directory where the current executable lives in, e.g. /foo/bar.

// This is independent of cwd().

std::string GetCurExecutableDir();

// Memory returned by AlignedAlloc() must be freed via AlignedFree() not just

// free. It makes a difference on Windows where _aligned_malloc() and

// _aligned_free() must be paired.

// Prefer using the AlignedAllocTyped() below which takes care of the pairing.

void* AlignedAlloc(size_t alignment, size_t size);

void AlignedFree(void*);

// A RAII version of the above, which takes care of pairing Aligned{Alloc,Free}.

template <typename T>

struct AlignedDeleter {

  inline void operator()(T* ptr) const { AlignedFree(ptr); }

};

// The remove_extent<T> here and below is to allow defining unique_ptr<T[]>.

// As per https://en.cppreference.com/w/cpp/memory/unique_ptr the Deleter takes

// always a T*, not a T[]*.

template <typename T>

using AlignedUniquePtr =

    std::unique_ptr<T, AlignedDeleter<typename std::remove_extent<T>::type>>;

template <typename T>

AlignedUniquePtr<T> AlignedAllocTyped(size_t n_membs) {

  using TU = typename std::remove_extent<T>::type;

  return AlignedUniquePtr<T>(

      static_cast<TU*>(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs)));

}

// A RAII wrapper to invoke a function when leaving a function/scope.

template <typename Func>

class OnScopeExitWrapper {

 public:

  explicit OnScopeExitWrapper(Func f) : f_(std::move(f)), active_(true) {}

  OnScopeExitWrapper(OnScopeExitWrapper&& other) noexcept

      : f_(std::move(other.f_)), active_(other.active_) {

    other.active_ = false;

  }

  ~OnScopeExitWrapper() {

    if (active_)

      f_();

  }

 private:

  Func f_;

  bool active_;

};

template <typename Func>

PERFETTO_WARN_UNUSED_RESULT OnScopeExitWrapper<Func> OnScopeExit(Func f) {

  return OnScopeExitWrapper<Func>(std::move(f));

}

// Returns a xxd-style hex dump (hex + ascii chars) of the input data.

std::string HexDump(const void* data, size_t len, size_t bytes_per_line = 16);

inline std::string HexDump(const std::string& data,

                           size_t bytes_per_line = 16) {

  return HexDump(data.data(), data.size(), bytes_per_line);

}

/*

 * Copyright (C) 2020 The Android Open Source Project

 *

 * 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 "perfetto/ext/base/utils.h"

#include <string>

#include "perfetto/base/build_config.h"

#include "perfetto/base/logging.h"

#include "perfetto/ext/base/file_utils.h"

#include "perfetto/ext/base/pipe.h"

#include "perfetto/ext/base/string_utils.h"

#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) ||   \

    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \

    PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) ||   \

    PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA)

#include <limits.h>

#include <stdlib.h>  // For _exit()

#include <unistd.h>  // For getpagesize() and geteuid() & fork()

#endif

#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)

#include <mach-o/dyld.h>

#include <mach/vm_page_size.h>

#endif

#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)

#include <Windows.h>

#include <io.h>

#include <malloc.h>  // For _aligned_malloc().

#endif

#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)

#include <dlfcn.h>

#include <malloc.h>

#ifdef M_PURGE

#define PERFETTO_M_PURGE M_PURGE

#else

// Only available in in-tree builds and on newer SDKs.

#define PERFETTO_M_PURGE -101

#endif  // M_PURGE

#ifdef M_PURGE_ALL

#define PERFETTO_M_PURGE_ALL M_PURGE_ALL

#else

// Only available in in-tree builds and on newer SDKs.

#define PERFETTO_M_PURGE_ALL -104

#endif  // M_PURGE

namespace {

extern "C" {

using MalloptType = int (*)(int, int);

}

}  // namespace

#endif  // OS_ANDROID

namespace perfetto {

namespace base {

uint32_t GetSysPageSize() {

  ignore_result(kPageSize);  // Just to keep the amalgamated build happy.

#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \

    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)

  static std::atomic<uint32_t> page_size{0};

  // This function might be called in hot paths. Avoid calling getpagesize() all

  // the times, in many implementations getpagesize() calls sysconf() which is

  // not cheap.

  uint32_t cached_value = page_size.load(std::memory_order_relaxed);

  if (PERFETTO_UNLIKELY(cached_value == 0)) {

    cached_value = static_cast<uint32_t>(getpagesize());

    page_size.store(cached_value, std::memory_order_relaxed);

  }

  return cached_value;

#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE)

  return static_cast<uint32_t>(vm_page_size);

#else

  return 4096;

#endif

}

void* AlignedAlloc(size_t alignment, size_t size) {

  void* res = nullptr;

  alignment = AlignUp<sizeof(void*)>(alignment);  // At least pointer size.

#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)

  // Window's _aligned_malloc() has a nearly identically signature to Unix's

  // aligned_alloc() but its arguments are obviously swapped.

  res = _aligned_malloc(size, alignment);

#else

  // aligned_alloc() has been introduced in Android only in API 28.

  // Also NaCl and Fuchsia seems to have only posix_memalign().

  ignore_result(posix_memalign(&res, alignment, size));

#endif

  PERFETTO_CHECK(res);

  return res;

}

void AlignedFree(void* ptr) {

#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)

  _aligned_free(ptr);  // MSDN says it is fine to pass nullptr.

#else

  free(ptr);

#endif

}

}  // namespace base

}  // namespace perfetto

    "utils.cc",