blob: 35eca99e6ababe2cd254109d8784abf3afe22607 [file] [log] [blame] [edit]
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/globals.h"
#if defined(DART_HOST_OS_FUCHSIA)
#include "vm/os.h"
#include <dlfcn.h>
#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <fuchsia/intl/cpp/fidl.h>
#include <lib/async-loop/default.h>
#include <lib/async-loop/loop.h>
#include <lib/async/default.h>
#include <lib/inspect/component/cpp/component.h>
#include <lib/inspect/cpp/inspect.h>
#include <lib/sys/cpp/component_context.h>
#include <lib/sys/cpp/service_directory.h>
#include <zircon/process.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/object.h>
#include <zircon/threads.h>
#include <zircon/time.h>
#include <zircon/types.h>
#include <set>
#include "unicode/errorcode.h"
#include "unicode/timezone.h"
#include "unicode/umachine.h"
#include "platform/assert.h"
#include "platform/syslog.h"
#include "platform/utils.h"
#include "vm/image_snapshot.h"
#include "vm/lockers.h"
#include "vm/os_thread.h"
#include "vm/zone.h"
namespace {
using dart::Mutex;
using dart::MutexLocker;
using dart::Syslog;
using dart::Zone;
// This is the default timezone returned if it could not be obtained. For
// Fuchsia, the default device timezone is always UTC.
static const char kDefaultTimezone[] = "UTC";
static constexpr int32_t kMsPerSec = 1000;
// The data directory containing ICU timezone data files.
static constexpr char kICUTZDataDir[] = "/config/data/tzdata/icu/44/le";
// An updated location for ICU timezone data files.
// See:
// https://fuchsia.dev/fuchsia-src/development/internationalization/icu_data#timezone_configuration_data
// https://fuchsia.dev/fuchsia-src/concepts/process/namespaces
static constexpr char kICUTZDataDir2[] = "/config/tzdata/icu/44/le";
// This is the general OK status.
static constexpr int32_t kOk = 0;
// This status means that the error code is not initialized yet ("set" was not
// yet called). Error codes are usually either 0 (kOk), or negative.
static constexpr int32_t kUninitialized = 1;
// The status codes for tzdata file open and read.
enum class TZDataStatus {
// The operation completed without error.
OK = 0,
// The open call for the tzdata file did not succeed.
COULD_NOT_OPEN = -1,
// The close call (after tzdata was loaded) did not succeed.
COULD_NOT_CLOSE = -2,
};
// Adds a facility for introspecting timezone data errors. Allows insight into
// the internal state of the VM even if error reporting facilities fail.
//
// Under normal operation, all metric values below should be zero.
class InspectMetrics {
public:
// Takes ownership of the vm_node.
explicit InspectMetrics(std::unique_ptr<inspect::Node> vm_node)
: vm_node_(std::move(vm_node)),
dst_status_(vm_node_->CreateInt("dst_status", kUninitialized)),
tz_data_status_(vm_node_->CreateInt("tz_data_status", kUninitialized)),
tz_data_close_status_(
vm_node_->CreateInt("tz_data_close_status", kUninitialized)),
get_profile_status_(
vm_node_->CreateInt("get_profile_status", kUninitialized)),
profiles_timezone_content_status_(
vm_node_->CreateInt("timezone_content_status", kOk)),
num_get_profile_calls_(vm_node_->CreateInt("num_get_profile_calls", 0)),
num_on_change_calls_(vm_node_->CreateInt("num_on_change_calls", 0)),
num_intl_provider_errors_(
vm_node_->CreateInt("num_intl_provider_errors", 0)) {}
// Registers a single call to GetProfile callback.
void RegisterGetProfileCall() { num_get_profile_calls_.Add(1); }
// Registers a single call to OnChange callback.
void RegisterOnChangeCall() { num_on_change_calls_.Add(1); }
// Registers a provider error.
void RegisterIntlProviderError() { num_intl_provider_errors_.Add(1); }
// Sets the last status code for DST offset calls.
void SetDSTOffsetStatus(zx_status_t status) {
dst_status_.Set(static_cast<int32_t>(status));
}
// Sets the return value of call to InitializeTZData, and the status of the
// reported by close() on tzdata files.
void SetInitTzData(TZDataStatus value, int32_t status) {
tz_data_status_.Set(static_cast<int32_t>(value));
tz_data_close_status_.Set(status);
}
// Sets the last status code for the call to PropertyProvider::GetProfile.
void SetProfileStatus(zx_status_t status) {
get_profile_status_.Set(static_cast<int32_t>(status));
}
// Sets the last status seen while examining timezones returned from
// PropertyProvider::GetProfile.
void SetTimeZoneContentStatus(zx_status_t status) {
profiles_timezone_content_status_.Set(static_cast<int32_t>(status));
}
private:
// The OS metrics node.
std::unique_ptr<inspect::Node> vm_node_;
// The status of the last GetTimeZoneOffset call.
inspect::IntProperty dst_status_;
// The status of the initialization.
inspect::IntProperty tz_data_status_;
// The return code for the close() call for tzdata files.
inspect::IntProperty tz_data_close_status_;
// The return code of the GetProfile call in GetTimeZoneName. If this is
// nonzero, then os_fuchsia.cc reported a default timezone as a fallback.
inspect::IntProperty get_profile_status_;
// U_ILLEGAL_ARGUMENT_ERROR(=1) if timezones read from ProfileProvider were
// incorrect. Otherwise 0. If this metric reports U_ILLEGAL_ARGUMENT_ERROR,
// the os_fuchsia.cc module reported a default timezone as a fallback.
inspect::IntProperty profiles_timezone_content_status_;
// Keeps a number of get_profile update calls.
inspect::IntProperty num_get_profile_calls_;
// Number of "on change" callback calls.
inspect::IntProperty num_on_change_calls_;
// Keeps a number of errors encountered in intl provider.
inspect::IntProperty num_intl_provider_errors_;
};
// Thread-safe storage for the current timezone name.
//
// Keeps an up to date timezone cache, updating if needed through the
// asynchronous update interface. Access to this class is thread-safe.
class TimezoneName final {
public:
// Creates a new instance of TimezoneName. Does not take ownership of
// metrics.
static std::shared_ptr<TimezoneName> New(
fuchsia::intl::PropertyProviderPtr proxy,
std::weak_ptr<InspectMetrics> metrics) {
auto timezone_name =
std::make_shared<TimezoneName>(std::move(proxy), metrics);
timezone_name->InitHandlers(timezone_name);
return timezone_name;
}
TimezoneName(fuchsia::intl::PropertyProviderPtr proxy,
std::weak_ptr<InspectMetrics> metrics)
: m_(),
metrics_(std::move(metrics)),
proxy_(std::move(proxy)),
timezone_name_(kDefaultTimezone) {
ASSERT(metrics_.lock() != nullptr);
}
// Gets the current timezone name. Repeated calls may retrieve updated
// values.
std::string Get() const {
MutexLocker lock(&m_);
// Returns a copy, to avoid a data race with async updates.
return timezone_name_;
}
private:
// Sets the event handlers in this resolver. Intended to resolve a circular
// reference between the shared timezone name and this.
void InitHandlers(std::shared_ptr<TimezoneName> timezone_name) {
ASSERT(timezone_name.get() == this);
timezone_name->proxy_.set_error_handler(
[weak_this =
std::weak_ptr<TimezoneName>(timezone_name)](zx_status_t status) {
if (!weak_this.expired()) {
weak_this.lock()->ErrorHandler(status);
}
});
timezone_name->proxy_.events().OnChange =
[weak_this = std::weak_ptr<TimezoneName>(timezone_name)]() {
if (!weak_this.expired()) {
weak_this.lock()->OnChangeCallback();
}
};
timezone_name->proxy_->GetProfile(
[weak_this = std::weak_ptr<TimezoneName>(timezone_name)](
fuchsia::intl::Profile profile) {
if (!weak_this.expired()) {
weak_this.lock()->GetProfileCallback(std::move(profile));
}
});
}
// Called on a profile provider error in the context of the event loop
// thread.
void ErrorHandler(zx_status_t status) {
MutexLocker lock(&m_);
WithMetrics([status](std::shared_ptr<InspectMetrics> metrics) {
metrics->SetProfileStatus(status);
metrics->RegisterIntlProviderError();
});
}
// Called when an OnChange event is received in the context of the event loop
// thread. The only action here is to trigger an asynchronous update of the
// intl profile.
void OnChangeCallback() {
MutexLocker lock(&m_);
WithMetrics([](std::shared_ptr<InspectMetrics> metrics) {
metrics->RegisterOnChangeCall();
});
proxy_->GetProfile([this](fuchsia::intl::Profile profile) {
this->GetProfileCallback(std::move(profile));
});
}
// Called when a GetProfile async request is resolved, in the context of the
// event loop thread.
void GetProfileCallback(fuchsia::intl::Profile profile) {
MutexLocker lock(&m_);
WithMetrics([](std::shared_ptr<InspectMetrics> metrics) {
metrics->RegisterGetProfileCall();
});
const std::vector<fuchsia::intl::TimeZoneId>& timezones =
profile.time_zones();
if (timezones.empty()) {
WithMetrics([](std::shared_ptr<InspectMetrics> metrics) {
metrics->SetTimeZoneContentStatus(U_ILLEGAL_ARGUMENT_ERROR);
});
// Empty timezone array is not up to fuchsia::intl spec. The serving
// endpoint is broken and should be fixed.
Syslog::PrintErr("got empty timezone value\n");
return;
}
WithMetrics([](std::shared_ptr<InspectMetrics> metrics) {
metrics->SetProfileStatus(ZX_OK);
metrics->SetTimeZoneContentStatus(ZX_OK);
});
timezone_name_ = timezones[0].id;
}
// Runs the provided function only on valid metrics.
void WithMetrics(std::function<void(std::shared_ptr<InspectMetrics> m)> f) {
std::shared_ptr<InspectMetrics> l = metrics_.lock();
if (l != nullptr) {
f(l);
}
}
// Guards timezone_name_ because the callbacks will be called in an
// asynchronous thread.
mutable Mutex m_;
// Used to keep tally on the update events. Not owned.
std::weak_ptr<InspectMetrics> metrics_;
// A client-side proxy for a connection to the property provider service.
fuchsia::intl::PropertyProviderPtr proxy_;
// Caches the current timezone name. This is updated asynchronously through
// GetProfileCallback.
std::string timezone_name_;
};
// The timezone names encountered so far. The timezone names must live forever.
std::set<std::string> timezone_names;
// Initialized on OS:Init(), deinitialized on OS::Cleanup.
std::shared_ptr<InspectMetrics> metrics;
std::shared_ptr<TimezoneName> timezone_name;
async_loop_t* message_loop = nullptr;
// Initializes the source of timezone data if available. Timezone data file in
// Fuchsia is at a fixed directory path. Returns true on success.
bool InitializeTZData() {
ASSERT(metrics != nullptr);
// Try opening the path to check if present. No need to verify that it is a
// directory since ICU loading will return an error if the TZ data path is
// wrong.
//
// Try the new dir first, sub with the old fallback.
const char* tz_dirname = kICUTZDataDir2;
int fd = openat(AT_FDCWD, tz_dirname, O_RDONLY);
if (fd < 0) {
tz_dirname = kICUTZDataDir;
fd = openat(AT_FDCWD, tz_dirname, O_RDONLY);
}
if (fd < 0) {
metrics->SetInitTzData(TZDataStatus::COULD_NOT_OPEN, fd);
return false;
}
// 0 == Not overwriting the env var if already set.
setenv("ICU_TIMEZONE_FILES_DIR", tz_dirname, 0);
int32_t close_status = close(fd);
if (close_status != 0) {
metrics->SetInitTzData(TZDataStatus::COULD_NOT_CLOSE, close_status);
return false;
}
metrics->SetInitTzData(TZDataStatus::OK, 0);
return true;
}
int64_t GetCurrentTimeNanos() {
struct timespec ts;
if (timespec_get(&ts, TIME_UTC) == 0) {
FATAL("timespec_get failed");
return 0;
}
return zx_time_add_duration(ZX_SEC(ts.tv_sec), ZX_NSEC(ts.tv_nsec));
}
} // namespace
namespace dart {
#ifndef PRODUCT
DEFINE_FLAG(bool,
generate_perf_events_symbols,
false,
"Generate events symbols for profiling with perf");
#endif // !PRODUCT
intptr_t OS::ProcessId() {
return static_cast<intptr_t>(getpid());
}
// TODO(FL-98): Change this to talk to fuchsia.dart to get timezone service to
// directly get timezone.
//
// Putting this hack right now due to CP-120 as I need to remove
// component:ConnectToEnvironmentServices and this is the only thing that is
// blocking it and FL-98 will take time.
static fuchsia::intl::PropertyProviderPtr property_provider;
static zx_status_t GetLocalAndDstOffsetInSeconds(int64_t seconds_since_epoch,
int32_t* local_offset,
int32_t* dst_offset) {
const char* timezone_id = OS::GetTimeZoneName(seconds_since_epoch);
std::unique_ptr<icu::TimeZone> timezone(
icu::TimeZone::createTimeZone(timezone_id));
UErrorCode error = U_ZERO_ERROR;
const auto ms_since_epoch =
static_cast<UDate>(kMsPerSec * seconds_since_epoch);
// The units of time that local_offset and dst_offset are returned from this
// function is, usefully, not documented, but it seems that the units are
// milliseconds. Add these variables here for clarity.
int32_t local_offset_ms = 0;
int32_t dst_offset_ms = 0;
timezone->getOffset(ms_since_epoch, /*local_time=*/0, local_offset_ms,
dst_offset_ms, error);
metrics->SetDSTOffsetStatus(error);
if (error != U_ZERO_ERROR) {
icu::ErrorCode icu_error;
icu_error.set(error);
Syslog::PrintErr("could not get DST offset: %s\n", icu_error.errorName());
return ZX_ERR_INTERNAL;
}
// We must return offset in seconds, so convert.
*local_offset = local_offset_ms / kMsPerSec;
*dst_offset = dst_offset_ms / kMsPerSec;
return ZX_OK;
}
// Returns a C string with the time zone name. This module retains the
// ownership of the pointer.
const char* OS::GetTimeZoneName(int64_t seconds_since_epoch) {
ASSERT(timezone_name != nullptr);
// Sadly, since we do not know how long the timezone name will be needed, we
// can not ever deallocate it. So instead, we put it into a a set that will
// not move it around in memory and return a pointer to it. Since the number
// of timezones is finite, this ensures that the memory taken up by timezones
// does not grow indefinitely, even if we end up retaining all the timezones
// there are.
const auto i = timezone_names.insert(timezone_name->Get());
ASSERT(i.first != timezone_names.end());
return i.first->c_str();
}
int OS::GetTimeZoneOffsetInSeconds(int64_t seconds_since_epoch) {
int32_t local_offset = 0;
int32_t dst_offset = 0;
const zx_status_t status = GetLocalAndDstOffsetInSeconds(
seconds_since_epoch, &local_offset, &dst_offset);
return status == ZX_OK ? local_offset + dst_offset : 0;
}
int64_t OS::GetCurrentTimeMillis() {
return GetCurrentTimeNanos() / ZX_MSEC(1);
}
int64_t OS::GetCurrentTimeMicros() {
return GetCurrentTimeNanos() / ZX_USEC(1);
}
int64_t OS::GetCurrentMonotonicTicks() {
return zx_clock_get_monotonic();
}
int64_t OS::GetCurrentMonotonicFrequency() {
return kNanosecondsPerSecond;
}
int64_t OS::GetCurrentMonotonicMicros() {
const int64_t ticks = GetCurrentMonotonicTicks();
ASSERT(GetCurrentMonotonicFrequency() == kNanosecondsPerSecond);
return ticks / kNanosecondsPerMicrosecond;
}
int64_t OS::GetCurrentThreadCPUMicros() {
zx_info_thread_stats_t info = {};
zx_status_t status = zx_object_get_info(thrd_get_zx_handle(thrd_current()),
ZX_INFO_THREAD_STATS, &info,
sizeof(info), nullptr, nullptr);
return status == ZX_OK ? info.total_runtime / kNanosecondsPerMicrosecond : 0;
}
int64_t OS::GetCurrentMonotonicMicrosForTimeline() {
#if defined(SUPPORT_TIMELINE)
return OS::GetCurrentMonotonicMicros();
#else
return -1;
#endif
}
// TODO(5411554): May need to hoist these architecture dependent code
// into a architecture specific file e.g: os_ia32_fuchsia.cc
intptr_t OS::ActivationFrameAlignment() {
#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64) || \
defined(TARGET_ARCH_ARM64)
const int kMinimumAlignment = 16;
#elif defined(TARGET_ARCH_ARM)
const int kMinimumAlignment = 8;
#else
#error Unsupported architecture.
#endif
intptr_t alignment = kMinimumAlignment;
// TODO(5411554): Allow overriding default stack alignment for
// testing purposes.
// Flags::DebugIsInt("stackalign", &alignment);
ASSERT(Utils::IsPowerOfTwo(alignment));
ASSERT(alignment >= kMinimumAlignment);
return alignment;
}
int OS::NumberOfAvailableProcessors() {
return sysconf(_SC_NPROCESSORS_CONF);
}
void OS::Sleep(int64_t millis) {
SleepMicros(millis * kMicrosecondsPerMillisecond);
}
void OS::SleepMicros(int64_t micros) {
zx_nanosleep(zx_deadline_after(micros * kNanosecondsPerMicrosecond));
}
void OS::DebugBreak() {
UNIMPLEMENTED();
}
DART_NOINLINE uintptr_t OS::GetProgramCounter() {
return reinterpret_cast<uintptr_t>(
__builtin_extract_return_addr(__builtin_return_address(0)));
}
void OS::Print(const char* format, ...) {
va_list args;
va_start(args, format);
VFPrint(stdout, format, args);
va_end(args);
}
void OS::VFPrint(FILE* stream, const char* format, va_list args) {
vfprintf(stream, format, args);
fflush(stream);
}
char* OS::SCreate(Zone* zone, const char* format, ...) {
va_list args;
va_start(args, format);
char* buffer = VSCreate(zone, format, args);
va_end(args);
return buffer;
}
char* OS::VSCreate(Zone* zone, const char* format, va_list args) {
// Measure.
va_list measure_args;
va_copy(measure_args, args);
intptr_t len = Utils::VSNPrint(nullptr, 0, format, measure_args);
va_end(measure_args);
char* buffer;
if (zone != nullptr) {
buffer = zone->Alloc<char>(len + 1);
} else {
buffer = reinterpret_cast<char*>(malloc(len + 1));
}
ASSERT(buffer != nullptr);
// Print.
va_list print_args;
va_copy(print_args, args);
Utils::VSNPrint(buffer, len + 1, format, print_args);
va_end(print_args);
return buffer;
}
bool OS::StringToInt64(const char* str, int64_t* value) {
ASSERT(str != nullptr && strlen(str) > 0 && value != nullptr);
int32_t base = 10;
char* endptr;
int i = 0;
if (str[0] == '-') {
i = 1;
} else if (str[0] == '+') {
i = 1;
}
if ((str[i] == '0') && (str[i + 1] == 'x' || str[i + 1] == 'X') &&
(str[i + 2] != '\0')) {
base = 16;
}
errno = 0;
if (base == 16) {
// Unsigned 64-bit hexadecimal integer literals are allowed but
// immediately interpreted as signed 64-bit integers.
*value = static_cast<int64_t>(strtoull(str, &endptr, base));
} else {
*value = strtoll(str, &endptr, base);
}
return ((errno == 0) && (endptr != str) && (*endptr == 0));
}
void OS::RegisterCodeObservers() {
#ifndef PRODUCT
if (FLAG_generate_perf_events_symbols) {
UNIMPLEMENTED();
}
#endif // !PRODUCT
}
void OS::PrintErr(const char* format, ...) {
va_list args;
va_start(args, format);
VFPrint(stderr, format, args);
va_end(args);
}
void OS::Init() {
if (async_get_default_dispatcher() == nullptr) {
async_loop_create(&kAsyncLoopConfigAttachToCurrentThread, &message_loop);
async_set_default_dispatcher(async_loop_get_dispatcher(message_loop));
async_loop_start_thread(message_loop, "Fuchsia async loop", nullptr);
}
auto vm_node = dart::TakeDartVmNode();
// TODO(fxbug.dev/69558) allow vm_node to be null and not crash
ASSERT(vm_node != nullptr);
metrics = std::make_shared<InspectMetrics>(std::move(vm_node));
InitializeTZData();
auto services = sys::ServiceDirectory::CreateFromNamespace();
services->Connect(property_provider.NewRequest());
timezone_name = TimezoneName::New(std::move(property_provider), metrics);
}
void OS::Cleanup() {
if (message_loop != nullptr) {
async_loop_shutdown(message_loop);
}
timezone_name.reset();
metrics.reset();
if (message_loop != nullptr) {
// Check message_loop is still the default dispatcher before clearing it.
if (async_get_default_dispatcher() ==
async_loop_get_dispatcher(message_loop)) {
async_set_default_dispatcher(nullptr);
}
async_loop_destroy(message_loop);
message_loop = nullptr;
}
}
void OS::PrepareToAbort() {}
void OS::Abort() {
PrepareToAbort();
abort();
}
void OS::Exit(int code) {
exit(code);
}
// Used to choose between Elf32/Elf64 types based on host archotecture bitsize.
#if defined(ARCH_IS_64_BIT)
#define ElfW(Type) Elf64_##Type
#else
#define ElfW(Type) Elf32_##Type
#endif
OS::BuildId OS::GetAppBuildId(const uint8_t* snapshot_instructions) {
// First return the build ID information from the instructions image if
// available.
const Image instructions_image(snapshot_instructions);
if (auto* const image_build_id = instructions_image.build_id()) {
return {instructions_image.build_id_length(), image_build_id};
}
const uint8_t* dso_base = GetAppDSOBase(snapshot_instructions);
const ElfW(Ehdr) & elf_header =
*reinterpret_cast<const ElfW(Ehdr)*>(dso_base);
const ElfW(Phdr)* const phdr_array =
reinterpret_cast<const ElfW(Phdr)*>(dso_base + elf_header.e_phoff);
for (intptr_t i = 0; i < elf_header.e_phnum; i++) {
const ElfW(Phdr) & header = phdr_array[i];
if (header.p_type != PT_NOTE) continue;
if ((header.p_flags & PF_R) != PF_R) continue;
const uint8_t* const note_addr = dso_base + header.p_vaddr;
const Elf32_Nhdr& note_header =
*reinterpret_cast<const Elf32_Nhdr*>(note_addr);
if (note_header.n_type != NT_GNU_BUILD_ID) continue;
const char* const note_contents =
reinterpret_cast<const char*>(note_addr + sizeof(Elf32_Nhdr));
// The note name contains the null terminator as well.
if (note_header.n_namesz != strlen(ELF_NOTE_GNU) + 1) continue;
if (strncmp(ELF_NOTE_GNU, note_contents, note_header.n_namesz) == 0) {
return {static_cast<intptr_t>(note_header.n_descsz),
reinterpret_cast<const uint8_t*>(note_contents +
note_header.n_namesz)};
}
}
return {0, nullptr};
}
} // namespace dart
#endif // defined(DART_HOST_OS_FUCHSIA)