Method copyFile

switch/source/io.cpp:237–381

}

Result io::copyFile(const std::string& srcPath, const std::string& dstPath, ProgressSink& sink, u64 commitWriteLimit, u64* bytesCopied, u32* crcOut)
{
    FILE* src = fopen(srcPath.c_str(), "rb");
    if (src == NULL) {
        Logging::error("Failed to open source file {} during copy with errno {}.", srcPath, errno);
        return RES_COPY_FAILED;
    }
    fseek(src, 0, SEEK_END);
    u64 sz = ftell(src);
    rewind(src);

    const bool toSaveDevice = dstPath.rfind("save:/", 0) == 0;

    // Create the destination at its final size instead of letting it grow one
    // write at a time. Every extending write on the save filesystem has to find
    // and chain a free block, so an append-grown tree of tens of thousands of
    // files both fragments and gets slower as the save fills.
    bool preallocated = false;
    if (toSaveDevice && sz > 0) {
        const Result cr = fsdevCreateFile(dstPath.c_str(), (size_t)sz, 0);
        if (R_SUCCEEDED(cr)) {
            preallocated = true;
        }
        else {
            Logging::debug("Preallocating {} at {} bytes failed with result 0x{:08X}; growing it by writes instead.", dstPath, sz, (u32)cr);
        }
    }

    // "wb" truncates, which would throw the preallocation away: an already-sized
    // file has to be opened for update instead.
    FILE* dst = fopen(dstPath.c_str(), preallocated ? "r+b" : "wb");
    if (dst == NULL) {
        Logging::error("Failed to open destination file {} during copy with errno {}.", dstPath, errno);
        fclose(src);
        return RES_COPY_FAILED;
    }

    u8* buf    = new u8[BUFFER_SIZE];
    u64 offset = 0;
    u32 crc    = 0;
    Result res = 0;

    size_t slashpos = srcPath.rfind("/");
    sink.startFile(srcPath.substr(slashpos + 1, srcPath.length() - slashpos - 1), sz);

    // The save journal only holds `commitWriteLimit` bytes of uncommitted writes:
    // a single file bigger than that must be committed partway through, or the
    // commit at the end would overflow the journal and fail (#443, #297).
    u64 journalPending = 0;

    while (offset < sz) {
        if (sink.cancelled()) {
            break;
        }

        size_t count = fread((char*)buf, 1, BUFFER_SIZE, src);
        if (count == 0) {
            Logging::error("fread returned 0 for file {} at offset {}/{} with errno {}. Aborting copy.", srcPath, offset, sz, errno);