CHROMIUM: verity: pull up maybe_read_entry

drivers/md/dm-verity.c

 /*
  * Originally based on dm-crypt.c,
  * Copyright (C) 2003 Christophe Saout <christophe@saout.de>
  * Copyright (C) 2004 Clemens Fruhwirth <clemens@endorphin.org>
  * Copyright (C) 2006-2008 Red Hat, Inc. All rights reserved.
  * Copyright (C) 2010 The Chromium OS Authors <chromium-os-dev@chromium.org>
  *                    All Rights Reserved.
  *
  * This file is released under the GPL.
  *
@@ skipping 101 matching lines @@
 struct verity_stats {
         unsigned int io_queue;
         unsigned int verify_queue;
         unsigned int average_requeues;
         unsigned int total_requeues;
         unsigned long long total_requests;
 };
 
 /* per-requested-bio private data */
 enum verity_io_flags {
-        VERITY_IOFLAGS_PENDING = 0x1,   /* pending hash read bios */
-        VERITY_IOFLAGS_CLONED = 0x2,    /* original bio has been cloned */
+        VERITY_IOFLAGS_CLONED = 0x1,    /* original bio has been cloned */
 };
 
 struct dm_verity_io {
         struct dm_target *target;
         struct bio *bio;
         struct delayed_work work;
         unsigned int flags;
 
         int error;
         atomic_t pending;
@@ skipping 457 matching lines @@
 
         DMDEBUG("dec pending %p: %d--", io, atomic_read(&io->pending));
 
         if (!atomic_dec_and_test(&io->pending))
                 goto done;
 
         if (unlikely(io->error))
                 goto io_error;
 
         /* I/Os that were pending may now be ready */
-        if ((io->flags & VERITY_IOFLAGS_PENDING) &&
-            !verity_is_bht_populated(io)) {
-                io->flags &= ~VERITY_IOFLAGS_PENDING;
-                INIT_DELAYED_WORK(&io->work, kverityd_io);
-                queue_delayed_work(vc->io_queue, &io->work, HZ/10);
-                verity_stats_total_requeues_inc(vc);
-                REQTRACE("Block %llu+ is being requeued for io (io:%p)",
-                         ULL(io->block), io);
-        } else {
-                io->flags &= ~VERITY_IOFLAGS_PENDING;
+        if (verity_is_bht_populated(io)) {
                 verity_stats_io_queue_dec(vc);
                 verity_stats_verify_queue_inc(vc);
                 INIT_DELAYED_WORK(&io->work, kverityd_verify);
                 queue_delayed_work(vc->verify_queue, &io->work, 0);
                 REQTRACE("Block %llu+ is being queued for verify (io:%p)",
                          ULL(io->block), io);
+        } else {
+                INIT_DELAYED_WORK(&io->work, kverityd_io);
+                queue_delayed_work(vc->io_queue, &io->work, HZ/10);
+                verity_stats_total_requeues_inc(vc);
+                REQTRACE("Block %llu+ is being requeued for io (io:%p)",
+                         ULL(io->block), io);
         }
 
 done:
         return;
 
 io_error:
         verity_return_bio_to_caller(io);
 }
 
 /* Walks the data set and computes the hash of the data read from the
@@ skipping 151 matching lines @@
          */
         DMDEBUG("Submitting bht io %p (entry:%p)", io, entry);
         generic_make_request(bio);
         return 0;
 }
 
 /* Performs the work of loading in any missing bht hashes. */
 static void kverityd_io_bht_populate(struct dm_verity_io *io)
 {
         struct verity_config *vc = io->target->private;
-        int populated = 0;
-        int io_status = 0;
         sector_t count;
 
         /* Submits an io request for each missing block of block hashes.
          * The last one to return will then enqueue this on the
          * io workqueue.
          */
         REQTRACE("populating %llu starting at block %llu (io:%p)",
                  ULL(io->count), ULL(io->block), io);
         for (count = 0; count < io->count; ++count) {
                 unsigned int block = (unsigned int)(io->block + count);
+                int populated;
+
                 /* Check for truncation. */
                 VERITY_BUG_ON((sector_t)(block) < io->block);
                 /* populate for each block */
                 DMDEBUG("Calling dm_bht_populate for %u (io:%p)", block, io);
                 populated = dm_bht_populate(&vc->bht, io, block);
                 if (populated < 0) {
                         DMCRIT("dm_bht_populate error for block %u (io:%p): %d",
                                block, io, populated);
                         /* TODO(wad) support propagating transient errors
                          *           cleanly.
                          */
                         /* verity_dec_pending will handle the error case. */
                         io->error = -EPERM;
                         break;
                 }
-                /* Accrue view of all I/O state for the full request */
-                io_status |= populated;
         }
         REQTRACE("Block %llu+ initiated %d requests (io: %p)",
                  ULL(io->block), atomic_read(&io->pending) - 1, io);
 
-        if (io_status & DM_BHT_ENTRY_REQUESTED) {
-                /* If no data is pending another I/O request, this io
-                 * will get bounced on the next queue when the last async call
-                 * returns.
-                 */
-                DMDEBUG("io has outstanding requests %p");
-        }
-
-        /* Some I/O is pending outside of this request. */
-        if (io_status & DM_BHT_ENTRY_PENDING) {
-                /* PENDING will cause a BHT requeue as delayed work */
-                /* TODO(wad) add a callback to dm-bht for pending_cb. Then for
-                 * each entry, the io could be delayed heavily until the end
-                 * read cb requeue them. (entries could be added to the
-                 * stored I/O context but races could be a challenge.
-                 */
-                DMDEBUG("io is pending %p");
-                io->flags |= VERITY_IOFLAGS_PENDING;
-        }
-
         /* If I/O requests were issues on behalf of populate, then the last
          * request will result in a requeue.  If all data was pending from
          * other requests, this will be requeued now.
          */
 }
 
 /* Asynchronously called upon the completion of I/O issued
  * from kverityd_src_io_read. verity_dec_pending() acts as
  * the scheduler/flow manager.
  */
@@ skipping 484 matching lines @@
         dm_unregister_target(&verity_target);
         kmem_cache_destroy(_verity_io_pool);
 }
 
 module_init(dm_verity_init);
 module_exit(dm_verity_exit);
 
 MODULE_AUTHOR("The Chromium OS Authors <chromium-os-dev@chromium.org>");
 MODULE_DESCRIPTION(DM_NAME " target for transparent disk integrity checking");
 MODULE_LICENSE("GPL");