drbd: Replace vnr_to_mdev() with conn_peer_device()

The new function returns a peer device, which allows us to eliminate a few
instances of first_peer_device().
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>

drivers/block/drbd/drbd_int.h

@@ -856,14 +856,6 @@ static inline unsigned int device_to_minor(struct drbd_device *device)
 	return device->minor;
 }
 
-static inline struct drbd_device *vnr_to_device(struct drbd_connection *connection, int vnr)
-{
-	struct drbd_peer_device *peer_device;
-
-	peer_device = idr_find(&connection->peer_devices, vnr);
-	return peer_device ? peer_device->device : NULL;
-}
-
 /*
  * function declarations
  *************************/

drivers/block/drbd/drbd_receiver.c

@@ -1422,6 +1422,12 @@ static void conn_wait_active_ee_empty(struct drbd_connection *connection)
 	rcu_read_unlock();
 }
 
+static struct drbd_peer_device *
+conn_peer_device(struct drbd_connection *connection, int volume_number)
+{
+	return idr_find(&connection->peer_devices, volume_number);
+}
+
 static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi)
 {
 	int rv;
@@ -1731,15 +1737,17 @@ find_request(struct drbd_device *device, struct rb_root *root, u64 id,
 
 static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct drbd_request *req;
 	sector_t sector;
 	int err;
 	struct p_data *p = pi->data;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	sector = be64_to_cpu(p->sector);
 
@@ -1764,14 +1772,16 @@ static int receive_DataReply(struct drbd_connection *connection, struct packet_i
 
 static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	sector_t sector;
 	int err;
 	struct p_data *p = pi->data;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	sector = be64_to_cpu(p->sector);
 	D_ASSERT(device, p->block_id == ID_SYNCER);
@@ -2154,6 +2164,7 @@ static int handle_write_conflicts(struct drbd_device *device,
 /* mirrored write */
 static int receive_Data(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	sector_t sector;
 	struct drbd_peer_request *peer_req;
@@ -2163,9 +2174,10 @@ static int receive_Data(struct drbd_connection *connection, struct packet_info *
 	u32 dp_flags;
 	int err, tp;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	if (!get_ldev(device)) {
 		int err2;
@@ -2211,7 +2223,7 @@ static int receive_Data(struct drbd_connection *connection, struct packet_info *
 	spin_unlock(&connection->epoch_lock);
 
 	rcu_read_lock();
-	tp = rcu_dereference(first_peer_device(device)->connection->net_conf)->two_primaries;
+	tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries;
 	rcu_read_unlock();
 	if (tp) {
 		peer_req->flags |= EE_IN_INTERVAL_TREE;
@@ -2238,9 +2250,9 @@ static int receive_Data(struct drbd_connection *connection, struct packet_info *
 	if (device->state.conn == C_SYNC_TARGET)
 		wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req));
 
-	if (first_peer_device(device)->connection->agreed_pro_version < 100) {
+	if (peer_device->connection->agreed_pro_version < 100) {
 		rcu_read_lock();
-		switch (rcu_dereference(first_peer_device(device)->connection->net_conf)->wire_protocol) {
+		switch (rcu_dereference(peer_device->connection->net_conf)->wire_protocol) {
 		case DRBD_PROT_C:
 			dp_flags |= DP_SEND_WRITE_ACK;
 			break;
@@ -2366,6 +2378,7 @@ int drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector)
 
 static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	sector_t sector;
 	sector_t capacity;
@@ -2375,9 +2388,10 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet
 	unsigned int fault_type;
 	struct p_block_req *p =	pi->data;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 	capacity = drbd_get_capacity(device->this_bdev);
 
 	sector = be64_to_cpu(p->sector);
@@ -2457,11 +2471,11 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet
 		peer_req->digest = di;
 		peer_req->flags |= EE_HAS_DIGEST;
 
-		if (drbd_recv_all(first_peer_device(device)->connection, di->digest, pi->size))
+		if (drbd_recv_all(peer_device->connection, di->digest, pi->size))
 			goto out_free_e;
 
 		if (pi->cmd == P_CSUM_RS_REQUEST) {
-			D_ASSERT(device, first_peer_device(device)->connection->agreed_pro_version >= 89);
+			D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89);
 			peer_req->w.cb = w_e_end_csum_rs_req;
 			/* used in the sector offset progress display */
 			device->bm_resync_fo = BM_SECT_TO_BIT(sector);
@@ -2478,7 +2492,7 @@ static int receive_DataRequest(struct drbd_connection *connection, struct packet
 
 	case P_OV_REQUEST:
 		if (device->ov_start_sector == ~(sector_t)0 &&
-		    first_peer_device(device)->connection->agreed_pro_version >= 90) {
+		    peer_device->connection->agreed_pro_version >= 90) {
 			unsigned long now = jiffies;
 			int i;
 			device->ov_start_sector = sector;
@@ -3323,6 +3337,7 @@ static int config_unknown_volume(struct drbd_connection *connection, struct pack
 
 static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_rs_param_95 *p;
 	unsigned int header_size, data_size, exp_max_sz;
@@ -3335,9 +3350,10 @@ static int receive_SyncParam(struct drbd_connection *connection, struct packet_i
 	int fifo_size = 0;
 	int err;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return config_unknown_volume(connection, pi);
+	device = peer_device->device;
 
 	exp_max_sz  = apv <= 87 ? sizeof(struct p_rs_param)
 		    : apv == 88 ? sizeof(struct p_rs_param)
@@ -3368,12 +3384,12 @@ static int receive_SyncParam(struct drbd_connection *connection, struct packet_i
 	p = pi->data;
 	memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
 
-	err = drbd_recv_all(first_peer_device(device)->connection, p, header_size);
+	err = drbd_recv_all(peer_device->connection, p, header_size);
 	if (err)
 		return err;
 
 	mutex_lock(&connection->resource->conf_update);
-	old_net_conf = first_peer_device(device)->connection->net_conf;
+	old_net_conf = peer_device->connection->net_conf;
 	if (get_ldev(device)) {
 		new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL);
 		if (!new_disk_conf) {
@@ -3399,7 +3415,7 @@ static int receive_SyncParam(struct drbd_connection *connection, struct packet_i
 				goto reconnect;
 			}
 
-			err = drbd_recv_all(first_peer_device(device)->connection, p->verify_alg, data_size);
+			err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size);
 			if (err)
 				goto reconnect;
 			/* we expect NUL terminated string */
@@ -3473,15 +3489,15 @@ static int receive_SyncParam(struct drbd_connection *connection, struct packet_i
 			if (verify_tfm) {
 				strcpy(new_net_conf->verify_alg, p->verify_alg);
 				new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1;
-				crypto_free_hash(first_peer_device(device)->connection->verify_tfm);
-				first_peer_device(device)->connection->verify_tfm = verify_tfm;
+				crypto_free_hash(peer_device->connection->verify_tfm);
+				peer_device->connection->verify_tfm = verify_tfm;
 				drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg);
 			}
 			if (csums_tfm) {
 				strcpy(new_net_conf->csums_alg, p->csums_alg);
 				new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1;
-				crypto_free_hash(first_peer_device(device)->connection->csums_tfm);
-				first_peer_device(device)->connection->csums_tfm = csums_tfm;
+				crypto_free_hash(peer_device->connection->csums_tfm);
+				peer_device->connection->csums_tfm = csums_tfm;
 				drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg);
 			}
 			rcu_assign_pointer(connection->net_conf, new_net_conf);
@@ -3527,7 +3543,7 @@ static int receive_SyncParam(struct drbd_connection *connection, struct packet_i
 	crypto_free_hash(csums_tfm);
 	/* but free the verify_tfm again, if csums_tfm did not work out */
 	crypto_free_hash(verify_tfm);
-	conn_request_state(first_peer_device(device)->connection, NS(conn, C_DISCONNECTING), CS_HARD);
+	conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
 	return -EIO;
 }
 
@@ -3546,6 +3562,7 @@ static void warn_if_differ_considerably(struct drbd_device *device,
 
 static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_sizes *p = pi->data;
 	enum determine_dev_size dd = DS_UNCHANGED;
@@ -3553,9 +3570,10 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info
 	int ldsc = 0; /* local disk size changed */
 	enum dds_flags ddsf;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return config_unknown_volume(connection, pi);
+	device = peer_device->device;
 
 	p_size = be64_to_cpu(p->d_size);
 	p_usize = be64_to_cpu(p->u_size);
@@ -3586,7 +3604,7 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info
 		    device->state.disk >= D_OUTDATED &&
 		    device->state.conn < C_CONNECTED) {
 			drbd_err(device, "The peer's disk size is too small!\n");
-			conn_request_state(first_peer_device(device)->connection, NS(conn, C_DISCONNECTING), CS_HARD);
+			conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
 			put_ldev(device);
 			return -EIO;
 		}
@@ -3667,14 +3685,16 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info
 
 static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_uuids *p = pi->data;
 	u64 *p_uuid;
 	int i, updated_uuids = 0;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return config_unknown_volume(connection, pi);
+	device = peer_device->device;
 
 	p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO);
 	if (!p_uuid) {
@@ -3694,14 +3714,14 @@ static int receive_uuids(struct drbd_connection *connection, struct packet_info
 	    (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {
 		drbd_err(device, "Can only connect to data with current UUID=%016llX\n",
 		    (unsigned long long)device->ed_uuid);
-		conn_request_state(first_peer_device(device)->connection, NS(conn, C_DISCONNECTING), CS_HARD);
+		conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
 		return -EIO;
 	}
 
 	if (get_ldev(device)) {
 		int skip_initial_sync =
 			device->state.conn == C_CONNECTED &&
-			first_peer_device(device)->connection->agreed_pro_version >= 90 &&
+			peer_device->connection->agreed_pro_version >= 90 &&
 			device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED &&
 			(p_uuid[UI_FLAGS] & 8);
 		if (skip_initial_sync) {
@@ -3772,19 +3792,21 @@ static union drbd_state convert_state(union drbd_state ps)
 
 static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_req_state *p = pi->data;
 	union drbd_state mask, val;
 	enum drbd_state_rv rv;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	mask.i = be32_to_cpu(p->mask);
 	val.i = be32_to_cpu(p->val);
 
-	if (test_bit(RESOLVE_CONFLICTS, &first_peer_device(device)->connection->flags) &&
+	if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) &&
 	    mutex_is_locked(device->state_mutex)) {
 		drbd_send_sr_reply(device, SS_CONCURRENT_ST_CHG);
 		return 0;
@@ -3827,6 +3849,7 @@ static int receive_req_conn_state(struct drbd_connection *connection, struct pac
 
 static int receive_state(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_state *p = pi->data;
 	union drbd_state os, ns, peer_state;
@@ -3834,9 +3857,10 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
 	enum chg_state_flags cs_flags;
 	int rv;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return config_unknown_volume(connection, pi);
+	device = peer_device->device;
 
 	peer_state.i = be32_to_cpu(p->state);
 
@@ -3943,10 +3967,10 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
 				peer_state.disk = D_DISKLESS;
 				real_peer_disk = D_DISKLESS;
 			} else {
-				if (test_and_clear_bit(CONN_DRY_RUN, &first_peer_device(device)->connection->flags))
+				if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags))
 					return -EIO;
 				D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS);
-				conn_request_state(first_peer_device(device)->connection, NS(conn, C_DISCONNECTING), CS_HARD);
+				conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
 				return -EIO;
 			}
 		}
@@ -3968,10 +3992,10 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
 		   for temporal network outages! */
 		spin_unlock_irq(&device->resource->req_lock);
 		drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n");
-		tl_clear(first_peer_device(device)->connection);
+		tl_clear(peer_device->connection);
 		drbd_uuid_new_current(device);
 		clear_bit(NEW_CUR_UUID, &device->flags);
-		conn_request_state(first_peer_device(device)->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD);
+		conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD);
 		return -EIO;
 	}
 	rv = _drbd_set_state(device, ns, cs_flags, NULL);
@@ -3979,7 +4003,7 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
 	spin_unlock_irq(&device->resource->req_lock);
 
 	if (rv < SS_SUCCESS) {
-		conn_request_state(first_peer_device(device)->connection, NS(conn, C_DISCONNECTING), CS_HARD);
+		conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
 		return -EIO;
 	}
 
@@ -4003,12 +4027,14 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
 
 static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_rs_uuid *p = pi->data;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	wait_event(device->misc_wait,
 		   device->state.conn == C_WF_SYNC_UUID ||
@@ -4225,13 +4251,15 @@ void INFO_bm_xfer_stats(struct drbd_device *device,
    returns 0 on failure, 1 if we successfully received it. */
 static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct bm_xfer_ctx c;
 	int err;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED);
 	/* you are supposed to send additional out-of-sync information
@@ -4260,7 +4288,7 @@ static int receive_bitmap(struct drbd_connection *connection, struct packet_info
 				err = -EIO;
 				goto out;
 			}
-			err = drbd_recv_all(first_peer_device(device)->connection, p, pi->size);
+			err = drbd_recv_all(peer_device->connection, p, pi->size);
 			if (err)
 			       goto out;
 			err = decode_bitmap_c(device, p, &c, pi->size);
@@ -4278,7 +4306,7 @@ static int receive_bitmap(struct drbd_connection *connection, struct packet_info
 				goto out;
 			break;
 		}
-		err = drbd_recv_header(first_peer_device(device)->connection, pi);
+		err = drbd_recv_header(peer_device->connection, pi);
 		if (err)
 			goto out;
 	}
@@ -4328,12 +4356,14 @@ static int receive_UnplugRemote(struct drbd_connection *connection, struct packe
 
 static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_block_desc *p = pi->data;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	switch (device->state.conn) {
 	case C_WF_SYNC_UUID:
@@ -4893,13 +4923,15 @@ static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_i
 
 static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_req_state_reply *p = pi->data;
 	int retcode = be32_to_cpu(p->retcode);
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) {
 		D_ASSERT(device, connection->agreed_pro_version < 100);
@@ -4936,16 +4968,18 @@ static int got_PingAck(struct drbd_connection *connection, struct packet_info *p
 
 static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_block_ack *p = pi->data;
 	sector_t sector = be64_to_cpu(p->sector);
 	int blksize = be32_to_cpu(p->blksize);
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
-	D_ASSERT(device, first_peer_device(device)->connection->agreed_pro_version >= 89);
+	D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89);
 
 	update_peer_seq(device, be32_to_cpu(p->seq_num));
 
@@ -4986,15 +5020,17 @@ validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t secto
 
 static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_block_ack *p = pi->data;
 	sector_t sector = be64_to_cpu(p->sector);
 	int blksize = be32_to_cpu(p->blksize);
 	enum drbd_req_event what;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	update_peer_seq(device, be32_to_cpu(p->seq_num));
 
@@ -5030,15 +5066,17 @@ static int got_BlockAck(struct drbd_connection *connection, struct packet_info *
 
 static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_block_ack *p = pi->data;
 	sector_t sector = be64_to_cpu(p->sector);
 	int size = be32_to_cpu(p->blksize);
 	int err;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	update_peer_seq(device, be32_to_cpu(p->seq_num));
 
@@ -5064,13 +5102,15 @@ static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi
 
 static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_block_ack *p = pi->data;
 	sector_t sector = be64_to_cpu(p->sector);
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	update_peer_seq(device, be32_to_cpu(p->seq_num));
 
@@ -5084,14 +5124,16 @@ static int got_NegDReply(struct drbd_connection *connection, struct packet_info
 
 static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	sector_t sector;
 	int size;
 	struct p_block_ack *p = pi->data;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	sector = be64_to_cpu(p->sector);
 	size = be32_to_cpu(p->blksize);
@@ -5142,15 +5184,17 @@ static int got_BarrierAck(struct drbd_connection *connection, struct packet_info
 
 static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi)
 {
+	struct drbd_peer_device *peer_device;
 	struct drbd_device *device;
 	struct p_block_ack *p = pi->data;
 	struct drbd_work *w;
 	sector_t sector;
 	int size;
 
-	device = vnr_to_device(connection, pi->vnr);
-	if (!device)
+	peer_device = conn_peer_device(connection, pi->vnr);
+	if (!peer_device)
 		return -EIO;
+	device = peer_device->device;
 
 	sector = be64_to_cpu(p->sector);
 	size = be32_to_cpu(p->blksize);
@@ -5179,7 +5223,7 @@ static int got_OVResult(struct drbd_connection *connection, struct packet_info *
 		if (w) {
 			w->cb = w_ov_finished;
 			w->device = device;
-			drbd_queue_work(&first_peer_device(device)->connection->sender_work, w);
+			drbd_queue_work(&peer_device->connection->sender_work, w);
 		} else {
 			drbd_err(device, "kmalloc(w) failed.");
 			ov_out_of_sync_print(device);