@nxtedition/rocksdb 15.4.1 → 16.0.0

package/deps/rocksdb/rocksdb/db_stress_tool/no_batched_ops_stress.cc

@@ -234,8 +234,9 @@ class NonBatchedOpsStressTest : public StressTest {
 
           Status s = secondary_db_->TryCatchUpWithPrimary();
 #ifndef NDEBUG
-          uint64_t manifest_num = static_cast_with_check<DBImpl>(secondary_db_)
-                                      ->TEST_Current_Manifest_FileNo();
+          uint64_t manifest_num =
+              static_cast_with_check<DBImpl>(secondary_db_.get())
+                  ->TEST_Current_Manifest_FileNo();
 #else
           uint64_t manifest_num = 0;
 #endif
@@ -542,7 +543,10 @@ class NonBatchedOpsStressTest : public StressTest {
         }
         std::unique_ptr<Iterator> iter(
             secondary_db_->NewIterator(read_opts, handle));
-        uint32_t rnd = (thread->rand.Next()) % 4;
+        // Skip SeekToFirst, SeekToLast, SeekForPrev, and Prev when backward
+        // scan is disabled.
+        uint32_t rnd =
+            (!FLAGS_test_backward_scan) ? 2 : (thread->rand.Next()) % 4;
         if (0 == rnd) {
           // SeekToFirst() + Next()*5
           read_opts.total_order_seek = true;
@@ -1904,6 +1908,11 @@ class NonBatchedOpsStressTest : public StressTest {
     } while (!s.ok() && IsErrorInjectedAndRetryable(s) &&
              initial_wal_write_may_succeed);
 
+    if (IsExpectedTxnError(s)) {
+      pending_expected_value.Rollback();
+      return Status::OK();
+    }
+
     if (!s.ok()) {
       pending_expected_value.Rollback();
       if (IsErrorInjectedAndRetryable(s)) {
@@ -2004,6 +2013,11 @@ class NonBatchedOpsStressTest : public StressTest {
       } while (!s.ok() && IsErrorInjectedAndRetryable(s) &&
                initial_wal_write_may_succeed);
 
+      if (IsExpectedTxnError(s)) {
+        pending_expected_value.Rollback();
+        return Status::OK();
+      }
+
       if (!s.ok()) {
         pending_expected_value.Rollback();
         if (IsErrorInjectedAndRetryable(s)) {
@@ -2071,6 +2085,11 @@ class NonBatchedOpsStressTest : public StressTest {
       } while (!s.ok() && IsErrorInjectedAndRetryable(s) &&
                initial_wal_write_may_succeed);
 
+      if (IsExpectedTxnError(s)) {
+        pending_expected_value.Rollback();
+        return Status::OK();
+      }
+
       if (!s.ok()) {
         pending_expected_value.Rollback();
         if (IsErrorInjectedAndRetryable(s)) {
@@ -2644,76 +2663,78 @@ class NonBatchedOpsStressTest : public StressTest {
       op_logs += "N";
     }
 
-    // backward scan
-    key_str = Key(ub - 1);
-    iter->SeekForPrev(key_str);
+    // backward scan — skip when backward iteration is not supported
+    if (FLAGS_test_backward_scan) {
+      key_str = Key(ub - 1);
+      iter->SeekForPrev(key_str);
 
-    op_logs += " SFP " + Slice(key_str).ToString(true) + " ";
+      op_logs += " SFP " + Slice(key_str).ToString(true) + " ";
 
-    last_key = ub;
-    while (true) {
-      assert(lb < last_key);
+      last_key = ub;
+      while (true) {
+        assert(lb < last_key);
 
-      if (iter->Valid() && ro.allow_unprepared_value) {
-        op_logs += "*";
+        if (iter->Valid() && ro.allow_unprepared_value) {
+          op_logs += "*";
 
-        if (!iter->PrepareValue()) {
-          assert(!iter->Valid());
-          assert(!iter->status().ok());
+          if (!iter->PrepareValue()) {
+            assert(!iter->Valid());
+            assert(!iter->status().ok());
+          }
         }
-      }
 
-      if (!iter->Valid()) {
-        if (!iter->status().ok()) {
-          if (IsErrorInjectedAndRetryable(iter->status())) {
-            return iter->status();
-          } else {
-            thread->shared->SetVerificationFailure();
-            fprintf(stderr, "TestIterate against expected state error: %s\n",
-                    iter->status().ToString().c_str());
-            fprintf(stderr, "Column family: %s, op_logs: %s\n",
-                    cfh->GetName().c_str(), op_logs.c_str());
-            thread->stats.AddErrors(1);
-            return iter->status();
+        if (!iter->Valid()) {
+          if (!iter->status().ok()) {
+            if (IsErrorInjectedAndRetryable(iter->status())) {
+              return iter->status();
+            } else {
+              thread->shared->SetVerificationFailure();
+              fprintf(stderr, "TestIterate against expected state error: %s\n",
+                      iter->status().ToString().c_str());
+              fprintf(stderr, "Column family: %s, op_logs: %s\n",
+                      cfh->GetName().c_str(), op_logs.c_str());
+              thread->stats.AddErrors(1);
+              return iter->status();
+            }
           }
+          if (!check_no_key_in_range(lb, last_key)) {
+            return Status::OK();
+          }
+          break;
         }
-        if (!check_no_key_in_range(lb, last_key)) {
+
+        if (!check_columns()) {
           return Status::OK();
         }
-        break;
-      }
-
-      if (!check_columns()) {
-        return Status::OK();
-      }
 
-      // the range (current key, last key) was skipped
-      GetIntVal(iter->key().ToString(), &curr);
-      if (last_key <= static_cast<int64_t>(curr)) {
-        thread->shared->SetVerificationFailure();
-        fprintf(stderr,
-                "TestIterateAgainstExpected failed: found unexpectedly large "
-                "key\n");
-        fprintf(stderr, "Column family: %s, op_logs: %s\n",
-                cfh->GetName().c_str(), op_logs.c_str());
-        fprintf(stderr, "Last op found key: %s, expected at most: %s\n",
-                Slice(Key(curr)).ToString(true).c_str(),
-                Slice(Key(last_key - 1)).ToString(true).c_str());
-        thread->stats.AddErrors(1);
-        return Status::OK();
-      }
-      if (!check_no_key_in_range(static_cast<int64_t>(curr + 1), last_key)) {
-        return Status::OK();
-      }
+        // the range (current key, last key) was skipped
+        GetIntVal(iter->key().ToString(), &curr);
+        if (last_key <= static_cast<int64_t>(curr)) {
+          thread->shared->SetVerificationFailure();
+          fprintf(stderr,
+                  "TestIterateAgainstExpected failed: found unexpectedly large "
+                  "key\n");
+          fprintf(stderr, "Column family: %s, op_logs: %s\n",
+                  cfh->GetName().c_str(), op_logs.c_str());
+          fprintf(stderr, "Last op found key: %s, expected at most: %s\n",
+                  Slice(Key(curr)).ToString(true).c_str(),
+                  Slice(Key(last_key - 1)).ToString(true).c_str());
+          thread->stats.AddErrors(1);
+          return Status::OK();
+        }
+        if (!check_no_key_in_range(static_cast<int64_t>(curr + 1), last_key)) {
+          return Status::OK();
+        }
 
-      last_key = static_cast<int64_t>(curr);
-      if (last_key <= lb) {
-        break;
-      }
+        last_key = static_cast<int64_t>(curr);
+        if (last_key <= lb) {
+          break;
+        }
 
-      iter->Prev();
+        iter->Prev();
 
-      op_logs += "P";
+        op_logs += "P";
+      }
     }
 
     // Write-prepared/write-unprepared transactions and multi-CF iterator do not
@@ -2755,7 +2776,8 @@ class NonBatchedOpsStressTest : public StressTest {
     key_str = Key(mid);
     const Slice key(key_str);
 
-    if (thread->rand.OneIn(2)) {
+    // Skip SeekForPrev and Prev when backward scan is not supported.
+    if (!FLAGS_test_backward_scan || thread->rand.OneIn(2)) {
       iter->Seek(key);
       op_logs += " S " + key.ToString(true) + " ";
       if (!iter->Valid() && iter->status().ok()) {
@@ -2824,8 +2846,14 @@ class NonBatchedOpsStressTest : public StressTest {
         iter->Next();
         op_logs += "N";
       } else if (static_cast<int64_t>(curr) >= ub) {
-        iter->Prev();
-        op_logs += "P";
+        // Use Next when backward scan is not supported.
+        if (!FLAGS_test_backward_scan) {
+          iter->Next();
+          op_logs += "N";
+        } else {
+          iter->Prev();
+          op_logs += "P";
+        }
       } else {
         const uint32_t value_base_from_db = GetValueBase(iter->value());
         std::size_t index = static_cast<std::size_t>(curr - lb);
@@ -2852,7 +2880,7 @@ class NonBatchedOpsStressTest : public StressTest {
           break;
         }
 
-        if (thread->rand.OneIn(2)) {
+        if (!FLAGS_test_backward_scan || thread->rand.OneIn(2)) {
           iter->Next();
           op_logs += "N";
           if (!iter->Valid()) {
@@ -3197,15 +3225,7 @@ class NonBatchedOpsStressTest : public StressTest {
           assert(false);
       }
 
-      // It is possible that multiple thread concurrently try to write to the
-      // same key, which could cause lock timeout or deadlock in the
-      // transactiondb layer, before transaction is rolled back.
-      // E.g.
-      // Timestamp 1: Transaction A: lock key M for write
-      // Timestamp 2: Transaction B: lock key N for write
-      // Timestamp 3: Transaction B: try to lock key M for write -> wait
-      // Timestamp 4: Transaction A: try to lock key N for write -> deadlock
-      if (s.IsTimedOut() || s.IsDeadlock()) {
+      if (IsExpectedTxnError(s)) {
         return;
       }
 

package/deps/rocksdb/rocksdb/env/env.cc

@@ -27,6 +27,7 @@
 #include "rocksdb/utilities/object_registry.h"
 #include "rocksdb/utilities/options_type.h"
 #include "util/autovector.h"
+#include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
 namespace {

package/deps/rocksdb/rocksdb/env/env_test.cc

@@ -41,6 +41,9 @@
 #include "env/env_chroot.h"
 #include "env/env_encryption_ctr.h"
 #include "env/fs_readonly.h"
+#if defined(ROCKSDB_IOURING_PRESENT)
+#include "env/io_posix.h"
+#endif
 #include "env/mock_env.h"
 #include "env/unique_id_gen.h"
 #include "logging/log_buffer.h"
@@ -2505,7 +2508,7 @@ TEST_P(EnvFSTestWithParam, OptionsTest) {
     }
   }
   for (int i = 0; i < 2; ++i) {
-    DB* db;
+    std::unique_ptr<DB> db;
     Status s = DB::Open(opts, dbname, &db);
     ASSERT_OK(s);
 
@@ -2523,7 +2526,7 @@ TEST_P(EnvFSTestWithParam, OptionsTest) {
     ASSERT_EQ("b", val);
 
     ASSERT_OK(db->Close());
-    delete db;
+    db.reset();
     ASSERT_OK(DestroyDB(dbname, opts));
 
     dbname = dbname2_;
@@ -3725,6 +3728,366 @@ TEST_F(TestAsyncRead, InterleavingIOUringOperations) {
 #endif
 }
 
+// Helper function to run AbortIO test with parameterized read requests.
+// Each request is specified as {offset, length}.
+// use_direct_io: if true, opens the file with O_DIRECT to bypass page cache.
+// iterations: number of times to repeat the test (useful for race conditions).
+void TestAbortIOWithRequests(
+    Env* env, size_t file_size,
+    const std::vector<std::pair<uint64_t, size_t>>& read_specs,
+    bool use_direct_io = false, int iterations = 1) {
+#if defined(ROCKSDB_IOURING_PRESENT)
+  fprintf(stderr,
+          "TestAbortIOWithRequests: file_size=%zu, num_reads=%zu, "
+          "direct_io=%d, iterations=%d\n",
+          file_size, read_specs.size(), use_direct_io, iterations);
+  std::shared_ptr<FileSystem> fs = env->GetFileSystem();
+  std::string fname = test::PerThreadDBPath(env, "testfile_abortio");
+
+  // 1. Create test file once (content doesn't change between iterations)
+  {
+    std::unique_ptr<FSWritableFile> wfile;
+    FileOptions file_opts;
+    file_opts.use_direct_writes = true;
+    ASSERT_OK(fs->NewWritableFile(fname, file_opts, &wfile, nullptr));
+
+    // Query the file's required buffer alignment (logical block size)
+    // instead of hardcoding 4096, to support devices with different
+    // sector sizes.
+    size_t sector_size = wfile->GetRequiredBufferAlignment();
+
+    // Round up to full sectors for direct IO writes
+    size_t num_sectors = (file_size + sector_size - 1) / sector_size;
+    for (size_t i = 0; i < num_sectors; ++i) {
+      auto data = NewAligned(sector_size, static_cast<char>(i + 1));
+      Slice slice(data.get(), sector_size);
+      ASSERT_OK(wfile->Append(slice, IOOptions(), nullptr));
+    }
+
+    // Truncate to exact file size if not aligned to sector boundary
+    if (file_size % sector_size != 0) {
+      ASSERT_OK(wfile->Truncate(file_size, IOOptions(), nullptr));
+    }
+
+    ASSERT_OK(wfile->Close(IOOptions(), nullptr));
+  }
+
+  for (int iter = 0; iter < iterations; iter++) {
+    // 2. Submit ReadAsync requests and immediately abort
+    {
+      FileOptions file_opts;
+      file_opts.use_direct_reads = use_direct_io;
+      std::unique_ptr<FSRandomAccessFile> file;
+      ASSERT_OK(fs->NewRandomAccessFile(fname, file_opts, &file, nullptr));
+
+      const size_t num_reads = read_specs.size();
+      IOOptions opts;
+      std::vector<void*> io_handles(num_reads);
+      std::vector<FSReadRequest> reqs(num_reads);
+      std::vector<std::unique_ptr<char, Deleter>> data;
+      std::vector<size_t> vals;
+      IOHandleDeleter del_fn;
+      std::atomic<int> callbacks_invoked{0};
+
+      // Initialize read requests from specs
+      for (size_t i = 0; i < num_reads; i++) {
+        reqs[i].offset = read_specs[i].first;
+        reqs[i].len = read_specs[i].second;
+        data.emplace_back(NewAligned(reqs[i].len, 0));
+        reqs[i].scratch = data.back().get();
+        vals.push_back(i);
+      }
+
+      // Callback
+      std::function<void(FSReadRequest&, void*)> callback =
+          [&](FSReadRequest& req, void* cb_arg) {
+            size_t i = *(reinterpret_cast<size_t*>(cb_arg));
+            reqs[i].status = req.status;
+            callbacks_invoked++;
+          };
+
+      // Submit all ReadAsync requests
+      for (size_t i = 0; i < num_reads; i++) {
+        void* cb_arg = static_cast<void*>(&(vals[i]));
+        IOStatus s = file->ReadAsync(reqs[i], opts, callback, cb_arg,
+                                     &(io_handles[i]), &del_fn, nullptr);
+        if (s.IsNotSupported()) {
+          // io_uring not supported, clean up and skip
+          fprintf(stderr,
+                  "WARNING: io_uring not supported, skipping test: %s\n",
+                  s.ToString().c_str());
+          for (size_t j = 0; j < i; j++) {
+            if (io_handles[j]) {
+              del_fn(io_handles[j]);
+            }
+          }
+          ASSERT_OK(fs->DeleteFile(fname, IOOptions(), nullptr));
+          return;
+        }
+        ASSERT_OK(s);
+      }
+
+      // Immediately call AbortIO - this should NOT hang
+      ASSERT_OK(fs->AbortIO(io_handles));
+
+      // Verify all handles are finished and all callbacks were invoked.
+      // Since all handles are passed to AbortIO, every handle is guaranteed
+      // to be finalized (either completed or cancelled).
+      for (size_t i = 0; i < num_reads; i++) {
+        Posix_IOHandle* h = static_cast<Posix_IOHandle*>(io_handles[i]);
+        ASSERT_TRUE(h->is_finished);
+      }
+      ASSERT_EQ(callbacks_invoked.load(), static_cast<int>(num_reads));
+
+      // Clean up handles
+      for (size_t i = 0; i < num_reads; i++) {
+        if (io_handles[i]) {
+          del_fn(io_handles[i]);
+        }
+      }
+    }
+  }
+
+  ASSERT_OK(fs->DeleteFile(fname, IOOptions(), nullptr));
+
+  fprintf(stderr, "TestAbortIOWithRequests: completed %d iterations\n",
+          iterations);
+#else
+  fprintf(stderr,
+          "TestAbortIOWithRequests: SKIPPED (ROCKSDB_IOURING_PRESENT not "
+          "defined)\n");
+  (void)env;
+  (void)file_size;
+  (void)read_specs;
+  (void)use_direct_io;
+  (void)iterations;
+#endif
+}
+
+// Test overlapping reads at aligned offsets (multiples of 4KB)
+TEST_F(TestAsyncRead, AbortIOOverlappingAligned) {
+  // 4 reads of 16KB each, overlapping by 8KB, all at 4KB-aligned offsets
+  // Read 0: [0, 16KB), Read 1: [8KB, 24KB), Read 2: [16KB, 32KB), Read 3:
+  // [24KB, 40KB)
+  std::vector<std::pair<uint64_t, size_t>> specs = {
+      {0, 16384},
+      {8192, 16384},
+      {16384, 16384},
+      {24576, 16384},
+  };
+  TestAbortIOWithRequests(env_, 64 * 1024, specs);
+}
+
+// Test reads at unaligned offsets (not multiples of 4KB)
+TEST_F(TestAsyncRead, AbortIOUnalignedOffsets) {
+  // Reads starting at non-4KB-aligned offsets
+  std::vector<std::pair<uint64_t, size_t>> specs = {
+      {1000, 8192},    // starts at 1000 (unaligned)
+      {5000, 12288},   // starts at 5000 (unaligned), spans multiple sectors
+      {15000, 8192},   // starts at 15000 (unaligned)
+      {25500, 16384},  // starts at 25500 (unaligned)
+  };
+  TestAbortIOWithRequests(env_, 64 * 1024, specs);
+}
+
+// Test mix of aligned and unaligned, various sizes
+TEST_F(TestAsyncRead, AbortIOMixedOffsets) {
+  std::vector<std::pair<uint64_t, size_t>> specs = {
+      {0, 4096},       // aligned, 1 sector
+      {1500, 8192},    // unaligned, 2 sectors
+      {4096, 20480},   // aligned, 5 sectors
+      {7000, 4096},    // unaligned, spans 2 sectors
+      {16384, 32768},  // aligned, 8 sectors
+      {50000, 8192},   // unaligned
+  };
+  TestAbortIOWithRequests(env_, 128 * 1024, specs);
+}
+
+// Stress test with many concurrent handles
+TEST_F(TestAsyncRead, AbortIOStress) {
+  std::vector<std::pair<uint64_t, size_t>> specs;
+  // 16 overlapping reads with mixed alignment
+  for (int i = 0; i < 16; i++) {
+    uint64_t offset = i * 4000;          // Not aligned to 4KB
+    size_t len = 8192 + (i % 4) * 4096;  // 8KB to 20KB
+    specs.emplace_back(offset, len);
+  }
+  TestAbortIOWithRequests(env_, 256 * 1024, specs);
+}
+
+// Regression test for a fixed bug in AbortIO where out-of-order io_uring
+// completions could cause an infinite hang. The bug occurred when completions
+// for a different handle arrived while waiting for the current handle - the
+// code would consume those completions but not mark the handle as finished,
+// causing a hang when later iterating to that handle.
+//
+// Uses a large read (1MB) followed by a small read (4KB) with Direct I/O to
+// maximize the chance of out-of-order completions. Runs 100 iterations to
+// increase the likelihood of triggering the race condition.
+TEST_F(TestAsyncRead, AbortIOReversedHandles) {
+  // Request 0: LARGE (1MB) at offset 0
+  // Request 1: SMALL (4KB) at offset 1MB
+  std::vector<std::pair<uint64_t, size_t>> specs = {
+      {0, 1024 * 1024},     // 1MB read
+      {1024 * 1024, 4096},  // 4KB read at 1MB offset
+  };
+  // 2MB file, Direct I/O enabled, 100 iterations
+  TestAbortIOWithRequests(env_, 2 * 1024 * 1024, specs,
+                          /*use_direct_io=*/true, /*iterations=*/100);
+}
+
+// Test for bug fix: AbortIO with partial handles should correctly handle
+// completions for non-aborted handles.
+//
+// Previously, AbortIO would consume completions for non-aborted handles but
+// not set is_finished (since it expected req_count==2 for all handles).
+// This caused subsequent Poll calls to hang forever.
+//
+// The fix correctly detects handles not in the abort set and finalizes them
+// immediately when their completion arrives (at req_count==1).
+TEST_F(TestAsyncRead, AbortIOPartialHandlesBug) {
+#if defined(ROCKSDB_IOURING_PRESENT)
+  std::shared_ptr<FileSystem> fs = env_->GetFileSystem();
+  std::string fname = test::PerThreadDBPath(env_, "testfile_abortio_partial");
+
+  constexpr size_t kSectorSize = 4096;
+  constexpr size_t kFileSize = 2 * 1024 * 1024;  // 2MB
+
+  // 1. Create test file with direct I/O
+  {
+    std::unique_ptr<FSWritableFile> wfile;
+    FileOptions file_opts;
+    file_opts.use_direct_writes = true;
+    ASSERT_OK(fs->NewWritableFile(fname, file_opts, &wfile, nullptr));
+
+    size_t num_sectors = kFileSize / kSectorSize;
+    for (size_t i = 0; i < num_sectors; ++i) {
+      auto data = NewAligned(kSectorSize, static_cast<char>(i + 1));
+      Slice slice(data.get(), kSectorSize);
+      ASSERT_OK(wfile->Append(slice, IOOptions(), nullptr));
+    }
+    ASSERT_OK(wfile->Close(IOOptions(), nullptr));
+  }
+
+  // 2. Submit 3 ReadAsync requests, abort only the first one, then Poll the
+  // rest
+  {
+    FileOptions file_opts;
+    file_opts.use_direct_reads = true;
+    std::unique_ptr<FSRandomAccessFile> file;
+    ASSERT_OK(fs->NewRandomAccessFile(fname, file_opts, &file, nullptr));
+
+    IOOptions opts;
+    constexpr size_t kNumReads = 3;
+    std::vector<void*> io_handles(kNumReads);
+    std::vector<FSReadRequest> reqs(kNumReads);
+    std::vector<std::unique_ptr<char, Deleter>> data;
+    std::vector<size_t> vals;
+    IOHandleDeleter del_fn;
+    std::atomic<int> callbacks_invoked{0};
+
+    // H0: 1MB read, H1: 4KB read, H2: 4KB read
+    std::vector<std::pair<uint64_t, size_t>> read_specs = {
+        {0, 1024 * 1024},            // H0: 1MB at offset 0
+        {1024 * 1024, 4096},         // H1: 4KB at offset 1MB
+        {1024 * 1024 + 4096, 4096},  // H2: 4KB at offset 1MB+4KB
+    };
+
+    for (size_t i = 0; i < kNumReads; i++) {
+      reqs[i].offset = read_specs[i].first;
+      reqs[i].len = read_specs[i].second;
+      data.emplace_back(NewAligned(reqs[i].len, 0));
+      reqs[i].scratch = data.back().get();
+      vals.push_back(i);
+    }
+
+    std::function<void(FSReadRequest&, void*)> callback =
+        [&](FSReadRequest& req, void* cb_arg) {
+          size_t i = *(reinterpret_cast<size_t*>(cb_arg));
+          reqs[i].status = req.status;
+          callbacks_invoked++;
+        };
+
+    // Submit all ReadAsync requests
+    for (size_t i = 0; i < kNumReads; i++) {
+      void* cb_arg = static_cast<void*>(&(vals[i]));
+      IOStatus s = file->ReadAsync(reqs[i], opts, callback, cb_arg,
+                                   &(io_handles[i]), &del_fn, nullptr);
+      if (s.IsNotSupported()) {
+        // io_uring not supported, clean up and skip
+        for (size_t j = 0; j < i; j++) {
+          if (io_handles[j]) {
+            del_fn(io_handles[j]);
+          }
+        }
+        ASSERT_OK(fs->DeleteFile(fname, IOOptions(), nullptr));
+        return;
+      }
+      ASSERT_OK(s);
+    }
+
+    // Wait for reads to complete in io_uring (completions in queue but not
+    // consumed). 5 seconds should be plenty for direct I/O reads to complete.
+    std::this_thread::sleep_for(std::chrono::seconds(5));
+
+    // Abort ONLY H0 - this will consume all completions but should correctly
+    // finalize H1 and H2 (since they're not in the abort set).
+    std::vector<void*> abort_handles = {io_handles[0]};
+    ASSERT_OK(fs->AbortIO(abort_handles));
+
+    // Verify H0 is finished (aborted)
+    Posix_IOHandle* h0 = static_cast<Posix_IOHandle*>(io_handles[0]);
+    ASSERT_TRUE(h0->is_finished);
+    ASSERT_EQ(h0->req_count, 2u);  // original + cancel
+
+    // Note: H1 and H2 may or may not be finished at this point. AbortIO
+    // finalizes non-aborted handles whose CQEs arrive while waiting for
+    // aborted handles, but CQE ordering is non-deterministic. If H0's
+    // completions arrived first, H1/H2's CQEs are still in the queue.
+    // Poll handles either case correctly.
+
+    // Poll on H1, H2 - completes them if not already finalized by AbortIO
+    std::vector<void*> poll_handles = {io_handles[1], io_handles[2]};
+
+    // Use a watchdog to detect hang (regression test for the original bug
+    // where AbortIO consumed non-aborted CQEs without finalizing them)
+    std::atomic<bool> poll_completed{false};
+    std::thread watchdog([&]() {
+      for (int i = 0; i < 500; i++) {  // 5 seconds timeout
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        if (poll_completed) return;
+      }
+      // Bug regression: Poll hung
+      _exit(1);
+    });
+
+    fs->Poll(poll_handles, poll_handles.size());
+    poll_completed = true;
+    watchdog.join();
+
+    // After Poll, H1 and H2 must be finished
+    Posix_IOHandle* h1 = static_cast<Posix_IOHandle*>(io_handles[1]);
+    Posix_IOHandle* h2 = static_cast<Posix_IOHandle*>(io_handles[2]);
+    ASSERT_TRUE(h1->is_finished);
+    ASSERT_TRUE(h2->is_finished);
+
+    // Verify all callbacks were invoked
+    ASSERT_EQ(callbacks_invoked.load(), 3);
+
+    // Clean up handles
+    for (size_t i = 0; i < kNumReads; i++) {
+      if (io_handles[i]) {
+        del_fn(io_handles[i]);
+      }
+    }
+  }
+
+  ASSERT_OK(fs->DeleteFile(fname, IOOptions(), nullptr));
+#else
+  (void)env_;  // Suppress unused variable warning
+#endif
+}
+
 struct StaticDestructionTester {
   bool activated = false;
   ~StaticDestructionTester() {