react-native-mmkv 2.0.0 → 2.0.1

package/MMKV/Core/MemoryFile_Android.cpp

@@ -41,23 +41,42 @@ extern int ASharedMemory_create(const char *name, size_t size);
 extern size_t ASharedMemory_getSize(int fd);
 extern string ASharedMemory_getName(int fd);
 
-MemoryFile::MemoryFile(const string &path, size_t size, FileType fileType)
-    : m_name(path), m_fd(-1), m_ptr(nullptr), m_size(0), m_fileType(fileType) {
+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) {
-        reloadFromFile();
+        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_name.c_str();
+        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 (m_fd >= 0) {
+        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);
@@ -67,13 +86,12 @@ MemoryFile::MemoryFile(const string &path, size_t size, FileType fileType)
 }
 
 MemoryFile::MemoryFile(int ashmemFD)
-    : m_name(""), m_fd(ashmemFD), m_ptr(nullptr), m_size(0), m_fileType(MMFILE_TYPE_ASHMEM) {
-    if (m_fd < 0) {
-        MMKVError("fd %d invalid", m_fd);
+    : 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_name = ASharedMemory_getName(m_fd);
-        m_size = ASharedMemory_getSize(m_fd);
-        MMKVInfo("ashmem name:%s, size:%zu", m_name.c_str(), m_size);
+        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);
@@ -90,13 +108,14 @@ MemoryFile::MemoryFile(int ashmemFD)
 namespace mmkv {
 
 constexpr auto ASHMEM_NAME_LEN = 256;
-constexpr auto __ASHMEMIOC = 0x77;
-#    define ASHMEM_SET_NAME _IOW(__ASHMEMIOC, 1, char[ASHMEM_NAME_LEN])
-#    define ASHMEM_GET_NAME _IOR(__ASHMEMIOC, 2, char[ASHMEM_NAME_LEN])
-#    define ASHMEM_SET_SIZE _IOW(__ASHMEMIOC, 3, size_t)
-#    define ASHMEM_GET_SIZE _IO(__ASHMEMIOC, 4)
+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";
@@ -171,7 +190,7 @@ 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 >= 29) {
+    if (g_android_api >= __ANDROID_API_Q__) {
         return "";
     }
 
@@ -180,7 +199,7 @@ string ASharedMemory_getName(int fd) {
         MMKVError("fail to get ashmem name:%d, %s", fd, strerror(errno));
         return "";
     }
-    return string(name);
+    return {name};
 }
 
 } // namespace mmkv

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

@@ -19,11 +19,10 @@
  */
 
 #include "MemoryFile.h"
+#include "MMKVLog.h"
 
 #ifdef MMKV_IOS
 
-#    include "MMKVLog.h"
-
 using namespace std;
 
 namespace mmkv {
@@ -50,3 +49,94 @@ void tryResetFileProtection(const string &path) {
 } // 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