t_status is a process-wide global on Apple platforms, so concurrent writes to two encrypted instances can lose every key #1698

// Minimal reproduction: on Apple platforms, MMKV's `t_status` is one process-wide global instead of a
// thread_local, so encrypted writes to different MMKV instances on different threads corrupt each other.
//
// Core/MMKV_IO.cpp:
//     // for Apple watch simulator
//     #    if defined(TARGET_OS_SIMULATOR) && defined(TARGET_CPU_X86)
//     static AESCryptStatus t_status;
//     #    else
//     thread_local AESCryptStatus t_status;
//     #    endif
// <TargetConditionals.h> defines both macros, as 0 or 1, on every Apple platform, so the `static` branch is
// always taken.
//
// Each replay:
//   1. creates encrypted store A with three keys and closes it, so the next open loads A from the file;
//   2. reopens A, and starts three threads that keep writing values of 300-3300 bytes to three other
//      encrypted stores;
//   3. overwrites a 769-byte value in A and reads it back;
//   4. stops the writers, deletes that key, and reloads A from the file with clearMemoryCache.
// Expected: the read-back matches, and the reload finds the other two keys, unchanged.
//
//   tstatus_race [replays] [verbose]
// Exits 1 if any replay went wrong. `verbose` turns on MMKV's info log, which shows the failing reload:
//   InvalidProtocolBuffer truncatedMessage
//   loaded [store.a] with 0 key-values

#import <Foundation/Foundation.h>
#import "MMKV.h"
#include <atomic>
#include <cstdio>
#include <cstdlib>
#include <thread>
#include <unistd.h>
#include <vector>

static NSData *makeData(NSUInteger length, uint8_t seed) {
    NSMutableData *data = [NSMutableData dataWithLength:length];
    auto *bytes = (uint8_t *) data.mutableBytes;
    for (NSUInteger i = 0; i < length; i++) {
        bytes[i] = (uint8_t) (seed + i * 13);
    }
    return data;
}

static NSData *makeKey(uint8_t seed) {
    return makeData(16, seed);
}

int main(int argc, const char *argv[]) {
    @autoreleasepool {
        int replays = argc > 1 ? atoi(argv[1]) : 200;
        bool verbose = argc > 2 && strcmp(argv[2], "verbose") == 0;
        NSString *root = [NSTemporaryDirectory()
            stringByAppendingPathComponent:[NSString stringWithFormat:@"tstatus_race.%d", getpid()]];
        [MMKV initializeMMKV:root logLevel:verbose ? MMKVLogInfo : MMKVLogNone];

        NSData *small = makeData(32, 1);
        NSData *large = makeData(4000, 2);
        int garbled = 0, emptied = 0, damaged = 0;

        for (int replay = 0; replay < replays; replay++) {
            @autoreleasepool {
                NSString *dir = [root stringByAppendingPathComponent:[NSString stringWithFormat:@"%d", replay]];

                // 1. Store A with three keys, closed so that the next open loads it from the file.
                MMKV *a = [MMKV mmkvWithID:@"store.a" cryptKey:makeKey(100) rootPath:dir];
                [a setData:small forKey:@"small"];
                [a setData:large forKey:@"large"];
                [a setData:makeData(769, 3) forKey:@"value"];
                [a close];
                a = [MMKV mmkvWithID:@"store.a" cryptKey:makeKey(100) rootPath:dir];

                // 2. Three other encrypted stores, each written on its own thread.
                std::atomic<bool> stop{false};
                std::vector<std::thread> writers;
                NSMutableArray<MMKV *> *others = [NSMutableArray array];
                for (int i = 0; i < 3; i++) {
                    MMKV *other = [MMKV mmkvWithID:[NSString stringWithFormat:@"store.other.%d", i]
                                          cryptKey:makeKey((uint8_t) (i + 1))
                                          rootPath:dir];
                    [others addObject:other];
                    writers.emplace_back([&stop, other] {
                        unsigned n = 0;
                        while (!stop.load()) {
                            @autoreleasepool {
                                [other setData:makeData(300 + (n * 977) % 3000, (uint8_t) n)
                                        forKey:[NSString stringWithFormat:@"k%u", n % 40]];
                                n++;
                            }
                        }
                    });
                }
                usleep(1000); // the race needs the writers to be running already

                // 3. Overwrite a large value in A and read it back.
                NSData *value = makeData(769, 4);
                [a setData:value forKey:@"value"];
                if (![[a getDataForKey:@"value"] isEqualToData:value]) {
                    garbled++;
                }

                stop = true;
                for (auto &writer : writers) {
                    writer.join();
                }
                for (MMKV *other in others) {
                    [other close];
                }

                // 4. Delete that key, then reload A from the file.
                [a removeValueForKey:@"value"];
                [a clearMemoryCache];
                NSSet *keys = [NSSet setWithArray:a.allKeys];
                if (keys.count == 0) {
                    emptied++;
                } else if (![keys isEqualToSet:[NSSet setWithObjects:@"small", @"large", nil]] ||
                           ![[a getDataForKey:@"small"] isEqualToData:small] ||
                           ![[a getDataForKey:@"large"] isEqualToData:large]) {
                    damaged++;
                }
                [a close];
            }
        }
        [[NSFileManager defaultManager] removeItemAtPath:root error:nil];

        printf("%d replays: %d garbled read-backs, %d reloads with 0 keys, %d other damaged reloads\n", replays,
               garbled, emptied, damaged);
        bool ok = garbled == 0 && emptied == 0 && damaged == 0;
        printf("%s\n", ok ? "PASS" : "FAIL");
        return ok ? 0 : 1;
    }
}