drbd: online verify: account for "skipped" blocks

In a multi-node scenario, to avoid a potential distributed deadlock,
after receiving a P_OV_REQUEST, we sometimes have to send back
P_RS_CANCEL instead of P_OV_REPLY, effectively skipping verify for those
blocks (they are "too busy" currently).

If you start verify on a Secondary, this may happen frequently.
If you start verify on the Primary, that should happen very rarely,

We forgot to account for these skipped blocks, though, ov_left would
then never reach zero. It would then appear that verify was stuck at
"almost" 100%, but never actually finishing.

This change should fix that.

Author: lge

drbd/drbd_int.h

@@ -1144,6 +1144,10 @@ struct drbd_peer_device {
 	sector_t ov_last_oos_start;
 	/* size of out-of-sync range in sectors. */
 	sector_t ov_last_oos_size;
+	/* Start sector of skipped range (to merge printk reporting). */
+	sector_t ov_last_skipped_start;
+	/* size of skipped range in sectors. */
+	sector_t ov_last_skipped_size;
 	int c_sync_rate; /* current resync rate after syncer throttle magic */
 	struct fifo_buffer *rs_plan_s; /* correction values of resync planer (RCU, connection->conn_update) */
 	atomic_t rs_sect_in; /* for incoming resync data rate, SyncTarget */
@@ -1152,6 +1156,7 @@ struct drbd_peer_device {
 			      * on the lower level device when we last looked. */
 	int rs_in_flight; /* resync sectors in flight (to proxy, in proxy and from proxy) */
 	unsigned long ov_left; /* in bits */
+	unsigned long ov_skipped; /* in bits */
 
 	u64 current_uuid;
 	u64 bitmap_uuids[DRBD_PEERS_MAX];
@@ -1850,6 +1855,8 @@ extern void drbd_start_resync(struct drbd_peer_device *, enum drbd_repl_state);
 extern void resume_next_sg(struct drbd_device *device);
 extern void suspend_other_sg(struct drbd_device *device);
 extern int drbd_resync_finished(struct drbd_peer_device *, enum drbd_disk_state);
+extern void verify_progress(struct drbd_peer_device *peer_device,
+		const sector_t sector, const unsigned int size);
 /* maybe rather drbd_main.c ? */
 extern void *drbd_md_get_buffer(struct drbd_device *device, const char *intent);
 extern void drbd_md_put_buffer(struct drbd_device *device);
@@ -1873,6 +1880,15 @@ static inline void ov_out_of_sync_print(struct drbd_peer_device *peer_device)
 	peer_device->ov_last_oos_size = 0;
 }
 
+static inline void ov_skipped_print(struct drbd_peer_device *peer_device)
+{
+	if (peer_device->ov_last_skipped_size) {
+		drbd_info(peer_device, "Skipped verify, too busy: start=%llu, size=%lu (sectors)\n",
+		     (unsigned long long)peer_device->ov_last_skipped_start,
+		     (unsigned long)peer_device->ov_last_skipped_size);
+	}
+	peer_device->ov_last_skipped_size = 0;
+}
 
 extern void drbd_csum_bio(struct crypto_ahash *, struct bio *, void *);
 extern void drbd_csum_pages(struct crypto_ahash *, struct page *, void *);
@@ -1882,7 +1898,6 @@ extern int w_e_end_rsdata_req(struct drbd_work *, int);
 extern int w_e_end_csum_rs_req(struct drbd_work *, int);
 extern int w_e_end_ov_reply(struct drbd_work *, int);
 extern int w_e_end_ov_req(struct drbd_work *, int);
-extern int w_ov_finished(struct drbd_work *, int);
 extern int w_resync_timer(struct drbd_work *, int);
 extern int w_send_dblock(struct drbd_work *, int);
 extern int w_send_read_req(struct drbd_work *, int);
@@ -2492,6 +2507,13 @@ static inline bool is_sync_state(struct drbd_peer_device *peer_device,
 		is_sync_target_state(peer_device, which);
 }
 
+static inline bool is_verify_state(struct drbd_peer_device *peer_device,
+				   enum which_state which)
+{
+	enum drbd_repl_state repl_state = peer_device->repl_state[which];
+	return repl_state == L_VERIFY_S || repl_state == L_VERIFY_T;
+}
+
 /**
  * get_ldev() - Increase the ref count on device->ldev. Returns 0 if there is no ldev
  * @_device:		DRBD device.

drbd/drbd_receiver.c

@@ -2944,6 +2944,20 @@ bool drbd_rs_c_min_rate_throttle(struct drbd_peer_device *peer_device)
 	return false;
 }
 
+static void verify_skipped_block(struct drbd_peer_device *peer_device,
+		const sector_t sector, const unsigned int size)
+{
+	++peer_device->ov_skipped;
+	if (peer_device->ov_last_skipped_start + peer_device->ov_last_skipped_size == sector) {
+		peer_device->ov_last_skipped_size += size>>9;
+	} else {
+		ov_skipped_print(peer_device);
+		peer_device->ov_last_skipped_start = sector;
+		peer_device->ov_last_skipped_size = size>>9;
+	}
+	verify_progress(peer_device, sector, size);
+}
+
 static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi)
 {
 	struct drbd_peer_device *peer_device;
@@ -2985,10 +2999,11 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet
 		case P_DATA_REQUEST:
 			drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p);
 			break;
+		case P_OV_REQUEST:
+			verify_skipped_block(peer_device, sector, size);
 		case P_RS_THIN_REQ:
 		case P_RS_DATA_REQUEST:
 		case P_CSUM_RS_REQUEST:
-		case P_OV_REQUEST:
 			drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p);
 			break;
 		case P_OV_REPLY:
@@ -3084,6 +3099,7 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet
 			peer_device->ov_start_sector = sector;
 			peer_device->ov_position = sector;
 			peer_device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector);
+			peer_device->ov_skipped = 0;
 			peer_device->rs_total = peer_device->ov_left;
 			for (i = 0; i < DRBD_SYNC_MARKS; i++) {
 				peer_device->rs_mark_left[i] = peer_device->ov_left;
@@ -3141,6 +3157,8 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet
 		   Instruct the SyncSource to retry */
 		err = drbd_try_rs_begin_io(peer_device, sector, false);
 		if (err) {
+			if (pi->cmd == P_OV_REQUEST)
+				verify_skipped_block(peer_device, sector, size);
 			err = drbd_send_ack(peer_device, P_RS_CANCEL, peer_req);
 			/* If err is set, we will drop the connection... */
 			goto fail3;
@@ -8320,10 +8338,14 @@ static int got_NegRSDReply(struct drbd_connection *connection, struct packet_inf
 			drbd_rs_failed_io(peer_device, sector, size);
 			break;
 		case P_RS_CANCEL:
-			bit = BM_SECT_TO_BIT(sector);
-			mutex_lock(&device->bm_resync_fo_mutex);
-			device->bm_resync_fo = min(device->bm_resync_fo, bit);
-			mutex_unlock(&device->bm_resync_fo_mutex);
+			if (peer_device->repl_state[NOW] == L_VERIFY_S) {
+				verify_skipped_block(peer_device, sector, size);
+			} else {
+				bit = BM_SECT_TO_BIT(sector);
+				mutex_lock(&device->bm_resync_fo_mutex);
+				device->bm_resync_fo = min(device->bm_resync_fo, bit);
+				mutex_unlock(&device->bm_resync_fo_mutex);
+			}
 
 			atomic_add(size >> 9, &peer_device->rs_sect_in);
 			mod_timer(&peer_device->resync_timer, jiffies + SLEEP_TIME);
@@ -8375,24 +8397,8 @@ static int got_OVResult(struct drbd_connection *connection, struct packet_info *
 	drbd_rs_complete_io(peer_device, sector);
 	dec_rs_pending(peer_device);
 
-	--peer_device->ov_left;
-
-	/* let's advance progress step marks only for every other megabyte */
-	if ((peer_device->ov_left & 0x200) == 0x200)
-		drbd_advance_rs_marks(peer_device, peer_device->ov_left);
+	verify_progress(peer_device, sector, size);
 
-	if (peer_device->ov_left == 0) {
-		struct drbd_peer_device_work *dw = kmalloc(sizeof(*dw), GFP_NOIO);
-		if (dw) {
-			dw->w.cb = w_ov_finished;
-			dw->peer_device = peer_device;
-			drbd_queue_work(&connection->sender_work, &dw->w);
-		} else {
-			drbd_err(device, "kmalloc(dw) failed.");
-			ov_out_of_sync_print(peer_device);
-			drbd_resync_finished(peer_device, D_MASK);
-		}
-	}
 	put_ldev(device);
 	return 0;
 }

drbd/drbd_sender.c

@@ -873,18 +873,6 @@ static int make_ov_request(struct drbd_peer_device *peer_device, int cancel)
 	return 1;
 }
 
-int w_ov_finished(struct drbd_work *w, int cancel)
-{
-	struct drbd_peer_device_work *dw =
-		container_of(w, struct drbd_peer_device_work, w);
-	struct drbd_peer_device *peer_device = dw->peer_device;
-	kfree(dw);
-	ov_out_of_sync_print(peer_device);
-	drbd_resync_finished(peer_device, D_MASK);
-
-	return 0;
-}
-
 struct resync_finished_work {
 	struct drbd_peer_device_work pdw;
 	enum drbd_disk_state new_peer_disk_state;
@@ -1091,17 +1079,22 @@ int drbd_resync_finished(struct drbd_peer_device *peer_device,
 	__change_repl_state(peer_device, L_ESTABLISHED);
 
 	aborted = device->disk_state[NOW] == D_OUTDATED && new_peer_disk_state == D_INCONSISTENT;
-
-	drbd_info(peer_device, "%s %s (total %lu sec; paused %lu sec; %lu K/sec)\n",
+	{
+	char tmp[sizeof(" but 01234567890123456789 4k blocks skipped")] = "";
+	if (verify_done && peer_device->ov_skipped)
+		snprintf(tmp, sizeof(tmp), " but %lu %dk blocks skipped",
+			peer_device->ov_skipped, Bit2KB(1));
+	drbd_info(peer_device, "%s %s%s (total %lu sec; paused %lu sec; %lu K/sec)\n",
 		  verify_done ? "Online verify" : "Resync",
-		  aborted ? "aborted" : "done",
+		  aborted ? "aborted" : "done", tmp,
 		  dt + peer_device->rs_paused, peer_device->rs_paused, dbdt);
+	}
 
 	n_oos = drbd_bm_total_weight(peer_device);
 
 	if (repl_state[NOW] == L_VERIFY_S || repl_state[NOW] == L_VERIFY_T) {
 		if (n_oos) {
-			drbd_alert(peer_device, "Online verify found %lu %dk block out of sync!\n",
+			drbd_alert(peer_device, "Online verify found %lu %dk blocks out of sync!\n",
 			      n_oos, Bit2KB(1));
 			khelper_cmd = "out-of-sync";
 		}
@@ -1490,12 +1483,31 @@ void drbd_ov_out_of_sync_found(struct drbd_peer_device *peer_device, sector_t se
 	if (peer_device->ov_last_oos_start + peer_device->ov_last_oos_size == sector) {
 		peer_device->ov_last_oos_size += size>>9;
 	} else {
+		ov_out_of_sync_print(peer_device);
 		peer_device->ov_last_oos_start = sector;
 		peer_device->ov_last_oos_size = size>>9;
 	}
 	drbd_set_out_of_sync(peer_device, sector, size);
 }
 
+void verify_progress(struct drbd_peer_device *peer_device,
+		const sector_t sector, const unsigned int size)
+{
+	bool stop_sector_reached =
+		(peer_device->repl_state[NOW] == L_VERIFY_S) &&
+		verify_can_do_stop_sector(peer_device) &&
+		(sector + (size>>9)) >= peer_device->ov_stop_sector;
+
+	--peer_device->ov_left;
+
+	/* let's advance progress step marks only for every other megabyte */
+	if ((peer_device->ov_left & 0x1ff) == 0)
+		drbd_advance_rs_marks(peer_device, peer_device->ov_left);
+
+	if (peer_device->ov_left == 0 || stop_sector_reached)
+		drbd_peer_device_post_work(peer_device, RS_DONE);
+}
+
 int w_e_end_ov_reply(struct drbd_work *w, int cancel)
 {
 	struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w);
@@ -1507,7 +1519,6 @@ int w_e_end_ov_reply(struct drbd_work *w, int cancel)
 	unsigned int size = peer_req->i.size;
 	int digest_size;
 	int err, eq = 0;
-	bool stop_sector_reached = false;
 
 	if (unlikely(cancel)) {
 		drbd_free_peer_req(peer_req);
@@ -1552,19 +1563,7 @@ int w_e_end_ov_reply(struct drbd_work *w, int cancel)
 
 	dec_unacked(peer_device);
 
-	--peer_device->ov_left;
-
-	/* let's advance progress step marks only for every other megabyte */
-	if ((peer_device->ov_left & 0x200) == 0x200)
-		drbd_advance_rs_marks(peer_device, peer_device->ov_left);
-
-	stop_sector_reached = verify_can_do_stop_sector(peer_device) &&
-		(sector + (size>>9)) >= peer_device->ov_stop_sector;
-
-	if (peer_device->ov_left == 0 || stop_sector_reached) {
-		ov_out_of_sync_print(peer_device);
-		drbd_resync_finished(peer_device, D_MASK);
-	}
+	verify_progress(peer_device, sector, size);
 
 	return err;
 }
@@ -2085,7 +2084,15 @@ static void update_on_disk_bitmap(struct drbd_peer_device *peer_device, bool res
 
 	drbd_bm_write_lazy(device, 0);
 
-	if (resync_done && is_sync_state(peer_device, NOW))
+	if (resync_done) {
+		if (is_verify_state(peer_device, NOW)) {
+			ov_out_of_sync_print(peer_device);
+			ov_skipped_print(peer_device);
+		} else
+			resync_done = is_sync_state(peer_device, NOW);
+	}
+
+	if (resync_done)
 		drbd_resync_finished(peer_device, D_MASK);
 
 	/* update timestamp, in case it took a while to write out stuff */

drbd/drbd_state.c

@@ -2037,6 +2037,7 @@ static void set_ov_position(struct drbd_peer_device *peer_device,
 		peer_device->ov_position = peer_device->ov_start_sector;
 	}
 	peer_device->ov_left = peer_device->rs_total;
+	peer_device->ov_skipped = 0;
 }
 
 static void queue_after_state_change_work(struct drbd_resource *resource,
@@ -2249,6 +2250,8 @@ static void finish_state_change(struct drbd_resource *resource, struct completio
 				peer_device->rs_last_sect_ev = 0;
 				peer_device->ov_last_oos_size = 0;
 				peer_device->ov_last_oos_start = 0;
+				peer_device->ov_last_skipped_size = 0;
+				peer_device->ov_last_skipped_start = 0;
 
 				for (i = 0; i < DRBD_SYNC_MARKS; i++) {
 					peer_device->rs_mark_left[i] = peer_device->ov_left;