react-native-mmkv-dz 2.5.1

package/MMKV/Core/MemoryFile_Android.cpp

@@ -0,0 +1,211 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2019 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * 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 "MemoryFile.h"
+
+#ifdef MMKV_ANDROID
+
+#    include "MMBuffer.h"
+#    include "MMKVLog.h"
+#    include <cerrno>
+#    include <fcntl.h>
+#    include <sys/mman.h>
+#    include <sys/stat.h>
+#    include <unistd.h>
+
+using namespace std;
+
+constexpr char ASHMEM_NAME_DEF[] = "/dev/ashmem";
+
+namespace mmkv {
+
+// for Android Q limiting ashmem access
+extern int ASharedMemory_create(const char *name, size_t size);
+extern size_t ASharedMemory_getSize(int fd);
+extern string ASharedMemory_getName(int fd);
+
+File::File(MMKVPath_t path, OpenFlag flag, size_t size, FileType fileType)
+    : m_path(std::move(path)), m_fd(-1), m_flag(flag), m_size(0), m_fileType(fileType) {
+    if (m_fileType == MMFILE_TYPE_FILE) {
+        open();
+    } else {
+        // round up to (n * pagesize)
+        if (size < DEFAULT_MMAP_SIZE || (size % DEFAULT_MMAP_SIZE != 0)) {
+            size = ((size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
+        }
+        auto filename = m_path.c_str();
+        auto ptr = strstr(filename, ASHMEM_NAME_DEF);
+        if (ptr && ptr[sizeof(ASHMEM_NAME_DEF) - 1] == '/') {
+            filename = ptr + sizeof(ASHMEM_NAME_DEF);
+        }
+        m_fd = ASharedMemory_create(filename, size);
+        if (isFileValid()) {
+            m_size = size;
+        }
+    }
+}
+
+File::File(MMKVFileHandle_t ashmemFD)
+    : m_path(), m_fd(ashmemFD), m_flag(OpenFlag::ReadWrite), m_size(0), m_fileType(MMFILE_TYPE_ASHMEM) {
+    if (isFileValid()) {
+        m_path = ASharedMemory_getName(m_fd);
+        m_size = ASharedMemory_getSize(m_fd);
+    }
+}
+
+MemoryFile::MemoryFile(string path, size_t size, FileType fileType)
+    : m_diskFile(std::move(path), OpenFlag::ReadWrite | OpenFlag::Create, size, fileType), m_ptr(nullptr), m_size(0), m_fileType(fileType) {
+    if (m_fileType == MMFILE_TYPE_FILE) {
+        reloadFromFile();
+    } else {
+        if (m_diskFile.isFileValid()) {
+            m_size = m_diskFile.m_size;
+            auto ret = mmap();
+            if (!ret) {
+                doCleanMemoryCache(true);
+            }
+        }
+    }
+}
+
+MemoryFile::MemoryFile(int ashmemFD)
+    : m_diskFile(ashmemFD), m_ptr(nullptr), m_size(0), m_fileType(MMFILE_TYPE_ASHMEM) {
+    if (!m_diskFile.isFileValid()) {
+        MMKVError("fd %d invalid", ashmemFD);
+    } else {
+        m_size = m_diskFile.m_size;
+        MMKVInfo("ashmem name:%s, size:%zu", m_diskFile.m_path.c_str(), m_size);
+        auto ret = mmap();
+        if (!ret) {
+            doCleanMemoryCache(true);
+        }
+    }
+}
+
+} // namespace mmkv
+
+#    pragma mark - ashmem
+#    include <dlfcn.h>
+#    include <sys/ioctl.h>
+
+namespace mmkv {
+
+constexpr auto ASHMEM_NAME_LEN = 256;
+constexpr auto ASHMEM_IOC = 0x77;
+#    define ASHMEM_SET_NAME _IOW(ASHMEM_IOC, 1, char[ASHMEM_NAME_LEN])
+#    define ASHMEM_GET_NAME _IOR(ASHMEM_IOC, 2, char[ASHMEM_NAME_LEN])
+#    define ASHMEM_SET_SIZE _IOW(ASHMEM_IOC, 3, size_t)
+#    define ASHMEM_GET_SIZE _IO(ASHMEM_IOC, 4)
+
+int g_android_api = __ANDROID_API_L__;
+std::string g_android_tmpDir = "/data/local/tmp/";
+
+void *loadLibrary() {
+    auto name = "libandroid.so";
+    static auto handle = dlopen(name, RTLD_LAZY | RTLD_LOCAL);
+    if (handle == RTLD_DEFAULT) {
+        MMKVError("unable to load library %s", name);
+    }
+    return handle;
+}
+
+typedef int (*AShmem_create_t)(const char *name, size_t size);
+
+int ASharedMemory_create(const char *name, size_t size) {
+    int fd = -1;
+    if (g_android_api >= __ANDROID_API_O__) {
+        static auto handle = loadLibrary();
+        static AShmem_create_t funcPtr =
+            (handle != nullptr) ? reinterpret_cast<AShmem_create_t>(dlsym(handle, "ASharedMemory_create")) : nullptr;
+        if (funcPtr) {
+            fd = funcPtr(name, size);
+            if (fd < 0) {
+                MMKVError("fail to ASharedMemory_create %s with size %zu, errno:%s", name, size, strerror(errno));
+            }
+        } else {
+            MMKVWarning("fail to locate ASharedMemory_create() from loading libandroid.so");
+        }
+    }
+    if (fd < 0) {
+        fd = open(ASHMEM_NAME_DEF, O_RDWR | O_CLOEXEC);
+        if (fd < 0) {
+            MMKVError("fail to open ashmem:%s, %s", name, strerror(errno));
+        } else {
+            if (ioctl(fd, ASHMEM_SET_NAME, name) != 0) {
+                MMKVError("fail to set ashmem name:%s, %s", name, strerror(errno));
+            } else if (ioctl(fd, ASHMEM_SET_SIZE, size) != 0) {
+                MMKVError("fail to set ashmem:%s, size %zu, %s", name, size, strerror(errno));
+            }
+        }
+    }
+    return fd;
+}
+
+typedef size_t (*AShmem_getSize_t)(int fd);
+
+size_t ASharedMemory_getSize(int fd) {
+    size_t size = 0;
+    if (g_android_api >= __ANDROID_API_O__) {
+        static auto handle = loadLibrary();
+        static AShmem_getSize_t funcPtr =
+            (handle != nullptr) ? reinterpret_cast<AShmem_getSize_t>(dlsym(handle, "ASharedMemory_getSize")) : nullptr;
+        if (funcPtr) {
+            size = funcPtr(fd);
+            if (size == 0) {
+                MMKVError("fail to ASharedMemory_getSize:%d, %s", fd, strerror(errno));
+            }
+        } else {
+            MMKVWarning("fail to locate ASharedMemory_create() from loading libandroid.so");
+        }
+    }
+    if (size == 0) {
+        int tmp = ioctl(fd, ASHMEM_GET_SIZE, nullptr);
+        if (tmp < 0) {
+            MMKVError("fail to get ashmem size:%d, %s", fd, strerror(errno));
+        } else {
+            size = static_cast<size_t>(tmp);
+        }
+    }
+    return size;
+}
+
+string ASharedMemory_getName(int fd) {
+    // Android Q doesn't have ASharedMemory_getName()
+    // I've make a request to Google, https://issuetracker.google.com/issues/130741665
+    // There's nothing we can do before it's supported officially by Google
+    if (g_android_api >= __ANDROID_API_Q__) {
+        return "";
+    }
+
+    char name[ASHMEM_NAME_LEN] = {0};
+    if (ioctl(fd, ASHMEM_GET_NAME, name) != 0) {
+        MMKVError("fail to get ashmem name:%d, %s", fd, strerror(errno));
+        return "";
+    }
+    return {name};
+}
+
+} // namespace mmkv
+
+MMKVPath_t ashmemMMKVPathWithID(const MMKVPath_t &mmapID) {
+    return MMKVPath_t(ASHMEM_NAME_DEF) + MMKV_PATH_SLASH + mmapID;
+}
+
+#endif // MMKV_ANDROID

package/MMKV/Core/MemoryFile_Linux.cpp

@@ -0,0 +1,120 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * 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 "MemoryFile.h"
+
+#if defined(MMKV_ANDROID) || defined(MMKV_LINUX)
+#    include "InterProcessLock.h"
+#    include "MMBuffer.h"
+#    include "MMKVLog.h"
+#    include "ScopedLock.hpp"
+#    include <cerrno>
+#    include <utility>
+#    include <fcntl.h>
+#    include <sys/mman.h>
+#    include <sys/stat.h>
+#    include <unistd.h>
+#    include <sys/file.h>
+#    include <dirent.h>
+#    include <cstring>
+#    include <sys/sendfile.h>
+#    include <sys/syscall.h>
+
+#ifdef MMKV_ANDROID
+#include <dlfcn.h>
+typedef int (*renameat2_t)(int old_dir_fd, const char* old_path, int new_dir_fd, const char* new_path, unsigned flags);
+#endif
+
+#ifndef RENAME_EXCHANGE
+#define RENAME_EXCHANGE (1 << 1) /* Exchange source and dest */
+#endif
+
+namespace mmkv {
+
+extern bool getFileSize(int fd, size_t &size);
+
+bool tryAtomicRename(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    bool renamed = false;
+
+    // try renameat2() first
+#ifdef SYS_renameat2
+#ifdef MMKV_ANDROID
+    static auto g_renameat2 = (renameat2_t) dlsym(RTLD_DEFAULT, "renameat2");
+    if (g_renameat2) {
+        renamed = (g_renameat2(AT_FDCWD, srcPath.c_str(), AT_FDCWD, dstPath.c_str(), RENAME_EXCHANGE) == 0);
+    }
+#endif
+    if (!renamed) {
+        renamed = (syscall(SYS_renameat2, AT_FDCWD, srcPath.c_str(), AT_FDCWD, dstPath.c_str(), RENAME_EXCHANGE) == 0);
+    }
+    if (!renamed && errno != ENOENT) {
+        MMKVError("fail on renameat2() [%s] to [%s], %d(%s)", srcPath.c_str(), dstPath.c_str(), errno, strerror(errno));
+    }
+#endif // SYS_renameat2
+
+    if (!renamed) {
+        if (::rename(srcPath.c_str(), dstPath.c_str()) != 0) {
+            MMKVError("fail to rename [%s] to [%s], %d(%s)", srcPath.c_str(), dstPath.c_str(), errno, strerror(errno));
+            return false;
+        }
+    }
+
+    ::unlink(srcPath.c_str());
+    return true;
+}
+
+// do it by sendfile()
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool needTruncate) {
+    if (dstFD < 0) {
+        return false;
+    }
+    File srcFile(srcPath, OpenFlag::ReadOnly);
+    if (!srcFile.isFileValid()) {
+        return false;
+    }
+    auto srcFileSize = srcFile.getActualFileSize();
+
+    lseek(dstFD, 0, SEEK_SET);
+    auto writtenSize = ::sendfile(dstFD, srcFile.getFd(), nullptr, srcFileSize);
+    auto ret = (writtenSize == srcFileSize);
+    if (!ret) {
+        if (writtenSize < 0) {
+            MMKVError("fail to sendfile() %s to fd[%d], %d(%s)", srcPath.c_str(), dstFD, errno, strerror(errno));
+        } else {
+            MMKVError("sendfile() %s to fd[%d], written %lld < %zu", srcPath.c_str(), dstFD, writtenSize, srcFileSize);
+        }
+    } else if (needTruncate) {
+        size_t dstFileSize = 0;
+        getFileSize(dstFD, dstFileSize);
+        if ((dstFileSize != srcFileSize) && (::ftruncate(dstFD, static_cast<off_t>(srcFileSize)) != 0)) {
+            MMKVError("fail to truncate [%d] to size [%zu], %d(%s)", dstFD, srcFileSize, errno, strerror(errno));
+            ret = false;
+        }
+    }
+
+    if (ret) {
+        MMKVInfo("copy content from %s to fd[%d] finish", srcPath.c_str(), dstFD);
+    }
+    return ret;
+}
+
+} // namespace mmkv
+
+#endif // defined(MMKV_ANDROID) || defined(MMKV_LINUX)

package/MMKV/Core/MemoryFile_OSX.cpp

@@ -0,0 +1,142 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2019 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * 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 "MemoryFile.h"
+#include "MMKVLog.h"
+
+#ifdef MMKV_IOS
+
+using namespace std;
+
+namespace mmkv {
+
+void tryResetFileProtection(const string &path) {
+    @autoreleasepool {
+        NSString *nsPath = [NSString stringWithUTF8String:path.c_str()];
+        NSDictionary *attr = [[NSFileManager defaultManager] attributesOfItemAtPath:nsPath error:nullptr];
+        NSString *protection = [attr valueForKey:NSFileProtectionKey];
+        MMKVInfo("protection on [%@] is %@", nsPath, protection);
+        if ([protection isEqualToString:NSFileProtectionCompleteUntilFirstUserAuthentication] == NO) {
+            NSMutableDictionary *newAttr = [NSMutableDictionary dictionaryWithDictionary:attr];
+            [newAttr setObject:NSFileProtectionCompleteUntilFirstUserAuthentication forKey:NSFileProtectionKey];
+            NSError *err = nil;
+            [[NSFileManager defaultManager] setAttributes:newAttr ofItemAtPath:nsPath error:&err];
+            if (err != nil) {
+                MMKVError("fail to set attribute %@ on [%@]: %@", NSFileProtectionCompleteUntilFirstUserAuthentication,
+                          nsPath, err);
+            }
+        }
+    }
+}
+
+} // namespace mmkv
+
+#endif // MMKV_IOS
+
+#ifdef MMKV_APPLE
+
+#include <copyfile.h>
+#include <mach/mach_time.h>
+
+namespace mmkv {
+
+bool tryAtomicRename(const char *src, const char *dst) {
+    bool renamed = false;
+
+    // try atomic swap first
+    if (@available(iOS 10.0, watchOS 3.0, *)) {
+        // renameat2() equivalent
+        if (renamex_np(src, dst, RENAME_SWAP) == 0) {
+            renamed = true;
+        } else if (errno != ENOENT) {
+            MMKVError("fail to renamex_np %s to %s, %s", src, dst, strerror(errno));
+        }
+    }
+
+    if (!renamed) {
+        // try old style rename
+        if (rename(src, dst) != 0) {
+            MMKVError("fail to rename %s to %s, %s", src, dst, strerror(errno));
+            return false;
+        }
+    }
+
+    unlink(src);
+
+    return true;
+}
+
+bool copyFile(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    // prepare a temp file for atomic rename, avoid data corruption of suddent crash
+    NSString *uniqueFileName = [NSString stringWithFormat:@"mmkv_%llu", mach_absolute_time()];
+    NSString *tmpFile = [NSTemporaryDirectory() stringByAppendingPathComponent:uniqueFileName];
+    if (copyfile(srcPath.c_str(), tmpFile.UTF8String, nullptr, COPYFILE_UNLINK | COPYFILE_CLONE) != 0) {
+        MMKVError("fail to copyfile [%s] to [%s], %s", srcPath.c_str(), tmpFile.UTF8String, strerror(errno));
+        return false;
+    }
+    MMKVInfo("copyfile [%s] to [%s]", srcPath.c_str(), tmpFile.UTF8String);
+
+    if (tryAtomicRename(tmpFile.UTF8String, dstPath.c_str())) {
+        MMKVInfo("copyfile [%s] to [%s] finish.", srcPath.c_str(), dstPath.c_str());
+        return true;
+    }
+    unlink(tmpFile.UTF8String);
+    return false;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    File dstFile(dstPath, OpenFlag::WriteOnly | OpenFlag::Create | OpenFlag::Truncate);
+    if (!dstFile.isFileValid()) {
+        return false;
+    }
+    if (copyFileContent(srcPath, dstFile.getFd())) {
+        MMKVInfo("copy content from %s to fd[%s] finish", srcPath.c_str(), dstPath.c_str());
+        return true;
+    }
+    MMKVError("fail to copyfile(): target file %s", dstPath.c_str());
+    return false;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD) {
+    if (dstFD < 0) {
+        return false;
+    }
+
+    File srcFile(srcPath, OpenFlag::ReadOnly);
+    if (!srcFile.isFileValid()) {
+        return false;
+    }
+
+    // sendfile() equivalent
+    if (::fcopyfile(srcFile.getFd(), dstFD, nullptr, COPYFILE_ACL | COPYFILE_STAT | COPYFILE_XATTR | COPYFILE_DATA) == 0) {
+        MMKVInfo("copy content from %s to fd[%d] finish", srcPath.c_str(), dstFD);
+        return true;
+    }
+    MMKVError("fail to copyfile(): %d(%s), source file %s", errno, strerror(errno), srcPath.c_str());
+    return false;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool needTruncate) {
+    return copyFileContent(srcPath, dstFD);
+}
+
+} // namespace mmkv
+
+#endif // MMKV_APPLE