非 UI 内核

buffer->length = (int32_t)round_page(length);
// Temporarily allocate twice the length, so we have the contiguous address space to
// support a second instance of the buffer directly after
vm_address_t bufferAddress;
kern_return_t result = vm_allocate(mach_task_self(),
                                   &bufferAddress,
                                   buffer->length * 2,
                                   VM_FLAGS_ANYWHERE);
result = vm_deallocate(mach_task_self(),
                       bufferAddress + buffer->length,
                       buffer->length);
// Re-map the buffer to the address space immediately after the buffer
vm_address_t virtualAddress = bufferAddress + buffer->length;
vm_prot_t cur_prot, max_prot;
result = vm_remap(mach_task_self(),
                  &virtualAddress,
                  buffer->length,
                  0,
                  0,
                  mach_task_self(),
                  bufferAddress,
                  0,
                  &cur_prot,
                  &max_prot,
                  VM_INHERIT_DEFAULT);

/// Whether this connection may delete the database to recover from an error.
/// Only the owning read-write connection (the main app) may do so.
let removeDatabaseOnError: Bool
static let openFailureWipeThreshold = 3
private static func openFailuresPath(databasePath: String) -> String {
    return databasePath + "-open-failures"
}
static func shouldWipeAfterOpenFailure(
    databasePath: String, systemErrno: Int32
) -> Bool {
    guard shouldCountOpenFailure(systemErrno: systemErrno) else {
        return false
    }
    let failures = self.consecutiveOpenFailures(databasePath: databasePath) + 1
    let _ = try? Data(String(failures).utf8).write(
        to: URL(fileURLWithPath: self.openFailuresPath(databasePath: databasePath)),
        options: .atomic
    )
    return failures >= self.openFailureWipeThreshold
}
static func removeDatabaseFiles(databasePath: String) {
    for suffix in ["", "-shm", "-wal", "-open-failures"] {
        let _ = try? FileManager.default.removeItem(atPath: databasePath + suffix)
    }
}

/// arm64e signs return addresses stored on the stack.
inline uintptr_t strippedPointer(uintptr_t value) {
#if __has_feature(ptrauth_calls)
    return (uintptr_t)ptrauth_strip((void *)value, ptrauth_key_return_address);
#else
    return value & 0x000000ffffffffffULL;
#endif
}
int walkStack(thread_t thread, uintptr_t stackLow, uintptr_t stackHigh,
              uintptr_t *frames) {
    arm_thread_state64_t state;
    mach_msg_type_number_t stateCount = ARM_THREAD_STATE64_COUNT;
    if (thread_get_state(thread, ARM_THREAD_STATE64,
                         (thread_state_t)&state, &stateCount) != KERN_SUCCESS) {
        return 0;
    }
    const uintptr_t pc = (uintptr_t)arm_thread_state64_get_pc(state);
    const uintptr_t lr = strippedPointer((uintptr_t)arm_thread_state64_get_lr(state));
    uintptr_t framePointer = (uintptr_t)arm_thread_state64_get_fp(state);
    if (framePointer < stackLow ||
        framePointer + 2 * sizeof(uintptr_t) > stackHigh) {
        break;
    }
    const uintptr_t returnAddress = strippedPointer(
        *(uintptr_t *)(framePointer + sizeof(uintptr_t)));

private let notificationKeyDisposable = MetaDisposable()
private let pollDisposable = MetaDisposable()
// Handler creation is, for practical purposes, when the system's ~30 s extension
// budget started ticking; the connection deadline on the poll path counts from here.
private let startTimestamp = CFAbsoluteTimeGetCurrent()

init?(queue: Queue, episode: String, updateCurrentContent: @escaping (NotificationContent) -> Void,
      completed: @escaping () -> Void, requestIdentifier: String,
      payload: [AnyHashable: Any]) {
    self.queue = queue

    // In the extension, database BEGIN/COMMIT/step failures must crash (the system then
    // falls back to displaying the unmodified push) instead of failing silently: silent
    // failures under cross-process lock contention produce non-atomic writes and pin the
    // account state, turning the difference polling loop into an infinite livelock.
    setValueBoxStrictErrorHandling(true)

var identity: FileIdentity?
var isAdditionalLink = false
if value.st_nlink > 1 {
    let fileIdentity = FileIdentity(
        device: UInt64(UInt32(bitPattern: value.st_dev)),
        inode: UInt64(value.st_ino)
    )
    identity = fileIdentity
    isAdditionalLink = !seenLinkedInodes.insert(fileIdentity).inserted
}

if isAdditionalLink {
    if performSizeMapping, let identity = identity {
        tempDatabase.addLink(pathBuffer: pathBuffer,
                             pathSize: strnlen(pathBuffer, 1024),
                             identity: identity)
    }
} else {
    result.totalSize += UInt64(value.st_size)
    if performSizeMapping {
        tempDatabase.add(pathBuffer: pathBuffer,
                         pathSize: strnlen(pathBuffer, 1024),
                         size: Int64(value.st_size),
                         timestamp: scanTimestamp(value.st_mtimespec.tv_sec),
                         identity: identity)

private func createTable(database: Database, table: ValueBoxTable) {
    switch table.keyType {
    case .binary:
        var createStatement =
            "CREATE TABLE IF NOT EXISTS t\(table.id) (key BLOB PRIMARY KEY, value BLOB)"
        if table.compactValuesOnCreation {
            createStatement += " WITHOUT ROWID"
        }
        let resultCode = database.execute(createStatement)
        assert(resultCode)
    }
}
if let statement = self.getStatements[table.id] {
    resultStatement = statement
} else {
    var statement: OpaquePointer? = nil
    let status = sqlite3_prepare_v3(self.database.handle,
        "SELECT value FROM t\(table.id) WHERE key=?", -1,
        SQLITE_PREPARE_PERSISTENT, &statement, nil)
    precondition(status == SQLITE_OK)
    let preparedStatement = SqlitePreparedStatement(statement: statement)
    self.getStatements[table.id] = preparedStatement
    resultStatement = preparedStatement
}
resultStatement.reset()

if !self.useCaches {
    resultCode = database.execute("PRAGMA cache_size=32")
    assert(resultCode)
}
resultCode = database.execute("PRAGMA mmap_size=0")
assert(resultCode)
resultCode = database.execute("PRAGMA synchronous=NORMAL")
assert(resultCode)
resultCode = database.execute("PRAGMA temp_store=MEMORY")
assert(resultCode)
resultCode = database.execute("PRAGMA journal_mode=WAL")
assert(resultCode)
resultCode = database.execute("PRAGMA cipher_memory_security = OFF")
assert(resultCode)

self.pageSize = Int(self.runPragma(database, "page_size"))
// ...
let _ = self.runPragma(database, "checkpoint_fullfsync = 1")
assert(self.runPragma(database, "checkpoint_fullfsync") == "1")

if (proxySettings != nil &&
    (proxySettings.secret != nil || proxySettings.webProxy)) {
    // An MTProxy chooses the datacenter from the obfuscated header and a WEB relay
    // ignores the address it is handed, so every probe through either lands in the
    // same place: N of them carry exactly the information of one.
    MTDatacenterAddress *chosen = nil;
    for (MTDatacenterAddress *address in bestAddressList) {
        if (![self isIpv6:address.ip]) {
            chosen = address;
            break;
        }
    }
    if (chosen == nil) {
        chosen = bestAddressList.firstObject;
    }
    return chosen == nil ? @[] : @[chosen];
}
+ (NSArray<NSNumber *> *)alternatePortsForProxySettings:
    (MTSocksProxySettings *)proxySettings {
    if (proxySettings != nil) {
        return @[];
    }
    return @[@80, @5222];
}

+ (void)_startBackoffRoundOf:(MTSignal *)signal
                       delay:(NSTimeInterval)delay
                    maxDelay:(NSTimeInterval)maxDelay
                       queue:(MTQueue *)queue
                  subscriber:(MTSubscriber *)subscriber
           currentDisposable:(MTMetaDisposable *)currentDisposable
                  isDisposed:(MTAtomic *)isDisposed {
    if ([[isDisposed value] boolValue]) {
        return;
    }
    NSTimeInterval nextDelay = MIN(delay * 2.0, maxDelay);
    MTSignal *round = [signal then:[[MTSignal complete] delay:delay onQueue:queue]];
    // The recursion happens from the delay timer's completion, so it never grows the stack.
    [currentDisposable setDisposable:[round startWithNext:^(id next) {
        [subscriber putNext:next];
    } error:^(id error) {
        [subscriber putError:error];
    } completed:^{
        [self _startBackoffRoundOf:signal delay:nextDelay maxDelay:maxDelay
            queue:queue subscriber:subscriber
            currentDisposable:currentDisposable isDisposed:isDisposed];
    }]];
}

override func serviceExtensionTimeWillExpire() {
    // Releasing impl deallocates the handler on its queue, which disposes the in-flight
    // poll (getDifference/state replay) and drops the keep-alive network connection.
    // Without this, that work keeps running after the system takes back control and
    // continues to consume CPU for as long as the extension process stays alive.
    self.impl = nil

    if let contentHandler = self.contentHandler {
        self.contentHandler = nil

        Logger.shared.log("NotificationService \(self.episode ?? \"???\")",
                          "Completing due to serviceExtensionTimeWillExpire")

        if let content = self.content.with({ $0 }) {
            contentHandler(content.generate())
        } else if let initialContent = self.initialContent {
            contentHandler(initialContent)
        }
    }
}

public init(name: String? = nil, qos: DispatchQoS = .default) {
    self.nativeQueue = DispatchQueue(label: name ?? "", qos: qos)
    self.specialIsMainQueue = false
    self.nativeQueue.setSpecific(key: QueueSpecificKey, value: self.specific)
}

public func isCurrent() -> Bool {
    if DispatchQueue.getSpecific(key: QueueSpecificKey) === self.specific {
        return true
    } else if self.specialIsMainQueue && Thread.isMainThread {
        return true
    } else {
        return false
    }
}

public func async(_ f: @escaping () -> Void) {
    if self.isCurrent() {
        f()
    } else {
        self.nativeQueue.async(execute: f)
    }
}

private func isLocked(passcodeSettings: PresentationPasscodeSettings,
                      state: LockState) -> Bool {
    if state.isManuallyLocked {
        return true
    } else if let autolockTimeout = passcodeSettings.autolockTimeout {
        var bootTimestamp: Int32 = 0
        let uptime = getDeviceUptimeSeconds(&bootTimestamp)
        let timestamp = MonotonicTimestamp(bootTimestamp: bootTimestamp,
                                           uptime: uptime)

        let applicationActivityTimestamp = state.applicationActivityTimestamp

        if let applicationActivityTimestamp = applicationActivityTimestamp {
            if timestamp.bootTimestamp != applicationActivityTimestamp.bootTimestamp {
                return true
            }
            if timestamp.uptime >= applicationActivityTimestamp.uptime + autolockTimeout {
                return true
            }
        } else {
            return true
        }
    }
    return false
}

let sharedKey = self.key(MessageIndex(
    id: MessageId(peerId: PeerId(0), namespace: 0, id: 0), timestamp: 0
))
let sharedBuffer = WriteBuffer()
let sharedEncoder = PostboxEncoder()
var outputOperations: [MessageHistoryOperation] = []
var accumulatedRemoveIndices: [(MessageIndex)] = []
var accumulatedAddedIncomingMessageIndices = Set<MessageIndex>()
var updatedCombinedState: CombinedPeerReadState?
var invalidateReadState = false

let commitAccumulatedAddedIndices: () -> Void = {
    if !accumulatedAddedIncomingMessageIndices.isEmpty {
        let (combinedState, invalidate) = self.readStateTable.addIncomingMessages(
            peerId, indices: accumulatedAddedIncomingMessageIndices
        )
        if let combinedState = combinedState {
            updatedCombinedState = combinedState
        }
        if invalidate {
            invalidateReadState = true
        }
        accumulatedAddedIncomingMessageIndices.removeAll()
    }
}

# Since Xcode 26 the Metal toolchain is an optional download that only works while
# its cryptex DMG is mounted at /Volumes/MetalToolchainCryptex.
# Xcode remounts it lazily, which races when bazel starts ~17 MetalCompile actions.
# Mounting it once, serially, before bazel runs removes the race.
guest_build_sh = '''
    set -x
    set -e

    if [ ! -d /Volumes/MetalToolchainCryptex ]; then
        METAL_DMG="$(ls -t /System/Library/AssetsV2/com_apple_MobileAsset_MetalToolchain/*.asset/AssetData/Restore/*.dmg 2>/dev/null | head -n 1)"
        if [ -n "$METAL_DMG" ]; then
            hdiutil attach "$METAL_DMG" -mountpoint /Volumes/MetalToolchainCryptex -nobrowse -quiet || true
        fi
    fi
    METAL_REAL=/Volumes/MetalToolchainCryptex/Metal.xctoolchain/usr/bin/metal
    if [ -x "$METAL_REAL" ] && ! xcrun metal --version >/dev/null 2>&1; then
        sudo ln -sf "$METAL_REAL" "$(xcode-select -p)/Toolchains/XcodeDefault.xctoolchain/usr/bin/metal" || true
    fi
    xcrun metal --version || true
    xcrun -f metallib || true
'''

for source in module["sources"] + module.get("hdrs", []) + module.get("textual_hdrs", []):
    # Process all sources (both regular and generated) with symlinks
    if source.startswith("bazel-out/"):
        if module["path"] in source:
            source_file_name = source[source.index(module["path"]) + len(module["path"]) + 1:]
        else:
            print("Source {} is not inside module path {}".format(source, module["path"]))
            sys.exit(1)
    else:
        if not source.startswith(module["path"]):
            print("Source {} is not inside module path {}".format(source, module["path"]))
            sys.exit(1)
        source_file_name = source[len(module["path"]) + 1:]

    symlink_location = os.path.join(module_directory, source_file_name)
    symlink_parent = os.path.dirname(symlink_location)
    create_spm_directory(symlink_parent)

    num_parent_dirs = symlink_location.count(os.path.sep)
    relative_prefix = "".join(["../"] * num_parent_dirs)
    symlink_target = relative_prefix + source
    link_spm_file(symlink_target, symlink_location)