Lines Matching defs:peer_device
223 struct drbd_peer_device *peer_device;
227 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
228 struct drbd_device *device = peer_device->device;
261 struct page *drbd_alloc_pages(struct drbd_peer_device *peer_device, unsigned int number,
264 struct drbd_device *device = peer_device->device;
271 nc = rcu_dereference(peer_device->connection->net_conf);
359 drbd_alloc_peer_req(struct drbd_peer_device *peer_device, u64 id, sector_t sector,
362 struct drbd_device *device = peer_device->device;
378 page = drbd_alloc_pages(peer_device, nr_pages,
390 peer_req->peer_device = peer_device;
888 int drbd_connected(struct drbd_peer_device *peer_device)
890 struct drbd_device *device = peer_device->device;
896 device->state_mutex = peer_device->connection->agreed_pro_version < 100 ?
897 &peer_device->connection->cstate_mutex :
900 err = drbd_send_sync_param(peer_device);
902 err = drbd_send_sizes(peer_device, 0, 0);
904 err = drbd_send_uuids(peer_device);
906 err = drbd_send_current_state(peer_device);
925 struct drbd_peer_device *peer_device;
1090 idr_for_each_entry(&connection->peer_devices, peer_device, vnr)
1091 mutex_lock(peer_device->device->state_mutex);
1098 idr_for_each_entry(&connection->peer_devices, peer_device, vnr)
1099 mutex_unlock(peer_device->device->state_mutex);
1102 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
1103 struct drbd_device *device = peer_device->device;
1112 drbd_connected(peer_device);
1313 struct drbd_peer_device *peer_device;
1322 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
1323 struct drbd_device *device = peer_device->device;
1660 conn_wait_active_ee_empty(peer_req->peer_device->connection);
1754 struct drbd_peer_device *peer_device;
1758 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
1759 struct drbd_device *device = peer_device->device;
1859 read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector,
1862 struct drbd_device *device = peer_device->device;
1868 void *dig_in = peer_device->connection->int_dig_in;
1869 void *dig_vv = peer_device->connection->int_dig_vv;
1876 if (!trim && peer_device->connection->peer_integrity_tfm) {
1877 digest_size = crypto_shash_digestsize(peer_device->connection->peer_integrity_tfm);
1882 err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size);
1900 drbd_err(peer_device, "data size (%u) != drbd logical block size (%u)\n",
1905 drbd_err(peer_device, "data size (%u) != backend logical block size (%u)\n",
1933 peer_req = drbd_alloc_peer_req(peer_device, id, sector, ds, data_size, GFP_NOIO);
1955 err = drbd_recv_all_warn(peer_device->connection, data, len);
1969 drbd_csum_ee_size(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv, data_size);
1984 static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size)
1993 page = drbd_alloc_pages(peer_device, 1, 1);
1999 err = drbd_recv_all_warn(peer_device->connection, data, len);
2005 drbd_free_pages(peer_device->device, page, 0);
2009 static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req,
2016 void *dig_in = peer_device->connection->int_dig_in;
2017 void *dig_vv = peer_device->connection->int_dig_vv;
2020 if (peer_device->connection->peer_integrity_tfm) {
2021 digest_size = crypto_shash_digestsize(peer_device->connection->peer_integrity_tfm);
2022 err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size);
2030 peer_device->device->recv_cnt += data_size>>9;
2033 D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector);
2038 err = drbd_recv_all_warn(peer_device->connection, mapped, expect);
2046 drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv);
2048 drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n");
2053 D_ASSERT(peer_device->device, data_size == 0);
2065 struct drbd_peer_device *peer_device = peer_req->peer_device;
2066 struct drbd_device *device = peer_device->device;
2074 err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req);
2079 err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req);
2086 static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector,
2089 struct drbd_device *device = peer_device->device;
2092 peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi);
2145 struct drbd_peer_device *peer_device;
2152 peer_device = conn_peer_device(connection, pi->vnr);
2153 if (!peer_device)
2155 device = peer_device->device;
2168 err = recv_dless_read(peer_device, req, sector, pi->size);
2180 struct drbd_peer_device *peer_device;
2186 peer_device = conn_peer_device(connection, pi->vnr);
2187 if (!peer_device)
2189 device = peer_device->device;
2198 err = recv_resync_read(peer_device, sector, pi);
2203 err = drbd_drain_block(peer_device, pi->size);
2205 drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size);
2239 struct drbd_peer_device *peer_device = peer_req->peer_device;
2240 struct drbd_device *device = peer_device->device;
2250 err = drbd_send_ack(peer_device, pcmd, peer_req);
2254 err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req);
2273 drbd_may_finish_epoch(peer_device->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0));
2282 struct drbd_peer_device *peer_device = peer_req->peer_device;
2285 err = drbd_send_ack(peer_device, ack, peer_req);
2286 dec_unacked(peer_device->device);
2300 struct drbd_connection *connection = peer_req->peer_device->connection;
2321 static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq)
2323 struct drbd_device *device = peer_device->device;
2326 if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) {
2382 static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq)
2384 struct drbd_device *device = peer_device->device;
2389 if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags))
2405 tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries;
2415 timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10;
2480 struct drbd_connection *connection = peer_req->peer_device->connection;
2535 queue_work(connection->ack_sender, &peer_req->peer_device->send_acks_work);
2588 struct drbd_peer_device *peer_device;
2599 peer_device = conn_peer_device(connection, pi->vnr);
2600 if (!peer_device)
2602 device = peer_device->device;
2607 err = wait_for_and_update_peer_seq(peer_device, peer_seq);
2608 drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size);
2610 err2 = drbd_drain_block(peer_device, pi->size);
2623 peer_req = read_in_block(peer_device, p->block_id, sector, pi);
2637 D_ASSERT(peer_device, peer_req->i.size > 0);
2638 D_ASSERT(peer_device, op == REQ_OP_DISCARD);
2639 D_ASSERT(peer_device, peer_req->pages == NULL);
2645 D_ASSERT(peer_device, peer_req->i.size > 0);
2646 D_ASSERT(peer_device, op == REQ_OP_WRITE_ZEROES);
2647 D_ASSERT(peer_device, peer_req->pages == NULL);
2666 nc = rcu_dereference(peer_device->connection->net_conf);
2668 if (peer_device->connection->agreed_pro_version < 100) {
2690 drbd_send_ack(peer_device, P_RECV_ACK, peer_req);
2697 err = wait_for_and_update_peer_seq(peer_device, peer_seq);
2711 update_peer_seq(peer_device, peer_seq);
2838 struct drbd_peer_device *peer_device;
2848 peer_device = conn_peer_device(connection, pi->vnr);
2849 if (!peer_device)
2851 device = peer_device->device;
2872 drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p);
2878 drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p);
2883 drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC);
2893 return drbd_drain_block(peer_device, pi->size);
2899 peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size,
2941 if (drbd_recv_all(peer_device->connection, di->digest, pi->size))
2945 D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89);
2964 peer_device->connection->agreed_pro_version >= 90) {
3052 static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local)
3054 struct drbd_device *device = peer_device->device;
3066 after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p;
3102 rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)
3119 rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)
3135 static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local)
3137 struct drbd_device *device = peer_device->device;
3142 after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p;
3156 hg = drbd_asb_recover_0p(peer_device);
3163 rv = drbd_asb_recover_0p(peer_device);
3168 hg = drbd_asb_recover_0p(peer_device);
3192 static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local)
3194 struct drbd_device *device = peer_device->device;
3199 after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p;
3213 rv = drbd_asb_recover_0p(peer_device);
3218 hg = drbd_asb_recover_0p(peer_device);
3271 struct drbd_peer_device *const peer_device = first_peer_device(device);
3272 struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL;
3362 drbd_warn(peer_device, "Equivalent unrotated UUIDs, but current primary present.\n");
3369 drbd_err(peer_device, "Equivalent unrotated UUIDs, but both are primary. Can not resolve this.\n");
3487 static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device,
3491 struct drbd_device *device = peer_device->device;
3545 nc = rcu_dereference(peer_device->connection->net_conf);
3558 hg = drbd_asb_recover_0p(peer_device);
3561 hg = drbd_asb_recover_1p(peer_device);
3564 hg = drbd_asb_recover_2p(peer_device);
3621 if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) {
3881 struct drbd_peer_device *peer_device;
3894 peer_device = conn_peer_device(connection, pi->vnr);
3895 if (!peer_device)
3897 device = peer_device->device;
3928 err = drbd_recv_all(peer_device->connection, p, header_size);
3933 old_net_conf = peer_device->connection->net_conf;
3959 err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size);
4033 crypto_free_shash(peer_device->connection->verify_tfm);
4034 peer_device->connection->verify_tfm = verify_tfm;
4040 crypto_free_shash(peer_device->connection->csums_tfm);
4041 peer_device->connection->csums_tfm = csums_tfm;
4087 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
4106 struct drbd_peer_device *peer_device;
4116 peer_device = conn_peer_device(connection, pi->vnr);
4117 if (!peer_device)
4119 device = peer_device->device;
4154 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
4229 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
4259 drbd_send_sizes(peer_device, 0, ddsf);
4279 struct drbd_peer_device *peer_device;
4285 peer_device = conn_peer_device(connection, pi->vnr);
4286 if (!peer_device)
4288 device = peer_device->device;
4308 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
4315 peer_device->connection->agreed_pro_version >= 90 &&
4386 struct drbd_peer_device *peer_device;
4392 peer_device = conn_peer_device(connection, pi->vnr);
4393 if (!peer_device)
4395 device = peer_device->device;
4400 if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) &&
4402 drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG);
4410 drbd_send_sr_reply(peer_device, rv);
4443 struct drbd_peer_device *peer_device;
4451 peer_device = conn_peer_device(connection, pi->vnr);
4452 if (!peer_device)
4454 device = peer_device->device;
4568 ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk);
4580 if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags))
4583 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
4605 tl_clear(peer_device->connection);
4608 conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD);
4616 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
4626 drbd_send_uuids(peer_device);
4627 drbd_send_current_state(peer_device);
4640 struct drbd_peer_device *peer_device;
4644 peer_device = conn_peer_device(connection, pi->vnr);
4645 if (!peer_device)
4647 device = peer_device->device;
4680 receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size,
4684 drbd_header_size(peer_device->connection);
4691 drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size);
4696 err = drbd_recv_all(peer_device->connection, p, want);
4700 drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p);
4732 recv_bm_rle_bits(struct drbd_peer_device *peer_device,
4761 drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e);
4764 _drbd_bm_set_bits(peer_device->device, s, e);
4768 drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n",
4801 decode_bitmap_c(struct drbd_peer_device *peer_device,
4807 return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p));
4813 drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding);
4814 conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
4864 struct drbd_peer_device *peer_device;
4869 peer_device = conn_peer_device(connection, pi->vnr);
4870 if (!peer_device)
4872 device = peer_device->device;
4885 err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c);
4901 err = drbd_recv_all(peer_device->connection, p, pi->size);
4904 err = decode_bitmap_c(peer_device, p, &c, pi->size);
4919 err = drbd_recv_header(peer_device->connection, pi);
4968 struct drbd_peer_device *peer_device;
4972 peer_device = conn_peer_device(connection, pi->vnr);
4973 if (!peer_device)
4975 device = peer_device->device;
4994 struct drbd_peer_device *peer_device;
5000 peer_device = conn_peer_device(connection, pi->vnr);
5001 if (!peer_device)
5003 device = peer_device->device;
5014 peer_req = drbd_alloc_peer_req(peer_device, ID_SYNCER, sector,
5050 drbd_send_ack_ex(peer_device, P_NEG_ACK, sector, size, ID_SYNCER);
5155 struct drbd_peer_device *peer_device;
5178 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
5179 struct drbd_device *device = peer_device->device;
5182 drbd_disconnected(peer_device);
5210 static int drbd_disconnected(struct drbd_peer_device *peer_device)
5212 struct drbd_device *device = peer_device->device;
5244 drbd_flush_workqueue(&peer_device->connection->sender_work);
5251 drbd_flush_workqueue(&peer_device->connection->sender_work);
5261 tl_clear(peer_device->connection);
5642 struct drbd_peer_device *peer_device;
5647 peer_device = conn_peer_device(connection, pi->vnr);
5648 if (!peer_device)
5650 device = peer_device->device;
5687 struct drbd_peer_device *peer_device;
5693 peer_device = conn_peer_device(connection, pi->vnr);
5694 if (!peer_device)
5696 device = peer_device->device;
5698 D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89);
5700 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));
5739 struct drbd_peer_device *peer_device;
5746 peer_device = conn_peer_device(connection, pi->vnr);
5747 if (!peer_device)
5749 device = peer_device->device;
5751 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));
5785 struct drbd_peer_device *peer_device;
5792 peer_device = conn_peer_device(connection, pi->vnr);
5793 if (!peer_device)
5795 device = peer_device->device;
5797 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));
5821 struct drbd_peer_device *peer_device;
5826 peer_device = conn_peer_device(connection, pi->vnr);
5827 if (!peer_device)
5829 device = peer_device->device;
5831 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));
5843 struct drbd_peer_device *peer_device;
5849 peer_device = conn_peer_device(connection, pi->vnr);
5850 if (!peer_device)
5852 device = peer_device->device;
5857 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));
5880 struct drbd_peer_device *peer_device;
5886 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
5887 struct drbd_device *device = peer_device->device;
5903 struct drbd_peer_device *peer_device;
5910 peer_device = conn_peer_device(connection, pi->vnr);
5911 if (!peer_device)
5913 device = peer_device->device;
5918 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));
5942 drbd_queue_work(&peer_device->connection->sender_work, &dw->w);
6148 struct drbd_peer_device *peer_device =
6150 struct drbd_connection *connection = peer_device->connection;
6151 struct drbd_device *device = peer_device->device;
6166 struct work_struct send_acks_work alive, which is in the peer_device object */