Merge branch 'for-jens' of git://git.drbd.org/linux-drbd into for-3.6/drivers

12 files changed, 159 insertions, 73 deletions

diff --git a/drivers/block/drbd/drbd_actlog.c b/drivers/block/drbd/drbd_actlog.c
index e54e31b02b88..3fbef018ce55 100644
--- a/drivers/block/drbd/drbd_actlog.c
+++ b/drivers/block/drbd/drbd_actlog.c
@@ -411,7 +411,7 @@ w_al_write_transaction(struct drbd_conf *mdev, struct drbd_work *w, int unused)
                 + mdev->ldev->md.al_offset + mdev->al_tr_pos;
 
         if (!drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE))
-                drbd_chk_io_error(mdev, 1, true);
+                drbd_chk_io_error(mdev, 1, DRBD_META_IO_ERROR);
 
         if (++mdev->al_tr_pos >
             div_ceil(mdev->act_log->nr_elements, AL_EXTENTS_PT))
@@ -876,7 +876,11 @@ int __drbd_set_out_of_sync(struct drbd_conf *mdev, sector_t sector, int size,
         unsigned int enr, count = 0;
         struct lc_element *e;
 
-        if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_BIO_SIZE) {
+        /* this should be an empty REQ_FLUSH */
+        if (size == 0)
+                return 0;
+
+        if (size < 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_BIO_SIZE) {
                 dev_err(DEV, "sector: %llus, size: %d\n",
                         (unsigned long long)sector, size);
                 return 0;
diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
index fcb956bb4b4c..ba91b408abad 100644
--- a/drivers/block/drbd/drbd_bitmap.c
+++ b/drivers/block/drbd/drbd_bitmap.c
@@ -1096,7 +1096,7 @@ static int bm_rw(struct drbd_conf *mdev, int rw, unsigned flags, unsigned lazy_w
 
         if (ctx->error) {
                 dev_alert(DEV, "we had at least one MD IO ERROR during bitmap IO\n");
-                drbd_chk_io_error(mdev, 1, true);
+                drbd_chk_io_error(mdev, 1, DRBD_META_IO_ERROR);
                 err = -EIO; /* ctx->error ? */
         }
 
@@ -1212,7 +1212,7 @@ int drbd_bm_write_page(struct drbd_conf *mdev, unsigned int idx) __must_hold(loc
         wait_until_done_or_disk_failure(mdev, mdev->ldev, &ctx->done);
 
         if (ctx->error)
-                drbd_chk_io_error(mdev, 1, true);
+                drbd_chk_io_error(mdev, 1, DRBD_META_IO_ERROR);
                 /* that should force detach, so the in memory bitmap will be
                  * gone in a moment as well. */
 
diff --git a/drivers/block/drbd/drbd_int.h b/drivers/block/drbd/drbd_int.h
index 02f013a073a7..b2ca143d0053 100644
--- a/drivers/block/drbd/drbd_int.h
+++ b/drivers/block/drbd/drbd_int.h
@@ -813,7 +813,6 @@ enum {
         SIGNAL_ASENDER,         /* whether asender wants to be interrupted */
         SEND_PING,              /* whether asender should send a ping asap */
 
-        UNPLUG_QUEUED,          /* only relevant with kernel 2.4 */
         UNPLUG_REMOTE,          /* sending a "UnplugRemote" could help */
         MD_DIRTY,               /* current uuids and flags not yet on disk */
         DISCARD_CONCURRENT,     /* Set on one node, cleared on the peer! */
@@ -824,7 +823,6 @@ enum {
         CRASHED_PRIMARY,        /* This node was a crashed primary.
                                  * Gets cleared when the state.conn
                                  * goes into C_CONNECTED state. */
-        NO_BARRIER_SUPP,        /* underlying block device doesn't implement barriers */
         CONSIDER_RESYNC,
 
         MD_NO_FUA,              /* Users wants us to not use FUA/FLUSH on meta data dev */
@@ -834,6 +832,7 @@ enum {
         BITMAP_IO_QUEUED,       /* Started bitmap IO */
         GO_DISKLESS,            /* Disk is being detached, on io-error or admin request. */
         WAS_IO_ERROR,           /* Local disk failed returned IO error */
+        FORCE_DETACH,           /* Force-detach from local disk, aborting any pending local IO */
         RESYNC_AFTER_NEG,       /* Resync after online grow after the attach&negotiate finished. */
         NET_CONGESTED,          /* The data socket is congested */
 
@@ -851,6 +850,13 @@ enum {
         AL_SUSPENDED,           /* Activity logging is currently suspended. */
         AHEAD_TO_SYNC_SOURCE,   /* Ahead -> SyncSource queued */
         STATE_SENT,             /* Do not change state/UUIDs while this is set */
+
+        CALLBACK_PENDING,       /* Whether we have a call_usermodehelper(, UMH_WAIT_PROC)
+                                 * pending, from drbd worker context.
+                                 * If set, bdi_write_congested() returns true,
+                                 * so shrink_page_list() would not recurse into,
+                                 * and potentially deadlock on, this drbd worker.
+                                 */
 };
 
 struct drbd_bitmap; /* opaque for drbd_conf */
@@ -1130,8 +1136,8 @@ struct drbd_conf {
         int rs_in_flight; /* resync sectors in flight (to proxy, in proxy and from proxy) */
         int rs_planed;    /* resync sectors already planned */
         atomic_t ap_in_flight; /* App sectors in flight (waiting for ack) */
-        int peer_max_bio_size;
-        int local_max_bio_size;
+        unsigned int peer_max_bio_size;
+        unsigned int local_max_bio_size;
 };
 
 static inline struct drbd_conf *minor_to_mdev(unsigned int minor)
@@ -1435,9 +1441,9 @@ struct bm_extent {
  * hash table. */
 #define HT_SHIFT 8
 #define DRBD_MAX_BIO_SIZE (1U<<(9+HT_SHIFT))
-#define DRBD_MAX_BIO_SIZE_SAFE (1 << 12)       /* Works always = 4k */
+#define DRBD_MAX_BIO_SIZE_SAFE (1U << 12)       /* Works always = 4k */
 
-#define DRBD_MAX_SIZE_H80_PACKET (1 << 15) /* The old header only allows packets up to 32Kib data */
+#define DRBD_MAX_SIZE_H80_PACKET (1U << 15) /* The old header only allows packets up to 32Kib data */
 
 /* Number of elements in the app_reads_hash */
 #define APP_R_HSIZE 15
@@ -1840,12 +1846,20 @@ static inline int drbd_request_state(struct drbd_conf *mdev,
         return _drbd_request_state(mdev, mask, val, CS_VERBOSE + CS_ORDERED);
 }
 
+enum drbd_force_detach_flags {
+        DRBD_IO_ERROR,
+        DRBD_META_IO_ERROR,
+        DRBD_FORCE_DETACH,
+};
+
 #define __drbd_chk_io_error(m,f) __drbd_chk_io_error_(m,f, __func__)
-static inline void __drbd_chk_io_error_(struct drbd_conf *mdev, int forcedetach, const char *where)
+static inline void __drbd_chk_io_error_(struct drbd_conf *mdev,
+                enum drbd_force_detach_flags forcedetach,
+                const char *where)
 {
         switch (mdev->ldev->dc.on_io_error) {
         case EP_PASS_ON:
-                if (!forcedetach) {
+                if (forcedetach == DRBD_IO_ERROR) {
                         if (__ratelimit(&drbd_ratelimit_state))
                                 dev_err(DEV, "Local IO failed in %s.\n", where);
                         if (mdev->state.disk > D_INCONSISTENT)
@@ -1856,6 +1870,8 @@ static inline void __drbd_chk_io_error_(struct drbd_conf *mdev, int forcedetach,
         case EP_DETACH:
         case EP_CALL_HELPER:
                 set_bit(WAS_IO_ERROR, &mdev->flags);
+                if (forcedetach == DRBD_FORCE_DETACH)
+                        set_bit(FORCE_DETACH, &mdev->flags);
                 if (mdev->state.disk > D_FAILED) {
                         _drbd_set_state(_NS(mdev, disk, D_FAILED), CS_HARD, NULL);
                         dev_err(DEV,
@@ -1875,7 +1891,7 @@ static inline void __drbd_chk_io_error_(struct drbd_conf *mdev, int forcedetach,
  */
 #define drbd_chk_io_error(m,e,f) drbd_chk_io_error_(m,e,f, __func__)
 static inline void drbd_chk_io_error_(struct drbd_conf *mdev,
-        int error, int forcedetach, const char *where)
+        int error, enum drbd_force_detach_flags forcedetach, const char *where)
 {
         if (error) {
                 unsigned long flags;
@@ -2405,15 +2421,17 @@ static inline void dec_ap_bio(struct drbd_conf *mdev)
         int ap_bio = atomic_dec_return(&mdev->ap_bio_cnt);
 
         D_ASSERT(ap_bio >= 0);
+
+        if (ap_bio == 0 && test_bit(BITMAP_IO, &mdev->flags)) {
+                if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))
+                        drbd_queue_work(&mdev->data.work, &mdev->bm_io_work.w);
+        }
+
         /* this currently does wake_up for every dec_ap_bio!
          * maybe rather introduce some type of hysteresis?
          * e.g. (ap_bio == mxb/2 || ap_bio == 0) ? */
         if (ap_bio < mxb)
                 wake_up(&mdev->misc_wait);
-        if (ap_bio == 0 && test_bit(BITMAP_IO, &mdev->flags)) {
-                if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))
-                        drbd_queue_work(&mdev->data.work, &mdev->bm_io_work.w);
-        }
 }
 
 static inline int drbd_set_ed_uuid(struct drbd_conf *mdev, u64 val)
diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index 920ede2829d6..2e0e7fc1dbba 100644
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -1514,6 +1514,13 @@ static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
 
         /* Do not change the order of the if above and the two below... */
         if (os.pdsk == D_DISKLESS && ns.pdsk > D_DISKLESS) {      /* attach on the peer */
+                /* we probably will start a resync soon.
+                 * make sure those things are properly reset. */
+                mdev->rs_total = 0;
+                mdev->rs_failed = 0;
+                atomic_set(&mdev->rs_pending_cnt, 0);
+                drbd_rs_cancel_all(mdev);
+
                 drbd_send_uuids(mdev);
                 drbd_send_state(mdev, ns);
         }
@@ -1630,9 +1637,24 @@ static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
                         eh = mdev->ldev->dc.on_io_error;
                         was_io_error = test_and_clear_bit(WAS_IO_ERROR, &mdev->flags);
 
-                        /* Immediately allow completion of all application IO, that waits
-                           for completion from the local disk. */
-                        tl_abort_disk_io(mdev);
+                        if (was_io_error && eh == EP_CALL_HELPER)
+                                drbd_khelper(mdev, "local-io-error");
+
+                        /* Immediately allow completion of all application IO,
+                         * that waits for completion from the local disk,
+                         * if this was a force-detach due to disk_timeout
+                         * or administrator request (drbdsetup detach --force).
+                         * Do NOT abort otherwise.
+                         * Aborting local requests may cause serious problems,
+                         * if requests are completed to upper layers already,
+                         * and then later the already submitted local bio completes.
+                         * This can cause DMA into former bio pages that meanwhile
+                         * have been re-used for other things.
+                         * So aborting local requests may cause crashes,
+                         * or even worse, silent data corruption.
+                         */
+                        if (test_and_clear_bit(FORCE_DETACH, &mdev->flags))
+                                tl_abort_disk_io(mdev);
 
                         /* current state still has to be D_FAILED,
                          * there is only one way out: to D_DISKLESS,
@@ -1653,9 +1675,6 @@ static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
                         drbd_md_sync(mdev);
                 }
                 put_ldev(mdev);
-
-                if (was_io_error && eh == EP_CALL_HELPER)
-                        drbd_khelper(mdev, "local-io-error");
         }
 
         /* second half of local IO error, failure to attach,
@@ -1669,10 +1688,6 @@ static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
                                 "ASSERT FAILED: disk is %s while going diskless\n",
                                 drbd_disk_str(mdev->state.disk));
 
-                mdev->rs_total = 0;
-                mdev->rs_failed = 0;
-                atomic_set(&mdev->rs_pending_cnt, 0);
-
                 if (ns.conn >= C_CONNECTED)
                         drbd_send_state(mdev, ns);
 
@@ -2194,7 +2209,8 @@ int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags fl
 {
         struct p_sizes p;
         sector_t d_size, u_size;
-        int q_order_type, max_bio_size;
+        int q_order_type;
+        unsigned int max_bio_size;
         int ok;
 
         if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
@@ -2203,7 +2219,7 @@ int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags fl
                 u_size = mdev->ldev->dc.disk_size;
                 q_order_type = drbd_queue_order_type(mdev);
                 max_bio_size = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
-                max_bio_size = min_t(int, max_bio_size, DRBD_MAX_BIO_SIZE);
+                max_bio_size = min(max_bio_size, DRBD_MAX_BIO_SIZE);
                 put_ldev(mdev);
         } else {
                 d_size = 0;
@@ -2214,7 +2230,7 @@ int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags fl
 
         /* Never allow old drbd (up to 8.3.7) to see more than 32KiB */
         if (mdev->agreed_pro_version <= 94)
-                max_bio_size = min_t(int, max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
+                max_bio_size = min(max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
 
         p.d_size = cpu_to_be64(d_size);
         p.u_size = cpu_to_be64(u_size);
@@ -3541,6 +3557,22 @@ static int drbd_congested(void *congested_data, int bdi_bits)
                 goto out;
         }
 
+        if (test_bit(CALLBACK_PENDING, &mdev->flags)) {
+                r |= (1 << BDI_async_congested);
+                /* Without good local data, we would need to read from remote,
+                 * and that would need the worker thread as well, which is
+                 * currently blocked waiting for that usermode helper to
+                 * finish.
+                 */
+                if (!get_ldev_if_state(mdev, D_UP_TO_DATE))
+                        r |= (1 << BDI_sync_congested);
+                else
+                        put_ldev(mdev);
+                r &= bdi_bits;
+                reason = 'c';
+                goto out;
+        }
+
         if (get_ldev(mdev)) {
                 q = bdev_get_queue(mdev->ldev->backing_bdev);
                 r = bdi_congested(&q->backing_dev_info, bdi_bits);
@@ -3604,6 +3636,7 @@ struct drbd_conf *drbd_new_device(unsigned int minor)
         q->backing_dev_info.congested_data = mdev;
 
         blk_queue_make_request(q, drbd_make_request);
+        blk_queue_flush(q, REQ_FLUSH | REQ_FUA);
         /* Setting the max_hw_sectors to an odd value of 8kibyte here
            This triggers a max_bio_size message upon first attach or connect */
         blk_queue_max_hw_sectors(q, DRBD_MAX_BIO_SIZE_SAFE >> 8);
@@ -3870,7 +3903,7 @@ void drbd_md_sync(struct drbd_conf *mdev)
         if (!drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {
                 /* this was a try anyways ... */
                 dev_err(DEV, "meta data update failed!\n");
-                drbd_chk_io_error(mdev, 1, true);
+                drbd_chk_io_error(mdev, 1, DRBD_META_IO_ERROR);
         }
 
         /* Update mdev->ldev->md.la_size_sect,
@@ -3950,9 +3983,9 @@ int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
 
         spin_lock_irq(&mdev->req_lock);
         if (mdev->state.conn < C_CONNECTED) {
-                int peer;
+                unsigned int peer;
                 peer = be32_to_cpu(buffer->la_peer_max_bio_size);
-                peer = max_t(int, peer, DRBD_MAX_BIO_SIZE_SAFE);
+                peer = max(peer, DRBD_MAX_BIO_SIZE_SAFE);
                 mdev->peer_max_bio_size = peer;
         }
         spin_unlock_irq(&mdev->req_lock);
diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index 6d4de6a72e80..fb9dce8daa24 100644
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -147,6 +147,9 @@ int drbd_khelper(struct drbd_conf *mdev, char *cmd)
         char *argv[] = {usermode_helper, cmd, mb, NULL };
         int ret;
 
+        if (current == mdev->worker.task)
+                set_bit(CALLBACK_PENDING, &mdev->flags);
+
         snprintf(mb, 12, "minor-%d", mdev_to_minor(mdev));
 
         if (get_net_conf(mdev)) {
@@ -189,6 +192,9 @@ int drbd_khelper(struct drbd_conf *mdev, char *cmd)
                                 usermode_helper, cmd, mb,
                                 (ret >> 8) & 0xff, ret);
 
+        if (current == mdev->worker.task)
+                clear_bit(CALLBACK_PENDING, &mdev->flags);
+
         if (ret < 0) /* Ignore any ERRNOs we got. */
                 ret = 0;
 
@@ -795,8 +801,8 @@ static int drbd_check_al_size(struct drbd_conf *mdev)
 static void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_bio_size)
 {
         struct request_queue * const q = mdev->rq_queue;
-        int max_hw_sectors = max_bio_size >> 9;
-        int max_segments = 0;
+        unsigned int max_hw_sectors = max_bio_size >> 9;
+        unsigned int max_segments = 0;
 
         if (get_ldev_if_state(mdev, D_ATTACHING)) {
                 struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
@@ -829,7 +835,7 @@ static void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_bio_
 
 void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
 {
-        int now, new, local, peer;
+        unsigned int now, new, local, peer;
 
         now = queue_max_hw_sectors(mdev->rq_queue) << 9;
         local = mdev->local_max_bio_size; /* Eventually last known value, from volatile memory */
@@ -840,13 +846,14 @@ void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
                 mdev->local_max_bio_size = local;
                 put_ldev(mdev);
         }
+        local = min(local, DRBD_MAX_BIO_SIZE);
 
         /* We may ignore peer limits if the peer is modern enough.
            Because new from 8.3.8 onwards the peer can use multiple
            BIOs for a single peer_request */
         if (mdev->state.conn >= C_CONNECTED) {
                 if (mdev->agreed_pro_version < 94) {
-                        peer = min_t(int, mdev->peer_max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
+                        peer = min(mdev->peer_max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
                         /* Correct old drbd (up to 8.3.7) if it believes it can do more than 32KiB */
                 } else if (mdev->agreed_pro_version == 94)
                         peer = DRBD_MAX_SIZE_H80_PACKET;
@@ -854,10 +861,10 @@ void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
                         peer = DRBD_MAX_BIO_SIZE;
         }
 
-        new = min_t(int, local, peer);
+        new = min(local, peer);
 
         if (mdev->state.role == R_PRIMARY && new < now)
-                dev_err(DEV, "ASSERT FAILED new < now; (%d < %d)\n", new, now);
+                dev_err(DEV, "ASSERT FAILED new < now; (%u < %u)\n", new, now);
 
         if (new != now)
                 dev_info(DEV, "max BIO size = %u\n", new);
@@ -950,6 +957,14 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
          * to realize a "hot spare" feature (not that I'd recommend that) */
         wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
 
+        /* make sure there is no leftover from previous force-detach attempts */
+        clear_bit(FORCE_DETACH, &mdev->flags);
+
+        /* and no leftover from previously aborted resync or verify, either */
+        mdev->rs_total = 0;
+        mdev->rs_failed = 0;
+        atomic_set(&mdev->rs_pending_cnt, 0);
+
         /* allocation not in the IO path, cqueue thread context */
         nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
         if (!nbc) {
@@ -1345,6 +1360,7 @@ static int drbd_nl_detach(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
         }
 
         if (dt.detach_force) {
+                set_bit(FORCE_DETACH, &mdev->flags);
                 drbd_force_state(mdev, NS(disk, D_FAILED));
                 reply->ret_code = SS_SUCCESS;
                 goto out;
@@ -1962,9 +1978,11 @@ static int drbd_nl_invalidate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nl
         int retcode;
 
         /* If there is still bitmap IO pending, probably because of a previous
-         * resync just being finished, wait for it before requesting a new resync. */
+         * resync just being finished, wait for it before requesting a new resync.
+         * Also wait for it's after_state_ch(). */
         drbd_suspend_io(mdev);
         wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
+        drbd_flush_workqueue(mdev);
 
         retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T), CS_ORDERED);
 
@@ -2003,9 +2021,11 @@ static int drbd_nl_invalidate_peer(struct drbd_conf *mdev, struct drbd_nl_cfg_re
         int retcode;
 
         /* If there is still bitmap IO pending, probably because of a previous
-         * resync just being finished, wait for it before requesting a new resync. */
+         * resync just being finished, wait for it before requesting a new resync.
+         * Also wait for it's after_state_ch(). */
         drbd_suspend_io(mdev);
         wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
+        drbd_flush_workqueue(mdev);
 
         retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_S), CS_ORDERED);
 
diff --git a/drivers/block/drbd/drbd_proc.c b/drivers/block/drbd/drbd_proc.c
index 869bada2ed06..5496104f90b9 100644
--- a/drivers/block/drbd/drbd_proc.c
+++ b/drivers/block/drbd/drbd_proc.c
@@ -245,6 +245,9 @@ static int drbd_seq_show(struct seq_file *seq, void *v)
                     mdev->state.role == R_SECONDARY) {
                         seq_printf(seq, "%2d: cs:Unconfigured\n", i);
                 } else {
+                        /* reset mdev->congestion_reason */
+                        bdi_rw_congested(&mdev->rq_queue->backing_dev_info);
+
                         seq_printf(seq,
                            "%2d: cs:%s ro:%s/%s ds:%s/%s %c %c%c%c%c%c%c\n"
                            "    ns:%u nr:%u dw:%u dr:%u al:%u bm:%u "
diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index ea4836e0ae98..c74ca2df7431 100644
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -277,6 +277,9 @@ static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net)
         atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use;
         int i;
 
+        if (page == NULL)
+                return;
+
         if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE)*minor_count)
                 i = page_chain_free(page);
         else {
@@ -316,7 +319,7 @@ struct drbd_epoch_entry *drbd_alloc_ee(struct drbd_conf *mdev,
                                      gfp_t gfp_mask) __must_hold(local)
 {
         struct drbd_epoch_entry *e;
-        struct page *page;
+        struct page *page = NULL;
         unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT;
 
         if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE))
@@ -329,9 +332,11 @@ struct drbd_epoch_entry *drbd_alloc_ee(struct drbd_conf *mdev,
                 return NULL;
         }
 
-        page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT));
-        if (!page)
-                goto fail;
+        if (data_size) {
+                page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT));
+                if (!page)
+                        goto fail;
+        }
 
         INIT_HLIST_NODE(&e->collision);
         e->epoch = NULL;
@@ -1270,7 +1275,6 @@ read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, int data_size) __
 
         data_size -= dgs;
 
-        ERR_IF(data_size == 0) return NULL;
         ERR_IF(data_size &  0x1ff) return NULL;
         ERR_IF(data_size >  DRBD_MAX_BIO_SIZE) return NULL;
 
@@ -1291,6 +1295,9 @@ read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, int data_size) __
         if (!e)
                 return NULL;
 
+        if (!data_size)
+                return e;
+
         ds = data_size;
         page = e->pages;
         page_chain_for_each(page) {
@@ -1715,6 +1722,10 @@ static int receive_Data(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned
 
         dp_flags = be32_to_cpu(p->dp_flags);
         rw |= wire_flags_to_bio(mdev, dp_flags);
+        if (e->pages == NULL) {
+                D_ASSERT(e->size == 0);
+                D_ASSERT(dp_flags & DP_FLUSH);
+        }
 
         if (dp_flags & DP_MAY_SET_IN_SYNC)
                 e->flags |= EE_MAY_SET_IN_SYNC;
@@ -3801,11 +3812,18 @@ void drbd_free_tl_hash(struct drbd_conf *mdev)
         mdev->ee_hash = NULL;
         mdev->ee_hash_s = 0;
 
-        /* paranoia code */
-        for (h = mdev->tl_hash; h < mdev->tl_hash + mdev->tl_hash_s; h++)
-                if (h->first)
-                        dev_err(DEV, "ASSERT FAILED tl_hash[%u] == %p, expected NULL\n",
-                                (int)(h - mdev->tl_hash), h->first);
+        /* We may not have had the chance to wait for all locally pending
+         * application requests. The hlist_add_fake() prevents access after
+         * free on master bio completion. */
+        for (h = mdev->tl_hash; h < mdev->tl_hash + mdev->tl_hash_s; h++) {
+                struct drbd_request *req;
+                struct hlist_node *pos, *n;
+                hlist_for_each_entry_safe(req, pos, n, h, collision) {
+                        hlist_del_init(&req->collision);
+                        hlist_add_fake(&req->collision);
+                }
+        }
+
         kfree(mdev->tl_hash);
         mdev->tl_hash = NULL;
         mdev->tl_hash_s = 0;
diff --git a/drivers/block/drbd/drbd_req.c b/drivers/block/drbd/drbd_req.c
index 8e93a6ac9bb6..910335c30927 100644
--- a/drivers/block/drbd/drbd_req.c
+++ b/drivers/block/drbd/drbd_req.c
@@ -455,7 +455,7 @@ int __req_mod(struct drbd_request *req, enum drbd_req_event what,
                 req->rq_state |= RQ_LOCAL_COMPLETED;
                 req->rq_state &= ~RQ_LOCAL_PENDING;
 
-                __drbd_chk_io_error(mdev, false);
+                __drbd_chk_io_error(mdev, DRBD_IO_ERROR);
                 _req_may_be_done_not_susp(req, m);
                 break;
 
@@ -477,7 +477,7 @@ int __req_mod(struct drbd_request *req, enum drbd_req_event what,
                         break;
                 }
 
-                __drbd_chk_io_error(mdev, false);
+                __drbd_chk_io_error(mdev, DRBD_IO_ERROR);
 
         goto_queue_for_net_read:
 
@@ -1111,13 +1111,12 @@ void drbd_make_request(struct request_queue *q, struct bio *bio)
         /*
          * what we "blindly" assume:
          */
-        D_ASSERT(bio->bi_size > 0);
         D_ASSERT((bio->bi_size & 0x1ff) == 0);
 
         /* to make some things easier, force alignment of requests within the
          * granularity of our hash tables */
         s_enr = bio->bi_sector >> HT_SHIFT;
-        e_enr = (bio->bi_sector+(bio->bi_size>>9)-1) >> HT_SHIFT;
+        e_enr = bio->bi_size ? (bio->bi_sector+(bio->bi_size>>9)-1) >> HT_SHIFT : s_enr;
 
         if (likely(s_enr == e_enr)) {
                 do {
@@ -1275,7 +1274,7 @@ void request_timer_fn(unsigned long data)
                  time_after(now, req->start_time + dt) &&
                 !time_in_range(now, mdev->last_reattach_jif, mdev->last_reattach_jif + dt)) {
                 dev_warn(DEV, "Local backing device failed to meet the disk-timeout\n");
-                __drbd_chk_io_error(mdev, 1);
+                __drbd_chk_io_error(mdev, DRBD_FORCE_DETACH);
         }
         nt = (time_after(now, req->start_time + et) ? now : req->start_time) + et;
         spin_unlock_irq(&mdev->req_lock);
diff --git a/drivers/block/drbd/drbd_worker.c b/drivers/block/drbd/drbd_worker.c
index 620c70ff2231..6bce2cc179d4 100644
--- a/drivers/block/drbd/drbd_worker.c
+++ b/drivers/block/drbd/drbd_worker.c
@@ -111,7 +111,7 @@ void drbd_endio_read_sec_final(struct drbd_epoch_entry *e) __releases(local)
         if (list_empty(&mdev->read_ee))
                 wake_up(&mdev->ee_wait);
         if (test_bit(__EE_WAS_ERROR, &e->flags))
-                __drbd_chk_io_error(mdev, false);
+                __drbd_chk_io_error(mdev, DRBD_IO_ERROR);
         spin_unlock_irqrestore(&mdev->req_lock, flags);
 
         drbd_queue_work(&mdev->data.work, &e->w);
@@ -154,7 +154,7 @@ static void drbd_endio_write_sec_final(struct drbd_epoch_entry *e) __releases(lo
                 : list_empty(&mdev->active_ee);
 
         if (test_bit(__EE_WAS_ERROR, &e->flags))
-                __drbd_chk_io_error(mdev, false);
+                __drbd_chk_io_error(mdev, DRBD_IO_ERROR);
         spin_unlock_irqrestore(&mdev->req_lock, flags);
 
         if (is_syncer_req)
@@ -1501,14 +1501,6 @@ void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side)
                 return;
         }
 
-        if (mdev->state.conn < C_AHEAD) {
-                /* In case a previous resync run was aborted by an IO error/detach on the peer. */
-                drbd_rs_cancel_all(mdev);
-                /* This should be done when we abort the resync. We definitely do not
-                   want to have this for connections going back and forth between
-                   Ahead/Behind and SyncSource/SyncTarget */
-        }
-
         if (side == C_SYNC_TARGET) {
                 /* Since application IO was locked out during C_WF_BITMAP_T and
                    C_WF_SYNC_UUID we are still unmodified. Before going to C_SYNC_TARGET
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 1347ba8b8377..8d4afc83e05f 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -672,6 +672,7 @@ static void __reschedule_timeout(int drive, const char *message)
 
         if (drive == current_reqD)
                 drive = current_drive;
+        __cancel_delayed_work(&fd_timeout);
 
         if (drive < 0 || drive >= N_DRIVE) {
                 delay = 20UL * HZ;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index bbca966f8f66..3bba65510d23 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1597,14 +1597,12 @@ static int loop_add(struct loop_device **l, int i)
         struct gendisk *disk;
         int err;
 
+        err = -ENOMEM;
         lo = kzalloc(sizeof(*lo), GFP_KERNEL);
-        if (!lo) {
-                err = -ENOMEM;
+        if (!lo)
                 goto out;
-        }
 
-        err = idr_pre_get(&loop_index_idr, GFP_KERNEL);
-        if (err < 0)
+        if (!idr_pre_get(&loop_index_idr, GFP_KERNEL))
                 goto out_free_dev;
 
         if (i >= 0) {
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 65665c9c42c6..8f428a8ab003 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -499,7 +499,7 @@ static int rbd_header_from_disk(struct rbd_image_header *header,
                          / sizeof (*ondisk))
                 return -EINVAL;
         header->snapc = kmalloc(sizeof(struct ceph_snap_context) +
-                                snap_count * sizeof (*ondisk),
+                                snap_count * sizeof(u64),
                                 gfp_flags);
         if (!header->snapc)
                 return -ENOMEM;
@@ -977,7 +977,7 @@ static void rbd_req_cb(struct ceph_osd_request *req, struct ceph_msg *msg)
         op = (void *)(replyhead + 1);
         rc = le32_to_cpu(replyhead->result);
         bytes = le64_to_cpu(op->extent.length);
-        read_op = (le32_to_cpu(op->op) == CEPH_OSD_OP_READ);
+        read_op = (le16_to_cpu(op->op) == CEPH_OSD_OP_READ);
 
         dout("rbd_req_cb bytes=%lld readop=%d rc=%d\n", bytes, read_op, rc);