Fix ERROR_HANDLE_NO_LONGER_VALID (0x1A9F) Transaction Handle

Quick answer for advanced users: Open the file handle inside the transaction block, not before TmCommitTransaction. The handle becomes invalid once the transaction is committed or rolled back.

What you’re seeing — 0x00001A9F — is Windows telling you the handle you’re trying to use was tied to a Kernel Transaction Manager (KTM) transaction that already ended. This happens in transactional file systems (TxF) or databases that use KTM under the hood. You opened a handle, started a transaction, did some work, then committed the transaction. After that, the handle is garbage. Windows invalidates it to prevent you from accidentally writing stale data outside the transaction’s atomic scope.

The trigger is almost always a pattern like this: CreateFile() → TmBeginTransaction() → WriteFile() → TmCommitTransaction() → WriteFile(). That last WriteFile hits 0x1A9F because the handle no longer belongs to a transaction. The kernel explicitly breaks the binding.

Fix Steps

1. Identify where the handle is opened. Look for CreateFile or NtCreateFile calls. If they’re outside the TmBeginTransaction / TmCommitTransaction block, that’s your bug.
2. Move the handle open inside the transaction. Call TmBeginTransaction first, then open the handle, do your I/O, commit, and close the handle. The handle is only valid for the duration of that transaction.
3. If you can’t move the open call (shared handle, library constraints), use TmEnableCallbacks to reopen the handle after each commit. Terrible for performance, but it works.
4. Close the old handle after commit with CloseHandle. Don’t keep it lying around — it’s dead memory.
5. Test with a minimal repro: Open handle → begin transaction → write → commit → try to read. You’ll hit 0x1A9F instantly. Then fix the code order.

Alternative Fix (When You Can’t Change the Code)

If you’re dealing with a third-party library or driver that opens handles outside your control, you can wrap each transaction-bound operation in its own scope:

HANDLE hFile = CreateFile(...);
// Don't use hFile here for transactional writes outside a transaction
for (int i = 0; i < nOps; i++) {
    HANDLE hTx = CreateTransaction(NULL, 0, 0, 0, 0, 0, NULL);
    HANDLE hTxFile = CreateFileTransacted(..., hTx);
    // Write to hTxFile
    CommitTransaction(hTx);
    CloseHandle(hTxFile);
    CloseHandle(hTx);
}
CloseHandle(hFile);

But honestly, just restructure the code. The transactional handle model isn’t optional — it’s how TxF enforces atomicity.

Prevention Tip

Set a clear rule in your code: no handle survives a transaction commit. If you need persistent access, open a non-transactional handle separately. And test against a real transactional volume (NTFS with TxF enabled) — not a RAM disk. The kernel behaves differently on actual disk.