```cpp
// mmZeroCopy.hpp --Zero means zero disturb
#pragma once
#include <Windows.h>
#include <dbt.h>

#include <string>
#include <expected>
#include <system_error>

class mmZeroCopy {
using zeroCopy_r = std::expected<void, std::error_code>;
   public:
    mmZeroCopy(HWND hWnd);
    ~mmZeroCopy() { cleanup(); };

    // · The caller is responsible to handle ERROR_SHARING_VIOLATION
    //   by remembering the obstacle file
    //   and to register other errors with retry limit
    zeroCopy_r copy(std::wstring_view filePath);

    // · This is public because you may need this to stop correctly
    //   while asyncIO is running. Normally, just cleanup()
    void abortCopy();
    void cleanup();

   private:
    static DWORD WINAPI asyncCleanup(void* self);

    void ovCopy();
    zeroCopy_r ovCopyResultReceiver{};
    static DWORD WINAPI asyncOvCopy(void* self);

    HWND hWnd_{nullptr};
    HDEVNOTIFY hDevNotify_{nullptr};
    std::wstring_view filePath_{};
    DWORD dbcvUnitMask_{0};
    HANDLE hFile_{INVALID_HANDLE_VALUE};
};
```
---
```cpp
// mmZeroCopy.cpp
#include "mmZeroCopy.h"
#include "mmLog.hpp"

mmZeroCopy::mmZeroCopy(HWND hWnd) : hWnd_(hWnd) {
    DEV_BROADCAST_VOLUME dbcvFilter{};
    dbcvFilter.dbcv_size = sizeof(dbcvFilter);
    dbcvFilter.dbcv_devicetype = DBT_DEVTYP_VOLUME;

    hDevNotify_ = ::RegisterDeviceNotificationW(hWnd_, &dbcvFilter,
        DEVICE_NOTIFY_WINDOW_HANDLE);
    if (!hDevNotify_) {
        MM_E("RegisterDeviceNotification Error: {}", mmLog::last_error());
        throw std::runtime_error("mmZeroCopy: init failed");
    }
}

mmZeroCopy::zeroCopy_r mmZeroCopy::copy(std::wstring_view filePath) {
    filePath_ = filePath;

    TCHAR drive = filePath[0];
    dbcvUnitMask_ = 1u << (drive - TEXT('A'));

    hFile_ = ::CreateFileW(
        std::format(L"\\\\?\\{}", filePath).c_str(),
        GENERIC_READ,
        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
        nullptr,
        OPEN_EXISTING,
        FILE_FLAG_OVERLAPPED,
        nullptr);

    if (hFile_ == INVALID_HANDLE_VALUE) {
        auto e = ::GetLastError();
        MM_F("CreateFile {} Error: {} ({})", filePath, mmLog::Logger::win32_message(e), e);
        return std::unexpected { std::error_code(e, std::system_category()) };
    }

    auto t = CreateThread(nullptr, 0, asyncOvCopy, this, 0, nullptr);  // Do I really need to copy it on another thread? I mean, after all, I'm still waiting after this. Am I silly, or not?
    WaitForSingleObject(t, INFINITE);  // Will it cause abortCopy() and cleanup() called by other threads blocked?
    if (ovCopyResultReceiver.error())  // Am I right here? Or is the whole thing (ovCopyResultReceiver) trying to communicate here not the best way?
        return ovCopyResultReceiver;

    return {};
}

void mmZeroCopy::abortCopy() {
    if (hFile_ != INVALID_HANDLE_VALUE) {
        CancelIoEx(hFile_, nullptr);
        CloseHandle(hFile_);
        hFile_ = INVALID_HANDLE_VALUE;
    }
    CreateThread(nullptr, 0, asyncCleanup, this, 0, nullptr);
}

void mmZeroCopy::cleanup() {
    ...
}

DWORD WINAPI mmZeroCopy::asyncCleanup(void* self) {
    ((mmZeroCopy*)self)->cleanup();
    return 0;
}

void mmZeroCopy::ovCopy() {

    ...

        ovCopyResultReceiver = std::unexpected{std::error_code(e, std::system_category())};
}

DWORD WINAPI mmZeroCopy::asyncOvCopy(void* self) {
    ((mmZeroCopy*)self)->ovCopy();
}
```
---

INSTRUCTION
**Above is a usb driver file copying system(which, obviously, lacks a dst param now) for Windows using C++, not blocking the ejection at any time. It now has parts for you to complete(not only the '...') and maybe refactor(where you think needs to). Also, create a caller main.cpp demo for this, capable of handling multiple drivers. (Assume 'mmLog.hpp' is already completed, MM_E for error log, _F for fatal...)**