drbd: factored tl_restart() out of tl_clear().

If IO was frozen for a temporal network outage, resend the
content of the transfer-log into the newly established connection.

Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>

1 files changed, 79 insertions, 37 deletions

diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index a86e6f1ff7f4..a8a0341fce53 100644
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -333,59 +333,94 @@ bail:
         drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));
 }
 
-
 /**
- * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
+ * _tl_restart() - Walks the transfer log, and applies an action to all requests
  * @mdev:       DRBD device.
+ * @what:       The action/event to perform with all request objects
  *
- * This is called after the connection to the peer was lost. The storage covered
- * by the requests on the transfer gets marked as our of sync. Called from the
- * receiver thread and the worker thread.
+ * @what might be one of connection_lost_while_pending, resend, fail_frozen_disk_io,
+ * restart_frozen_disk_io.
  */
-void tl_clear(struct drbd_conf *mdev)
+static void _tl_restart(struct drbd_conf *mdev, enum drbd_req_event what)
 {
-        struct drbd_tl_epoch *b, *tmp;
+        struct drbd_tl_epoch *b, *tmp, **pn;
         struct list_head *le, *tle;
-        struct drbd_request *r;
-        int new_initial_bnr = net_random();
-
-        spin_lock_irq(&mdev->req_lock);
+        struct drbd_request *req;
+        int rv, n_writes, n_reads;
 
         b = mdev->oldest_tle;
+        pn = &mdev->oldest_tle;
         while (b) {
+                n_writes = 0;
+                n_reads = 0;
                 list_for_each_safe(le, tle, &b->requests) {
-                        r = list_entry(le, struct drbd_request, tl_requests);
-                        /* It would be nice to complete outside of spinlock.
-                         * But this is easier for now. */
-                        _req_mod(r, connection_lost_while_pending);
+                        req = list_entry(le, struct drbd_request, tl_requests);
+                        rv = _req_mod(req, what);
+
+                        n_writes += (rv & MR_WRITE) >> MR_WRITE_SHIFT;
+                        n_reads  += (rv & MR_READ) >> MR_READ_SHIFT;
                 }
                 tmp = b->next;
 
-                /* there could still be requests on that ring list,
-                 * in case local io is still pending */
-                list_del(&b->requests);
-
-                /* dec_ap_pending corresponding to queue_barrier.
-                 * the newest barrier may not have been queued yet,
-                 * in which case w.cb is still NULL. */
-                if (b->w.cb != NULL)
-                        dec_ap_pending(mdev);
-
-                if (b == mdev->newest_tle) {
-                        /* recycle, but reinit! */
-                        D_ASSERT(tmp == NULL);
-                        INIT_LIST_HEAD(&b->requests);
-                        INIT_LIST_HEAD(&b->w.list);
-                        b->w.cb = NULL;
-                        b->br_number = new_initial_bnr;
-                        b->n_writes = 0;
-
-                        mdev->oldest_tle = b;
-                        break;
+                if (n_writes + n_reads) {
+                        if (what == resend) {
+                                b->n_writes = n_writes;
+                                if (b->w.cb == NULL) {
+                                        b->w.cb = w_send_barrier;
+                                        inc_ap_pending(mdev);
+                                        set_bit(CREATE_BARRIER, &mdev->flags);
+                                }
+
+                                drbd_queue_work(&mdev->data.work, &b->w);
+                        }
+                        pn = &b->next;
+                } else {
+                        /* there could still be requests on that ring list,
+                         * in case local io is still pending */
+                        list_del(&b->requests);
+
+                        /* dec_ap_pending corresponding to queue_barrier.
+                         * the newest barrier may not have been queued yet,
+                         * in which case w.cb is still NULL. */
+                        if (b->w.cb != NULL)
+                                dec_ap_pending(mdev);
+
+                        if (b == mdev->newest_tle) {
+                                /* recycle, but reinit! */
+                                D_ASSERT(tmp == NULL);
+                                INIT_LIST_HEAD(&b->requests);
+                                INIT_LIST_HEAD(&b->w.list);
+                                b->w.cb = NULL;
+                                b->br_number = net_random();
+                                b->n_writes = 0;
+
+                                *pn = b;
+                                break;
+                        }
+                        *pn = tmp;
+                        kfree(b);
                 }
-                kfree(b);
                 b = tmp;
         }
+}
+
+
+/**
+ * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
+ * @mdev:       DRBD device.
+ *
+ * This is called after the connection to the peer was lost. The storage covered
+ * by the requests on the transfer gets marked as our of sync. Called from the
+ * receiver thread and the worker thread.
+ */
+void tl_clear(struct drbd_conf *mdev)
+{
+        struct list_head *le, *tle;
+        struct drbd_request *r;
+
+        spin_lock_irq(&mdev->req_lock);
+
+        _tl_restart(mdev, connection_lost_while_pending);
 
         /* we expect this list to be empty. */
         D_ASSERT(list_empty(&mdev->out_of_sequence_requests));
@@ -406,6 +441,13 @@ void tl_clear(struct drbd_conf *mdev)
         spin_unlock_irq(&mdev->req_lock);
 }
 
+void tl_restart(struct drbd_conf *mdev, enum drbd_req_event what)
+{
+        spin_lock_irq(&mdev->req_lock);
+        _tl_restart(mdev, what);
+        spin_unlock_irq(&mdev->req_lock);
+}
+
 /**
  * cl_wide_st_chg() - TRUE if the state change is a cluster wide one
  * @mdev:       DRBD device.