Commit 0d11f3cf authored by Christoph Böhmwalder's avatar Christoph Böhmwalder Committed by Jens Axboe
Browse files

drbd: Pass a peer device to the resync and online verify functions 



Originally-from: Andreas Grünbacher <agruen@linbit.com>
Signed-off-by: default avatarChristoph Böhmwalder <christoph.boehmwalder@linbit.com>
Link: https://lore.kernel.org/r/20230330102744.2128122-2-christoph.boehmwalder@linbit.com


Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent ad878a0d

drivers/block/drbd/drbd_actlog.c

+8 −5
Original line number Diff line number Diff line
@@ -735,8 +735,9 @@ static bool update_rs_extent(struct drbd_device *device, 
	return false;

}



void drbd_advance_rs_marks(struct drbd_device *device, unsigned long still_to_go)

void drbd_advance_rs_marks(struct drbd_peer_device *peer_device, unsigned long still_to_go)

{

	struct drbd_device *device = peer_device->device;

	unsigned long now = jiffies;

	unsigned long last = device->rs_mark_time[device->rs_last_mark];

	int next = (device->rs_last_mark + 1) % DRBD_SYNC_MARKS;
@@ -819,7 +820,7 @@ static int update_sync_bits(struct drbd_device *device, 
		if (mode == SET_IN_SYNC) {

			unsigned long still_to_go = drbd_bm_total_weight(device);

			bool rs_is_done = (still_to_go <= device->rs_failed);

			drbd_advance_rs_marks(device, still_to_go);

			drbd_advance_rs_marks(first_peer_device(device), still_to_go);

			if (cleared || rs_is_done)

				maybe_schedule_on_disk_bitmap_update(device, rs_is_done);

		} else if (mode == RECORD_RS_FAILED)
@@ -843,10 +844,11 @@ static bool plausible_request_size(int size) 
 * called by worker on C_SYNC_TARGET and receiver on SyncSource.

 *

 */

int __drbd_change_sync(struct drbd_device *device, sector_t sector, int size,

int __drbd_change_sync(struct drbd_peer_device *peer_device, sector_t sector, int size,

		enum update_sync_bits_mode mode)

{

	/* Is called from worker and receiver context _only_ */

	struct drbd_device *device = peer_device->device;

	unsigned long sbnr, ebnr, lbnr;

	unsigned long count = 0;

	sector_t esector, nr_sectors;
@@ -1009,14 +1011,15 @@ int drbd_rs_begin_io(struct drbd_device *device, sector_t sector) 
 * tries to set it to BME_LOCKED. Returns 0 upon success, and -EAGAIN

 * if there is still application IO going on in this area.

 */

int drbd_try_rs_begin_io(struct drbd_device *device, sector_t sector)

int drbd_try_rs_begin_io(struct drbd_peer_device *peer_device, sector_t sector)

{

	struct drbd_device *device = peer_device->device;

	unsigned int enr = BM_SECT_TO_EXT(sector);

	const unsigned int al_enr = enr*AL_EXT_PER_BM_SECT;

	struct lc_element *e;

	struct bm_extent *bm_ext;

	int i;

	bool throttle = drbd_rs_should_slow_down(device, sector, true);

	bool throttle = drbd_rs_should_slow_down(peer_device, sector, true);



	/* If we need to throttle, a half-locked (only marked BME_NO_WRITES,

	 * not yet BME_LOCKED) extent needs to be kicked out explicitly if we

drivers/block/drbd/drbd_int.h

+25 −21
Original line number Diff line number Diff line
@@ -1433,21 +1433,24 @@ void drbd_resync_after_changed(struct drbd_device *device); 
extern void drbd_start_resync(struct drbd_device *device, enum drbd_conns side);

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_device *device);

extern int drbd_resync_finished(struct drbd_peer_device *peer_device);

/* 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);

extern int drbd_md_sync_page_io(struct drbd_device *device,

		struct drbd_backing_dev *bdev, sector_t sector, enum req_op op);

extern void drbd_ov_out_of_sync_found(struct drbd_device *, sector_t, int);

extern void drbd_ov_out_of_sync_found(struct drbd_peer_device *peer_device,

		sector_t sector, int size);

extern void wait_until_done_or_force_detached(struct drbd_device *device,

		struct drbd_backing_dev *bdev, unsigned int *done);

extern void drbd_rs_controller_reset(struct drbd_device *device);

extern void drbd_rs_controller_reset(struct drbd_peer_device *peer_device);



static inline void ov_out_of_sync_print(struct drbd_device *device)

static inline void ov_out_of_sync_print(struct drbd_peer_device *peer_device)

{

	struct drbd_device *device = peer_device->device;



	if (device->ov_last_oos_size) {

		drbd_err(device, "Out of sync: start=%llu, size=%lu (sectors)\n",

		drbd_err(peer_device, "Out of sync: start=%llu, size=%lu (sectors)\n",

		     (unsigned long long)device->ov_last_oos_start,

		     (unsigned long)device->ov_last_oos_size);

	}
@@ -1486,7 +1489,7 @@ extern int drbd_ack_receiver(struct drbd_thread *thi); 
extern void drbd_send_ping_wf(struct work_struct *ws);

extern void drbd_send_acks_wf(struct work_struct *ws);

extern bool drbd_rs_c_min_rate_throttle(struct drbd_device *device);

extern bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector,

extern bool drbd_rs_should_slow_down(struct drbd_peer_device *peer_device, sector_t sector,

		bool throttle_if_app_is_waiting);

extern int drbd_submit_peer_request(struct drbd_peer_request *peer_req);

extern int drbd_free_peer_reqs(struct drbd_device *, struct list_head *);
@@ -1542,22 +1545,22 @@ extern void drbd_al_begin_io(struct drbd_device *device, struct drbd_interval *i 
extern void drbd_al_complete_io(struct drbd_device *device, struct drbd_interval *i);

extern void drbd_rs_complete_io(struct drbd_device *device, sector_t sector);

extern int drbd_rs_begin_io(struct drbd_device *device, sector_t sector);

extern int drbd_try_rs_begin_io(struct drbd_device *device, sector_t sector);

extern int drbd_try_rs_begin_io(struct drbd_peer_device *peer_device, sector_t sector);

extern void drbd_rs_cancel_all(struct drbd_device *device);

extern int drbd_rs_del_all(struct drbd_device *device);

extern void drbd_rs_failed_io(struct drbd_device *device,

extern void drbd_rs_failed_io(struct drbd_peer_device *peer_device,

		sector_t sector, int size);

extern void drbd_advance_rs_marks(struct drbd_device *device, unsigned long still_to_go);

extern void drbd_advance_rs_marks(struct drbd_peer_device *peer_device, unsigned long still_to_go);



enum update_sync_bits_mode { RECORD_RS_FAILED, SET_OUT_OF_SYNC, SET_IN_SYNC };

extern int __drbd_change_sync(struct drbd_device *device, sector_t sector, int size,

extern int __drbd_change_sync(struct drbd_peer_device *peer_device, sector_t sector, int size,

		enum update_sync_bits_mode mode);

#define drbd_set_in_sync(device, sector, size) \

	__drbd_change_sync(device, sector, size, SET_IN_SYNC)

#define drbd_set_out_of_sync(device, sector, size) \

	__drbd_change_sync(device, sector, size, SET_OUT_OF_SYNC)

#define drbd_rs_failed_io(device, sector, size) \

	__drbd_change_sync(device, sector, size, RECORD_RS_FAILED)

#define drbd_set_in_sync(peer_device, sector, size) \

	__drbd_change_sync(peer_device, sector, size, SET_IN_SYNC)

#define drbd_set_out_of_sync(peer_device, sector, size) \

	__drbd_change_sync(peer_device, sector, size, SET_OUT_OF_SYNC)

#define drbd_rs_failed_io(peer_device, sector, size) \

	__drbd_change_sync(peer_device, sector, size, RECORD_RS_FAILED)

extern void drbd_al_shrink(struct drbd_device *device);

extern int drbd_al_initialize(struct drbd_device *, void *);
@@ -1945,15 +1948,16 @@ static inline int __dec_ap_pending(struct drbd_device *device) 
 * C_SYNC_SOURCE sends P_RS_DATA_REPLY   (and expects P_WRITE_ACK with ID_SYNCER)

 *					   (or P_NEG_ACK with ID_SYNCER)

 */

static inline void inc_rs_pending(struct drbd_device *device)

static inline void inc_rs_pending(struct drbd_peer_device *peer_device)

{

	atomic_inc(&device->rs_pending_cnt);

	atomic_inc(&peer_device->device->rs_pending_cnt);

}



#define dec_rs_pending(device) ((void)expect((device), __dec_rs_pending(device) >= 0))

static inline int __dec_rs_pending(struct drbd_device *device)

#define dec_rs_pending(peer_device) \

	((void)expect((peer_device), __dec_rs_pending(peer_device) >= 0))

static inline int __dec_rs_pending(struct drbd_peer_device *peer_device)

{

	return atomic_dec_return(&device->rs_pending_cnt);

	return atomic_dec_return(&peer_device->device->rs_pending_cnt);

}



/* counts how many answers we still need to send to the peer.

drivers/block/drbd/drbd_receiver.c

+30 −29
Original line number Diff line number Diff line
@@ -2044,11 +2044,11 @@ static int e_end_resync_block(struct drbd_work *w, int unused) 
	D_ASSERT(device, drbd_interval_empty(&peer_req->i));



	if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) {

		drbd_set_in_sync(device, sector, peer_req->i.size);

		drbd_set_in_sync(peer_device, sector, peer_req->i.size);

		err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req);

	} else {

		/* Record failure to sync */

		drbd_rs_failed_io(device, sector, peer_req->i.size);

		drbd_rs_failed_io(peer_device, sector, peer_req->i.size);



		err  = drbd_send_ack(peer_device, P_NEG_ACK, peer_req);

	}
@@ -2067,7 +2067,7 @@ static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t secto 
	if (!peer_req)

		goto fail;



	dec_rs_pending(device);

	dec_rs_pending(peer_device);



	inc_unacked(device);

	/* corresponding dec_unacked() in e_end_resync_block()
@@ -2220,7 +2220,7 @@ static int e_end_block(struct drbd_work *w, int cancel) 
				P_RS_WRITE_ACK : P_WRITE_ACK;

			err = drbd_send_ack(peer_device, pcmd, peer_req);

			if (pcmd == P_RS_WRITE_ACK)

				drbd_set_in_sync(device, sector, peer_req->i.size);

				drbd_set_in_sync(peer_device, sector, peer_req->i.size);

		} else {

			err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req);

			/* we expect it to be marked out of sync anyways...
@@ -2691,7 +2691,7 @@ static int receive_Data(struct drbd_connection *connection, struct packet_info * 


	if (device->state.pdsk < D_INCONSISTENT) {

		/* In case we have the only disk of the cluster, */

		drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size);

		drbd_set_out_of_sync(peer_device, peer_req->i.sector, peer_req->i.size);

		peer_req->flags &= ~EE_MAY_SET_IN_SYNC;

		drbd_al_begin_io(device, &peer_req->i);

		peer_req->flags |= EE_CALL_AL_COMPLETE_IO;
@@ -2730,9 +2730,10 @@ static int receive_Data(struct drbd_connection *connection, struct packet_info * 
 * The current sync rate used here uses only the most recent two step marks,

 * to have a short time average so we can react faster.

 */

bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector,

bool drbd_rs_should_slow_down(struct drbd_peer_device *peer_device, sector_t sector,

		bool throttle_if_app_is_waiting)

{

	struct drbd_device *device = peer_device->device;

	struct lc_element *tmp;

	bool throttle = drbd_rs_c_min_rate_throttle(device);
@@ -2844,7 +2845,7 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet 
			break;

		case P_OV_REPLY:

			verb = 0;

			dec_rs_pending(device);

			dec_rs_pending(peer_device);

			drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC);

			break;

		default:
@@ -2915,7 +2916,7 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet 
			/* track progress, we may need to throttle */

			atomic_add(size >> 9, &device->rs_sect_in);

			peer_req->w.cb = w_e_end_ov_reply;

			dec_rs_pending(device);

			dec_rs_pending(peer_device);

			/* drbd_rs_begin_io done when we sent this request,

			 * but accounting still needs to be done. */

			goto submit_for_resync;
@@ -2978,7 +2979,7 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet 


	update_receiver_timing_details(connection, drbd_rs_should_slow_down);

	if (device->state.peer != R_PRIMARY

	&& drbd_rs_should_slow_down(device, sector, false))

	&& drbd_rs_should_slow_down(peer_device, sector, false))

		schedule_timeout_uninterruptible(HZ/10);

	update_receiver_timing_details(connection, drbd_rs_begin_io);

	if (drbd_rs_begin_io(device, sector))
@@ -4450,7 +4451,7 @@ static int receive_state(struct drbd_connection *connection, struct packet_info 
		else if (os.conn >= C_SYNC_SOURCE &&

			 peer_state.conn == C_CONNECTED) {

			if (drbd_bm_total_weight(device) <= device->rs_failed)

				drbd_resync_finished(device);

				drbd_resync_finished(peer_device);

			return 0;

		}

	}
@@ -4458,8 +4459,8 @@ static int receive_state(struct drbd_connection *connection, struct packet_info 
	/* explicit verify finished notification, stop sector reached. */

	if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE &&

	    peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) {

		ov_out_of_sync_print(device);

		drbd_resync_finished(device);

		ov_out_of_sync_print(peer_device);

		drbd_resync_finished(peer_device);

		return 0;

	}
@@ -4937,7 +4938,7 @@ static int receive_out_of_sync(struct drbd_connection *connection, struct packet 
				drbd_conn_str(device->state.conn));

	}



	drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize));

	drbd_set_out_of_sync(peer_device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize));



	return 0;

}
@@ -4958,7 +4959,7 @@ static int receive_rs_deallocated(struct drbd_connection *connection, struct pac 
	sector = be64_to_cpu(p->sector);

	size = be32_to_cpu(p->blksize);



	dec_rs_pending(device);

	dec_rs_pending(peer_device);



	if (get_ldev(device)) {

		struct drbd_peer_request *peer_req;
@@ -5650,12 +5651,12 @@ static int got_IsInSync(struct drbd_connection *connection, struct packet_info * 


	if (get_ldev(device)) {

		drbd_rs_complete_io(device, sector);

		drbd_set_in_sync(device, sector, blksize);

		drbd_set_in_sync(peer_device, sector, blksize);

		/* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */

		device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT);

		put_ldev(device);

	}

	dec_rs_pending(device);

	dec_rs_pending(peer_device);

	atomic_add(blksize >> 9, &device->rs_sect_in);



	return 0;
@@ -5701,8 +5702,8 @@ static int got_BlockAck(struct drbd_connection *connection, struct packet_info * 
	update_peer_seq(peer_device, be32_to_cpu(p->seq_num));



	if (p->block_id == ID_SYNCER) {

		drbd_set_in_sync(device, sector, blksize);

		dec_rs_pending(device);

		drbd_set_in_sync(peer_device, sector, blksize);

		dec_rs_pending(peer_device);

		return 0;

	}

	switch (pi->cmd) {
@@ -5747,8 +5748,8 @@ static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi 
	update_peer_seq(peer_device, be32_to_cpu(p->seq_num));



	if (p->block_id == ID_SYNCER) {

		dec_rs_pending(device);

		drbd_rs_failed_io(device, sector, size);

		dec_rs_pending(peer_device);

		drbd_rs_failed_io(peer_device, sector, size);

		return 0;

	}
@@ -5761,7 +5762,7 @@ static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi 
		   request is no longer in the collision hash. */

		/* In Protocol B we might already have got a P_RECV_ACK

		   but then get a P_NEG_ACK afterwards. */

		drbd_set_out_of_sync(device, sector, size);

		drbd_set_out_of_sync(peer_device, sector, size);

	}

	return 0;

}
@@ -5806,13 +5807,13 @@ static int got_NegRSDReply(struct drbd_connection *connection, struct packet_inf 


	update_peer_seq(peer_device, be32_to_cpu(p->seq_num));



	dec_rs_pending(device);

	dec_rs_pending(peer_device);



	if (get_ldev_if_state(device, D_FAILED)) {

		drbd_rs_complete_io(device, sector);

		switch (pi->cmd) {

		case P_NEG_RS_DREPLY:

			drbd_rs_failed_io(device, sector, size);

			drbd_rs_failed_io(peer_device, sector, size);

			break;

		case P_RS_CANCEL:

			break;
@@ -5869,21 +5870,21 @@ static int got_OVResult(struct drbd_connection *connection, struct packet_info * 
	update_peer_seq(peer_device, be32_to_cpu(p->seq_num));



	if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC)

		drbd_ov_out_of_sync_found(device, sector, size);

		drbd_ov_out_of_sync_found(peer_device, sector, size);

	else

		ov_out_of_sync_print(device);

		ov_out_of_sync_print(peer_device);



	if (!get_ldev(device))

		return 0;



	drbd_rs_complete_io(device, sector);

	dec_rs_pending(device);

	dec_rs_pending(peer_device);



	--device->ov_left;



	/* let's advance progress step marks only for every other megabyte */

	if ((device->ov_left & 0x200) == 0x200)

		drbd_advance_rs_marks(device, device->ov_left);

		drbd_advance_rs_marks(peer_device, device->ov_left);



	if (device->ov_left == 0) {

		dw = kmalloc(sizeof(*dw), GFP_NOIO);
@@ -5893,8 +5894,8 @@ static int got_OVResult(struct drbd_connection *connection, struct packet_info * 
			drbd_queue_work(&peer_device->connection->sender_work, &dw->w);

		} else {

			drbd_err(device, "kmalloc(dw) failed.");

			ov_out_of_sync_print(device);

			drbd_resync_finished(device);

			ov_out_of_sync_print(peer_device);

			drbd_resync_finished(peer_device);

		}

	}

	put_ldev(device);

drivers/block/drbd/drbd_req.c

+5 −4
Original line number Diff line number Diff line
@@ -122,12 +122,13 @@ void drbd_req_destroy(struct kref *kref) 
		 * before it even was submitted or sent.

		 * In that case we do not want to touch the bitmap at all.

		 */

		struct drbd_peer_device *peer_device = first_peer_device(device);

		if ((s & (RQ_POSTPONED|RQ_LOCAL_MASK|RQ_NET_MASK)) != RQ_POSTPONED) {

			if (!(s & RQ_NET_OK) || !(s & RQ_LOCAL_OK))

				drbd_set_out_of_sync(device, req->i.sector, req->i.size);

				drbd_set_out_of_sync(peer_device, req->i.sector, req->i.size);



			if ((s & RQ_NET_OK) && (s & RQ_LOCAL_OK) && (s & RQ_NET_SIS))

				drbd_set_in_sync(device, req->i.sector, req->i.size);

				drbd_set_in_sync(peer_device, req->i.sector, req->i.size);

		}



		/* one might be tempted to move the drbd_al_complete_io
@@ -620,7 +621,7 @@ int __req_mod(struct drbd_request *req, enum drbd_req_event what, 
		break;



	case READ_COMPLETED_WITH_ERROR:

		drbd_set_out_of_sync(device, req->i.sector, req->i.size);

		drbd_set_out_of_sync(peer_device, req->i.sector, req->i.size);

		drbd_report_io_error(device, req);

		__drbd_chk_io_error(device, DRBD_READ_ERROR);

		fallthrough;
@@ -1131,7 +1132,7 @@ static int drbd_process_write_request(struct drbd_request *req) 
	if (remote) {

		_req_mod(req, TO_BE_SENT, peer_device);

		_req_mod(req, QUEUE_FOR_NET_WRITE, peer_device);

	} else if (drbd_set_out_of_sync(device, req->i.sector, req->i.size))

	} else if (drbd_set_out_of_sync(peer_device, req->i.sector, req->i.size))

		_req_mod(req, QUEUE_FOR_SEND_OOS, peer_device);



	return remote;

drivers/block/drbd/drbd_state.c

+6 −4
Original line number Diff line number Diff line
@@ -1222,9 +1222,11 @@ void drbd_resume_al(struct drbd_device *device) 
}



/* helper for _drbd_set_state */

static void set_ov_position(struct drbd_device *device, enum drbd_conns cs)

static void set_ov_position(struct drbd_peer_device *peer_device, enum drbd_conns cs)

{

	if (first_peer_device(device)->connection->agreed_pro_version < 90)

	struct drbd_device *device = peer_device->device;



	if (peer_device->connection->agreed_pro_version < 90)

		device->ov_start_sector = 0;

	device->rs_total = drbd_bm_bits(device);

	device->ov_position = 0;
@@ -1387,7 +1389,7 @@ _drbd_set_state(struct drbd_device *device, union drbd_state ns, 
		unsigned long now = jiffies;

		int i;



		set_ov_position(device, ns.conn);

		set_ov_position(peer_device, ns.conn);

		device->rs_start = now;

		device->rs_last_sect_ev = 0;

		device->ov_last_oos_size = 0;
@@ -1398,7 +1400,7 @@ _drbd_set_state(struct drbd_device *device, union drbd_state ns, 
			device->rs_mark_time[i] = now;

		}



		drbd_rs_controller_reset(device);

		drbd_rs_controller_reset(peer_device);



		if (ns.conn == C_VERIFY_S) {

			drbd_info(device, "Starting Online Verify from sector %llu\n",