blob: ed076a45b9106f7c0fa9de9fd96a26f25f52d28b [file] [log] [blame]
/*
* Copyright (C) 2019 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 "IcuRegistration.h"
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <unicode/udata.h>
#include <unicode/utypes.h>
#if !defined(__ANDROID__) || defined(NO_ANDROID_LIBLOG)
static int PriorityToLevel(char priority) {
// Priority is just the array index of priority in kPriorities.
static const char* kPriorities = "VDIWEF";
static const int kLogSuppress = sizeof(kPriorities);
const char* matching_priority = strchr(kPriorities, toupper(priority));
return (matching_priority != nullptr) ? matching_priority - kPriorities : kLogSuppress;
}
static int GetHostLogLevel() {
const char* log_tags = getenv("ANDROID_LOG_TAGS");
if (log_tags == nullptr) {
return 0;
}
// Find the wildcard prefix if present in ANDROID_LOG_TAGS.
static constexpr const char kLogWildcardPrefix[] = "*:";
static constexpr size_t kLogWildcardPrefixLength = sizeof(kLogWildcardPrefix) - 1;
const char* wildcard_start = strstr(log_tags, kLogWildcardPrefix);
if (wildcard_start == nullptr) {
return 0;
}
// Priority is based on the character after the wildcard prefix.
char priority = *(wildcard_start + kLogWildcardPrefixLength);
return PriorityToLevel(priority);
}
bool AIcuHostShouldLog(char priority) {
static int g_LogLevel = GetHostLogLevel();
return PriorityToLevel(priority) >= g_LogLevel;
}
#endif // !defined(__ANDROID__) || defined(NO_ANDROID_LIBLOG)
namespace androidicuinit {
namespace impl {
#if !defined(__ANDROID__) || defined(NO_ANDROID_LIBLOG)
// http://b/171371690 Avoid dependency on liblog and libbase on host
// Simplified version of android::base::unique_fd for host.
class simple_unique_fd final {
public:
simple_unique_fd(int fd) {
reset(fd);
}
~simple_unique_fd() {
reset();
}
int get() {
return fd_;
}
private:
int fd_ = -1;
void reset(int new_fd = -1) {
if (fd_ != -1) {
close(fd_);
}
fd_ = new_fd;
}
// Disable copy constructor and assignment operator
simple_unique_fd(const simple_unique_fd&) = delete;
void operator=(const simple_unique_fd&) = delete;
};
// A copy of TEMP_FAILURE_RETRY from android-base/macros.h
// bionic and glibc both have TEMP_FAILURE_RETRY, but eg Mac OS' libc doesn't.
#ifndef TEMP_FAILURE_RETRY
#define TEMP_FAILURE_RETRY(exp) \
({ \
decltype(exp) _rc; \
do { \
_rc = (exp); \
} while (_rc == -1 && errno == EINTR); \
_rc; \
})
#endif
#endif // !defined(__ANDROID__) || defined(NO_ANDROID_LIBLOG)
// http://b/171371690 Avoid dependency on liblog and libbase on host
#if defined(__ANDROID__) && !defined(NO_ANDROID_LIBLOG)
typedef android::base::unique_fd aicu_unique_fd;
#else
typedef simple_unique_fd aicu_unique_fd;
#endif
// Map in ICU data at the path, returning null to print error if it failed.
std::unique_ptr<IcuDataMap> IcuDataMap::Create(const std::string& path) {
std::unique_ptr<IcuDataMap> map(new IcuDataMap(path));
if (!map->TryMap()) {
// madvise or ICU could fail but mmap still succeeds.
// Destructor will take care of cleaning up a partial init.
return nullptr;
}
return map;
}
// Unmap the ICU data.
IcuDataMap::~IcuDataMap() { TryUnmap(); }
bool IcuDataMap::TryMap() {
// Open the file and get its length.
aicu_unique_fd fd(TEMP_FAILURE_RETRY(open(path_.c_str(), O_RDONLY)));
if (fd.get() == -1) {
AICU_LOGE("Couldn't open '%s': %s", path_.c_str(), strerror(errno));
return false;
}
struct stat sb;
if (fstat(fd.get(), &sb) == -1) {
AICU_LOGE("Couldn't stat '%s': %s", path_.c_str(), strerror(errno));
return false;
}
data_length_ = sb.st_size;
// Map it.
data_ =
mmap(NULL, data_length_, PROT_READ, MAP_SHARED, fd.get(), 0 /* offset */);
if (data_ == MAP_FAILED) {
AICU_LOGE("Couldn't mmap '%s': %s", path_.c_str(), strerror(errno));
return false;
}
// Tell the kernel that accesses are likely to be random rather than
// sequential.
if (madvise(data_, data_length_, MADV_RANDOM) == -1) {
AICU_LOGE("Couldn't madvise(MADV_RANDOM) '%s': %s", path_.c_str(),
strerror(errno));
return false;
}
UErrorCode status = U_ZERO_ERROR;
// Tell ICU to use our memory-mapped data.
udata_setCommonData(data_, &status);
if (status != U_ZERO_ERROR) {
AICU_LOGE("Couldn't initialize ICU (udata_setCommonData): %s (%s)",
u_errorName(status), path_.c_str());
return false;
}
return true;
}
bool IcuDataMap::TryUnmap() {
// Don't need to do opposite of udata_setCommonData,
// u_cleanup (performed in IcuRegistration::~IcuRegistration()) takes care of
// it.
// Don't need to opposite of madvise, munmap will take care of it.
if (data_ != nullptr && data_ != MAP_FAILED) {
if (munmap(data_, data_length_) == -1) {
AICU_LOGE("Couldn't munmap '%s': %s", path_.c_str(), strerror(errno));
return false;
}
}
// Don't need to close the file, it was closed automatically during TryMap.
return true;
}
} // namespace impl
// A pointer to the instance used by Register and Deregister. Since this code
// is currently included in a static library this doesn't prevent duplicate
// initialization calls.
static std::unique_ptr<IcuRegistration> gIcuRegistration;
void IcuRegistration::Register() {
CHECK(gIcuRegistration.get() == nullptr);
gIcuRegistration.reset(new IcuRegistration());
}
void IcuRegistration::Deregister() {
gIcuRegistration.reset();
}
// Init ICU, configuring it and loading the data files.
IcuRegistration::IcuRegistration() {
// Note: This logic below should match the logic for ICU4J in
// TimeZoneDataFiles.java in external/icu/ to ensure consistent behavior between
// ICU4C and ICU4J.
// Check the timezone override file exists from a mounted APEX file.
// If it does, map it so we use its data in preference to later ones.
std::string tzModulePath = getTimeZoneModulePath();
if (pathExists(tzModulePath)) {
AICU_LOGD("Time zone APEX ICU file found: %s", tzModulePath.c_str());
icu_datamap_from_tz_module_ = impl::IcuDataMap::Create(tzModulePath);
if (icu_datamap_from_tz_module_ == nullptr) {
AICU_LOGW(
"TZ module override file %s exists but could not be loaded. "
"Skipping.",
tzModulePath.c_str());
}
} else {
AICU_LOGV("No time zone module override file found: %s", tzModulePath.c_str());
}
// Use the ICU data files that shipped with the i18n module for everything
// else.
std::string i18nModulePath = getI18nModulePath();
icu_datamap_from_i18n_module_ = impl::IcuDataMap::Create(i18nModulePath);
if (icu_datamap_from_i18n_module_ == nullptr) {
// IcuDataMap::Create() will log on error so there is no need to log here.
abort();
}
AICU_LOGD("I18n APEX ICU file found: %s", i18nModulePath.c_str());
}
// De-init ICU, unloading the data files. Do the opposite of the above function.
IcuRegistration::~IcuRegistration() {
// Unmap ICU data files.
icu_datamap_from_i18n_module_.reset();
icu_datamap_from_tz_module_.reset();
}
bool IcuRegistration::pathExists(const std::string& path) {
struct stat sb;
return stat(path.c_str(), &sb) == 0;
}
// Returns a string containing the expected path of the (optional) /apex tz
// module data file
std::string IcuRegistration::getTimeZoneModulePath() {
const char* tzdataModulePathPrefix = getenv("ANDROID_TZDATA_ROOT");
if (tzdataModulePathPrefix == NULL) {
AICU_LOGE("ANDROID_TZDATA_ROOT environment variable not set");
abort();
}
std::string tzdataModulePath;
tzdataModulePath = tzdataModulePathPrefix;
tzdataModulePath += "/etc/icu/icu_tzdata.dat";
return tzdataModulePath;
}
std::string IcuRegistration::getI18nModulePath() {
const char* i18nModulePathPrefix = getenv("ANDROID_I18N_ROOT");
if (i18nModulePathPrefix == NULL) {
AICU_LOGE("ANDROID_I18N_ROOT environment variable not set");
abort();
}
std::string i18nModulePath;
i18nModulePath = i18nModulePathPrefix;
i18nModulePath += "/etc/icu/" U_ICUDATA_NAME ".dat";
return i18nModulePath;
}
} // namespace androidicuinit
void android_icu_register() {
androidicuinit::IcuRegistration::Register();
}
void android_icu_deregister() {
androidicuinit::IcuRegistration::Deregister();
}
bool android_icu_is_registered() {
return androidicuinit::gIcuRegistration.get() != nullptr;
}