Lines Matching +full:l2 +full:- +full:ws +full:- +full:latency
1 // SPDX-License-Identifier: GPL-2.0-or-later
7 Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
8 Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
9 Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
69 * page->private being our "next" pointer.
91 if (--n == 0) in page_chain_del()
161 drbd_pp_vacant -= number; in __drbd_alloc_pages()
167 /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD in __drbd_alloc_pages()
168 * "criss-cross" setup, that might cause write-out on some other DRBD, in __drbd_alloc_pages()
204 list_for_each_entry_safe(peer_req, tmp, &device->net_ee, w.list) { in reclaim_finished_net_peer_reqs()
207 list_move(&peer_req->w.list, to_be_freed); in reclaim_finished_net_peer_reqs()
216 spin_lock_irq(&device->resource->req_lock); in drbd_reclaim_net_peer_reqs()
218 spin_unlock_irq(&device->resource->req_lock); in drbd_reclaim_net_peer_reqs()
229 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { in conn_reclaim_net_peer_reqs()
230 struct drbd_device *device = peer_device->device; in conn_reclaim_net_peer_reqs()
231 if (!atomic_read(&device->pp_in_use_by_net)) in conn_reclaim_net_peer_reqs()
234 kref_get(&device->kref); in conn_reclaim_net_peer_reqs()
237 kref_put(&device->kref, drbd_destroy_device); in conn_reclaim_net_peer_reqs()
244 * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled)
256 * We do not use max-buffers as hard limit, because it could lead to
257 * congestion and further to a distributed deadlock during online-verify or
258 * (checksum based) resync, if the max-buffers, socket buffer sizes and
259 * resync-rate settings are mis-configured.
261 * Returns a page chain linked via page->private.
266 struct drbd_device *device = peer_device->device; in drbd_alloc_pages()
273 nc = rcu_dereference(peer_device->connection->net_conf); in drbd_alloc_pages()
274 mxb = nc ? nc->max_buffers : 1000000; in drbd_alloc_pages()
277 if (atomic_read(&device->pp_in_use) < mxb) in drbd_alloc_pages()
282 if (page && atomic_read(&device->pp_in_use_by_net) > 512) in drbd_alloc_pages()
290 if (atomic_read(&device->pp_in_use) < mxb) { in drbd_alloc_pages()
310 atomic_add(number, &device->pp_in_use); in drbd_alloc_pages()
315 * Is also used from inside an other spin_lock_irq(&resource->req_lock);
320 atomic_t *a = is_net ? &device->pp_in_use_by_net : &device->pp_in_use; in drbd_free_pages()
364 struct drbd_device *device = peer_device->device; in drbd_alloc_peer_req()
367 unsigned nr_pages = (payload_size + PAGE_SIZE -1) >> PAGE_SHIFT; in drbd_alloc_peer_req()
387 INIT_LIST_HEAD(&peer_req->w.list); in drbd_alloc_peer_req()
388 drbd_clear_interval(&peer_req->i); in drbd_alloc_peer_req()
389 peer_req->i.size = request_size; in drbd_alloc_peer_req()
390 peer_req->i.sector = sector; in drbd_alloc_peer_req()
391 peer_req->submit_jif = jiffies; in drbd_alloc_peer_req()
392 peer_req->peer_device = peer_device; in drbd_alloc_peer_req()
393 peer_req->pages = page; in drbd_alloc_peer_req()
398 peer_req->block_id = id; in drbd_alloc_peer_req()
411 if (peer_req->flags & EE_HAS_DIGEST) in __drbd_free_peer_req()
412 kfree(peer_req->digest); in __drbd_free_peer_req()
413 drbd_free_pages(device, peer_req->pages, is_net); in __drbd_free_peer_req()
414 D_ASSERT(device, atomic_read(&peer_req->pending_bios) == 0); in __drbd_free_peer_req()
415 D_ASSERT(device, drbd_interval_empty(&peer_req->i)); in __drbd_free_peer_req()
416 if (!expect(!(peer_req->flags & EE_CALL_AL_COMPLETE_IO))) { in __drbd_free_peer_req()
417 peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; in __drbd_free_peer_req()
418 drbd_al_complete_io(device, &peer_req->i); in __drbd_free_peer_req()
428 int is_net = list == &device->net_ee; in drbd_free_peer_reqs()
430 spin_lock_irq(&device->resource->req_lock); in drbd_free_peer_reqs()
432 spin_unlock_irq(&device->resource->req_lock); in drbd_free_peer_reqs()
451 spin_lock_irq(&device->resource->req_lock); in drbd_finish_peer_reqs()
453 list_splice_init(&device->done_ee, &work_list); in drbd_finish_peer_reqs()
454 spin_unlock_irq(&device->resource->req_lock); in drbd_finish_peer_reqs()
467 err2 = peer_req->w.cb(&peer_req->w, !!err); in drbd_finish_peer_reqs()
472 wake_up(&device->ee_wait); in drbd_finish_peer_reqs()
485 prepare_to_wait(&device->ee_wait, &wait, TASK_UNINTERRUPTIBLE); in _drbd_wait_ee_list_empty()
486 spin_unlock_irq(&device->resource->req_lock); in _drbd_wait_ee_list_empty()
488 finish_wait(&device->ee_wait, &wait); in _drbd_wait_ee_list_empty()
489 spin_lock_irq(&device->resource->req_lock); in _drbd_wait_ee_list_empty()
496 spin_lock_irq(&device->resource->req_lock); in drbd_wait_ee_list_empty()
498 spin_unlock_irq(&device->resource->req_lock); in drbd_wait_ee_list_empty()
518 rv = drbd_recv_short(connection->data.socket, buf, size, 0); in drbd_recv()
521 if (rv == -ECONNRESET) in drbd_recv()
523 else if (rv != -ERESTARTSYS) in drbd_recv()
526 if (test_bit(DISCONNECT_SENT, &connection->flags)) { in drbd_recv()
529 t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; in drbd_recv()
532 t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); in drbd_recv()
554 err = -EIO; in drbd_recv_all()
580 sock->sk->sk_sndbuf = snd; in drbd_setbufsize()
581 sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; in drbd_setbufsize()
584 sock->sk->sk_rcvbuf = rcv; in drbd_setbufsize()
585 sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; in drbd_setbufsize()
601 nc = rcu_dereference(connection->net_conf); in drbd_try_connect()
606 sndbuf_size = nc->sndbuf_size; in drbd_try_connect()
607 rcvbuf_size = nc->rcvbuf_size; in drbd_try_connect()
608 connect_int = nc->connect_int; in drbd_try_connect()
611 my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); in drbd_try_connect()
612 memcpy(&src_in6, &connection->my_addr, my_addr_len); in drbd_try_connect()
614 if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) in drbd_try_connect()
617 ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ in drbd_try_connect()
619 peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); in drbd_try_connect()
620 memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); in drbd_try_connect()
623 err = sock_create_kern(&init_net, ((struct sockaddr *)&src_in6)->sa_family, in drbd_try_connect()
630 sock->sk->sk_rcvtimeo = in drbd_try_connect()
631 sock->sk->sk_sndtimeo = connect_int * HZ; in drbd_try_connect()
642 err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); in drbd_try_connect()
650 err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); in drbd_try_connect()
658 switch (-err) { in drbd_try_connect()
687 struct accept_wait_data *ad = sk->sk_user_data; in drbd_incoming_connection()
690 state_change = ad->original_sk_state_change; in drbd_incoming_connection()
691 if (sk->sk_state == TCP_ESTABLISHED) in drbd_incoming_connection()
692 complete(&ad->door_bell); in drbd_incoming_connection()
705 nc = rcu_dereference(connection->net_conf); in prepare_listen_socket()
708 return -EIO; in prepare_listen_socket()
710 sndbuf_size = nc->sndbuf_size; in prepare_listen_socket()
711 rcvbuf_size = nc->rcvbuf_size; in prepare_listen_socket()
714 my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); in prepare_listen_socket()
715 memcpy(&my_addr, &connection->my_addr, my_addr_len); in prepare_listen_socket()
718 err = sock_create_kern(&init_net, ((struct sockaddr *)&my_addr)->sa_family, in prepare_listen_socket()
725 s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ in prepare_listen_socket()
729 err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); in prepare_listen_socket()
733 ad->s_listen = s_listen; in prepare_listen_socket()
734 write_lock_bh(&s_listen->sk->sk_callback_lock); in prepare_listen_socket()
735 ad->original_sk_state_change = s_listen->sk->sk_state_change; in prepare_listen_socket()
736 s_listen->sk->sk_state_change = drbd_incoming_connection; in prepare_listen_socket()
737 s_listen->sk->sk_user_data = ad; in prepare_listen_socket()
738 write_unlock_bh(&s_listen->sk->sk_callback_lock); in prepare_listen_socket()
741 err = s_listen->ops->listen(s_listen, 5); in prepare_listen_socket()
750 if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { in prepare_listen_socket()
756 return -EIO; in prepare_listen_socket()
761 write_lock_bh(&sk->sk_callback_lock); in unregister_state_change()
762 sk->sk_state_change = ad->original_sk_state_change; in unregister_state_change()
763 sk->sk_user_data = NULL; in unregister_state_change()
764 write_unlock_bh(&sk->sk_callback_lock); in unregister_state_change()
774 nc = rcu_dereference(connection->net_conf); in drbd_wait_for_connect()
779 connect_int = nc->connect_int; in drbd_wait_for_connect()
784 timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; in drbd_wait_for_connect()
786 err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); in drbd_wait_for_connect()
790 err = kernel_accept(ad->s_listen, &s_estab, 0); in drbd_wait_for_connect()
792 if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { in drbd_wait_for_connect()
799 unregister_state_change(s_estab->sk, ad); in drbd_wait_for_connect()
810 return -EIO; in send_first_packet()
822 nc = rcu_dereference(connection->net_conf); in receive_first_packet()
825 return -EIO; in receive_first_packet()
827 sock->sk->sk_rcvtimeo = nc->ping_timeo * 4 * HZ / 10; in receive_first_packet()
830 err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); in receive_first_packet()
833 err = -EIO; in receive_first_packet()
836 err = decode_header(connection, connection->data.rbuf, &pi); in receive_first_packet()
843 * drbd_socket_okay() - Free the socket if its connection is not okay
856 if (rr > 0 || rr == -EAGAIN) { in drbd_socket_okay()
877 nc = rcu_dereference(connection->net_conf); in connection_established()
878 timeout = (nc->sock_check_timeo ?: nc->ping_timeo) * HZ / 10; in connection_established()
892 struct drbd_device *device = peer_device->device; in drbd_connected()
895 atomic_set(&device->packet_seq, 0); in drbd_connected()
896 device->peer_seq = 0; in drbd_connected()
898 device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? in drbd_connected()
899 &peer_device->connection->cstate_mutex : in drbd_connected()
900 &device->own_state_mutex; in drbd_connected()
909 clear_bit(USE_DEGR_WFC_T, &device->flags); in drbd_connected()
910 clear_bit(RESIZE_PENDING, &device->flags); in drbd_connected()
911 atomic_set(&device->ap_in_flight, 0); in drbd_connected()
912 mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ in drbd_connected()
920 * -1 peer talks different language,
922 * -2 We do not have a network config...
937 clear_bit(DISCONNECT_SENT, &connection->flags); in conn_connect()
939 return -2; in conn_connect()
942 sock.sbuf = connection->data.sbuf; in conn_connect()
943 sock.rbuf = connection->data.rbuf; in conn_connect()
946 msock.sbuf = connection->meta.sbuf; in conn_connect()
947 msock.rbuf = connection->meta.rbuf; in conn_connect()
951 connection->agreed_pro_version = 80; in conn_connect()
965 clear_bit(RESOLVE_CONFLICTS, &connection->flags); in conn_connect()
994 set_bit(RESOLVE_CONFLICTS, &connection->flags); in conn_connect()
1012 if (connection->cstate <= C_DISCONNECTING) in conn_connect()
1017 if (get_t_state(&connection->receiver) == EXITING) in conn_connect()
1027 sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ in conn_connect()
1028 msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ in conn_connect()
1030 sock.socket->sk->sk_allocation = GFP_NOIO; in conn_connect()
1031 msock.socket->sk->sk_allocation = GFP_NOIO; in conn_connect()
1033 sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; in conn_connect()
1034 msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; in conn_connect()
1037 * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; in conn_connect()
1038 * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; in conn_connect()
1042 nc = rcu_dereference(connection->net_conf); in conn_connect()
1044 sock.socket->sk->sk_sndtimeo = in conn_connect()
1045 sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; in conn_connect()
1047 msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; in conn_connect()
1048 timeout = nc->timeout * HZ / 10; in conn_connect()
1049 discard_my_data = nc->discard_my_data; in conn_connect()
1052 msock.socket->sk->sk_sndtimeo = timeout; in conn_connect()
1056 tcp_sock_set_nodelay(sock.socket->sk); in conn_connect()
1057 tcp_sock_set_nodelay(msock.socket->sk); in conn_connect()
1059 connection->data.socket = sock.socket; in conn_connect()
1060 connection->meta.socket = msock.socket; in conn_connect()
1061 connection->last_received = jiffies; in conn_connect()
1067 if (connection->cram_hmac_tfm) { in conn_connect()
1070 case -1: in conn_connect()
1072 return -1; in conn_connect()
1079 connection->data.socket->sk->sk_sndtimeo = timeout; in conn_connect()
1080 connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; in conn_connect()
1082 if (drbd_send_protocol(connection) == -EOPNOTSUPP) in conn_connect()
1083 return -1; in conn_connect()
1085 /* Prevent a race between resync-handshake and in conn_connect()
1092 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) in conn_connect()
1093 mutex_lock(peer_device->device->state_mutex); in conn_connect()
1096 spin_lock_irq(&connection->resource->req_lock); in conn_connect()
1097 set_bit(STATE_SENT, &connection->flags); in conn_connect()
1098 spin_unlock_irq(&connection->resource->req_lock); in conn_connect()
1100 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) in conn_connect()
1101 mutex_unlock(peer_device->device->state_mutex); in conn_connect()
1104 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { in conn_connect()
1105 struct drbd_device *device = peer_device->device; in conn_connect()
1106 kref_get(&device->kref); in conn_connect()
1110 set_bit(DISCARD_MY_DATA, &device->flags); in conn_connect()
1112 clear_bit(DISCARD_MY_DATA, &device->flags); in conn_connect()
1115 kref_put(&device->kref, drbd_destroy_device); in conn_connect()
1121 if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { in conn_connect()
1122 clear_bit(STATE_SENT, &connection->flags); in conn_connect()
1126 drbd_thread_start(&connection->ack_receiver); in conn_connect()
1129 connection->ack_sender = in conn_connect()
1130 alloc_ordered_workqueue("drbd_as_%s", WQ_MEM_RECLAIM, connection->resource->name); in conn_connect()
1131 if (!connection->ack_sender) { in conn_connect()
1136 mutex_lock(&connection->resource->conf_update); in conn_connect()
1137 /* The discard_my_data flag is a single-shot modifier to the next in conn_connect()
1141 connection->net_conf->discard_my_data = 0; in conn_connect()
1142 mutex_unlock(&connection->resource->conf_update); in conn_connect()
1153 return -1; in conn_connect()
1163 if (h->pad != 0) { in decode_header()
1165 return -EINVAL; in decode_header()
1167 pi->vnr = be16_to_cpu(h->volume); in decode_header()
1168 pi->cmd = be16_to_cpu(h->command); in decode_header()
1169 pi->size = be32_to_cpu(h->length); in decode_header()
1173 pi->cmd = be16_to_cpu(h->command); in decode_header()
1174 pi->size = be32_to_cpu(h->length); in decode_header()
1175 pi->vnr = 0; in decode_header()
1179 pi->cmd = be16_to_cpu(h->command); in decode_header()
1180 pi->size = be16_to_cpu(h->length); in decode_header()
1181 pi->vnr = 0; in decode_header()
1185 connection->agreed_pro_version); in decode_header()
1186 return -EINVAL; in decode_header()
1188 pi->data = header + header_size; in decode_header()
1194 if (current->plug == &connection->receiver_plug) { in drbd_unplug_all_devices()
1195 blk_finish_plug(&connection->receiver_plug); in drbd_unplug_all_devices()
1196 blk_start_plug(&connection->receiver_plug); in drbd_unplug_all_devices()
1202 void *buffer = connection->data.rbuf; in drbd_recv_header()
1210 connection->last_received = jiffies; in drbd_recv_header()
1217 void *buffer = connection->data.rbuf; in drbd_recv_header_maybe_unplug()
1221 err = drbd_recv_short(connection->data.socket, buffer, size, MSG_NOSIGNAL|MSG_DONTWAIT); in drbd_recv_header_maybe_unplug()
1224 * application latency, try to drain the backend queues as in drbd_recv_header_maybe_unplug()
1227 if (err == -EAGAIN) { in drbd_recv_header_maybe_unplug()
1228 tcp_sock_set_quickack(connection->data.socket->sk, 2); in drbd_recv_header_maybe_unplug()
1233 size -= err; in drbd_recv_header_maybe_unplug()
1240 err = decode_header(connection, connection->data.rbuf, pi); in drbd_recv_header_maybe_unplug()
1241 connection->last_received = jiffies; in drbd_recv_header_maybe_unplug()
1261 struct one_flush_context *octx = bio->bi_private; in one_flush_endio()
1262 struct drbd_device *device = octx->device; in one_flush_endio()
1263 struct issue_flush_context *ctx = octx->ctx; in one_flush_endio()
1265 if (bio->bi_status) { in one_flush_endio()
1266 ctx->error = blk_status_to_errno(bio->bi_status); in one_flush_endio()
1267 drbd_info(device, "local disk FLUSH FAILED with status %d\n", bio->bi_status); in one_flush_endio()
1272 clear_bit(FLUSH_PENDING, &device->flags); in one_flush_endio()
1274 kref_put(&device->kref, drbd_destroy_device); in one_flush_endio()
1276 if (atomic_dec_and_test(&ctx->pending)) in one_flush_endio()
1277 complete(&ctx->done); in one_flush_endio()
1293 ctx->error = -ENOMEM; in submit_one_flush()
1295 kref_put(&device->kref, drbd_destroy_device); in submit_one_flush()
1299 octx->device = device; in submit_one_flush()
1300 octx->ctx = ctx; in submit_one_flush()
1301 bio_set_dev(bio, device->ldev->backing_bdev); in submit_one_flush()
1302 bio->bi_private = octx; in submit_one_flush()
1303 bio->bi_end_io = one_flush_endio; in submit_one_flush()
1304 bio->bi_opf = REQ_OP_FLUSH | REQ_PREFLUSH; in submit_one_flush()
1306 device->flush_jif = jiffies; in submit_one_flush()
1307 set_bit(FLUSH_PENDING, &device->flags); in submit_one_flush()
1308 atomic_inc(&ctx->pending); in submit_one_flush()
1314 if (connection->resource->write_ordering >= WO_BDEV_FLUSH) { in drbd_flush()
1324 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { in drbd_flush()
1325 struct drbd_device *device = peer_device->device; in drbd_flush()
1329 kref_get(&device->kref); in drbd_flush()
1339 * if disk-timeout is set? */ in drbd_flush()
1346 * if (rv == -EOPNOTSUPP) */ in drbd_flush()
1348 drbd_bump_write_ordering(connection->resource, NULL, WO_DRAIN_IO); in drbd_flush()
1354 * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it.
1367 spin_lock(&connection->epoch_lock); in drbd_may_finish_epoch()
1371 epoch_size = atomic_read(&epoch->epoch_size); in drbd_may_finish_epoch()
1375 atomic_dec(&epoch->active); in drbd_may_finish_epoch()
1378 set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); in drbd_may_finish_epoch()
1386 atomic_read(&epoch->active) == 0 && in drbd_may_finish_epoch()
1387 (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { in drbd_may_finish_epoch()
1389 spin_unlock(&connection->epoch_lock); in drbd_may_finish_epoch()
1390 drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); in drbd_may_finish_epoch()
1391 spin_lock(&connection->epoch_lock); in drbd_may_finish_epoch()
1396 if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) in drbd_may_finish_epoch()
1397 dec_unacked(epoch->connection); in drbd_may_finish_epoch()
1400 if (connection->current_epoch != epoch) { in drbd_may_finish_epoch()
1401 next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); in drbd_may_finish_epoch()
1402 list_del(&epoch->list); in drbd_may_finish_epoch()
1404 connection->epochs--; in drbd_may_finish_epoch()
1410 epoch->flags = 0; in drbd_may_finish_epoch()
1411 atomic_set(&epoch->epoch_size, 0); in drbd_may_finish_epoch()
1412 /* atomic_set(&epoch->active, 0); is already zero */ in drbd_may_finish_epoch()
1424 spin_unlock(&connection->epoch_lock); in drbd_may_finish_epoch()
1434 dc = rcu_dereference(bdev->disk_conf); in max_allowed_wo()
1436 if (wo == WO_BDEV_FLUSH && !dc->disk_flushes) in max_allowed_wo()
1438 if (wo == WO_DRAIN_IO && !dc->disk_drain) in max_allowed_wo()
1445 * drbd_bump_write_ordering() - Fall back to an other write ordering method
1460 pwo = resource->write_ordering; in drbd_bump_write_ordering()
1464 idr_for_each_entry(&resource->devices, device, vnr) { in drbd_bump_write_ordering()
1466 wo = max_allowed_wo(device->ldev, wo); in drbd_bump_write_ordering()
1467 if (device->ldev == bdev) in drbd_bump_write_ordering()
1478 resource->write_ordering = wo; in drbd_bump_write_ordering()
1479 if (pwo != resource->write_ordering || wo == WO_BDEV_FLUSH) in drbd_bump_write_ordering()
1480 …drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_or… in drbd_bump_write_ordering()
1485 * Drivers have to "announce" q->limits.max_write_zeroes_sectors, or it
1489 * And dm-thin does not do this (yet), mostly because in general it has
1491 * https://www.mail-archive.com/dm-devel%40redhat.com/msg07965.html
1492 * https://www.redhat.com/archives/dm-devel/2018-January/msg00271.html
1494 * We *may* ignore the discard-zeroes-data setting, if so configured.
1500 * LVM version: 2.02.115(2)-RHEL7 (2015-01-28)
1501 * Library version: 1.02.93-RHEL7 (2015-01-28)
1506 * we zero-out the initial (and/or) trailing unaligned partial chunks,
1515 struct block_device *bdev = device->ldev->backing_bdev; in drbd_issue_discard_or_zero_out()
1525 /* Zero-sector (unknown) and one-sector granularities are the same. */ in drbd_issue_discard_or_zero_out()
1526 granularity = max(q->limits.discard_granularity >> 9, 1U); in drbd_issue_discard_or_zero_out()
1529 max_discard_sectors = min(q->limits.max_discard_sectors, (1U << 22)); in drbd_issue_discard_or_zero_out()
1530 max_discard_sectors -= max_discard_sectors % granularity; in drbd_issue_discard_or_zero_out()
1541 /* start + gran - (start + gran - align) % gran */ in drbd_issue_discard_or_zero_out()
1542 tmp = start + granularity - alignment; in drbd_issue_discard_or_zero_out()
1543 tmp = start + granularity - sector_div(tmp, granularity); in drbd_issue_discard_or_zero_out()
1545 nr = tmp - start; in drbd_issue_discard_or_zero_out()
1549 nr_sectors -= nr; in drbd_issue_discard_or_zero_out()
1554 nr_sectors -= max_discard_sectors; in drbd_issue_discard_or_zero_out()
1563 nr -= (unsigned int)nr % granularity; in drbd_issue_discard_or_zero_out()
1566 nr_sectors -= nr; in drbd_issue_discard_or_zero_out()
1580 struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); in can_do_reliable_discards()
1588 dc = rcu_dereference(device->ldev->disk_conf); in can_do_reliable_discards()
1589 can_do = dc->discard_zeroes_if_aligned; in can_do_reliable_discards()
1597 * read-back zeroes in discarded ranges, we fall back to in drbd_issue_peer_discard_or_zero_out()
1598 * zero-out. Unless configuration specifically requested in drbd_issue_peer_discard_or_zero_out()
1601 peer_req->flags |= EE_ZEROOUT; in drbd_issue_peer_discard_or_zero_out()
1603 if (drbd_issue_discard_or_zero_out(device, peer_req->i.sector, in drbd_issue_peer_discard_or_zero_out()
1604 peer_req->i.size >> 9, peer_req->flags & (EE_ZEROOUT|EE_TRIM))) in drbd_issue_peer_discard_or_zero_out()
1605 peer_req->flags |= EE_WAS_ERROR; in drbd_issue_peer_discard_or_zero_out()
1612 struct block_device *bdev = device->ldev->backing_bdev; in drbd_issue_peer_wsame()
1613 sector_t s = peer_req->i.sector; in drbd_issue_peer_wsame()
1614 sector_t nr = peer_req->i.size >> 9; in drbd_issue_peer_wsame()
1615 if (blkdev_issue_write_same(bdev, s, nr, GFP_NOIO, peer_req->pages)) in drbd_issue_peer_wsame()
1616 peer_req->flags |= EE_WAS_ERROR; in drbd_issue_peer_wsame()
1630 * -ENOMEM if we could not allocate enough bios,
1631 * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a
1644 struct page *page = peer_req->pages; in drbd_submit_peer_request()
1645 sector_t sector = peer_req->i.sector; in drbd_submit_peer_request()
1646 unsigned data_size = peer_req->i.size; in drbd_submit_peer_request()
1648 unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; in drbd_submit_peer_request()
1649 int err = -ENOMEM; in drbd_submit_peer_request()
1657 if (peer_req->flags & (EE_TRIM|EE_WRITE_SAME|EE_ZEROOUT)) { in drbd_submit_peer_request()
1660 conn_wait_active_ee_empty(peer_req->peer_device->connection); in drbd_submit_peer_request()
1663 peer_req->submit_jif = jiffies; in drbd_submit_peer_request()
1664 peer_req->flags |= EE_SUBMITTED; in drbd_submit_peer_request()
1668 if (list_empty(&peer_req->w.list)) { in drbd_submit_peer_request()
1669 spin_lock_irq(&device->resource->req_lock); in drbd_submit_peer_request()
1670 list_add_tail(&peer_req->w.list, &device->active_ee); in drbd_submit_peer_request()
1671 spin_unlock_irq(&device->resource->req_lock); in drbd_submit_peer_request()
1674 if (peer_req->flags & (EE_TRIM|EE_ZEROOUT)) in drbd_submit_peer_request()
1695 /* > peer_req->i.sector, unless this is the first bio */ in drbd_submit_peer_request()
1696 bio->bi_iter.bi_sector = sector; in drbd_submit_peer_request()
1697 bio_set_dev(bio, device->ldev->backing_bdev); in drbd_submit_peer_request()
1699 bio->bi_private = peer_req; in drbd_submit_peer_request()
1700 bio->bi_end_io = drbd_peer_request_endio; in drbd_submit_peer_request()
1702 bio->bi_next = bios; in drbd_submit_peer_request()
1710 data_size -= len; in drbd_submit_peer_request()
1712 --nr_pages; in drbd_submit_peer_request()
1717 atomic_set(&peer_req->pending_bios, n_bios); in drbd_submit_peer_request()
1719 peer_req->submit_jif = jiffies; in drbd_submit_peer_request()
1720 peer_req->flags |= EE_SUBMITTED; in drbd_submit_peer_request()
1723 bios = bios->bi_next; in drbd_submit_peer_request()
1724 bio->bi_next = NULL; in drbd_submit_peer_request()
1733 bios = bios->bi_next; in drbd_submit_peer_request()
1742 struct drbd_interval *i = &peer_req->i; in drbd_remove_epoch_entry_interval()
1744 drbd_remove_interval(&device->write_requests, i); in drbd_remove_epoch_entry_interval()
1748 if (i->waiting) in drbd_remove_epoch_entry_interval()
1749 wake_up(&device->misc_wait); in drbd_remove_epoch_entry_interval()
1758 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { in conn_wait_active_ee_empty()
1759 struct drbd_device *device = peer_device->device; in conn_wait_active_ee_empty()
1761 kref_get(&device->kref); in conn_wait_active_ee_empty()
1763 drbd_wait_ee_list_empty(device, &device->active_ee); in conn_wait_active_ee_empty()
1764 kref_put(&device->kref, drbd_destroy_device); in conn_wait_active_ee_empty()
1773 struct p_barrier *p = pi->data; in receive_Barrier()
1779 connection->current_epoch->barrier_nr = p->barrier; in receive_Barrier()
1780 connection->current_epoch->connection = connection; in receive_Barrier()
1781 rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); in receive_Barrier()
1788 switch (connection->resource->write_ordering) { in receive_Barrier()
1807 if (atomic_read(&connection->current_epoch->epoch_size)) { in receive_Barrier()
1815 drbd_err(connection, "Strangeness in connection->write_ordering %d\n", in receive_Barrier()
1816 connection->resource->write_ordering); in receive_Barrier()
1817 return -EIO; in receive_Barrier()
1820 epoch->flags = 0; in receive_Barrier()
1821 atomic_set(&epoch->epoch_size, 0); in receive_Barrier()
1822 atomic_set(&epoch->active, 0); in receive_Barrier()
1824 spin_lock(&connection->epoch_lock); in receive_Barrier()
1825 if (atomic_read(&connection->current_epoch->epoch_size)) { in receive_Barrier()
1826 list_add(&epoch->list, &connection->current_epoch->list); in receive_Barrier()
1827 connection->current_epoch = epoch; in receive_Barrier()
1828 connection->epochs++; in receive_Barrier()
1833 spin_unlock(&connection->epoch_lock); in receive_Barrier()
1843 unsigned int tmp = r->i.size; in drbd_csum_ee_size()
1844 r->i.size = payload_size; in drbd_csum_ee_size()
1846 r->i.size = tmp; in drbd_csum_ee_size()
1862 struct drbd_device *device = peer_device->device; in read_in_block()
1863 const sector_t capacity = get_capacity(device->vdisk); in read_in_block()
1867 unsigned int data_size = pi->size, ds; in read_in_block()
1868 void *dig_in = peer_device->connection->int_dig_in; in read_in_block()
1869 void *dig_vv = peer_device->connection->int_dig_vv; in read_in_block()
1871 struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL; in read_in_block()
1872 struct p_trim *zeroes = (pi->cmd == P_ZEROES) ? pi->data : NULL; in read_in_block()
1873 struct p_trim *wsame = (pi->cmd == P_WSAME) ? pi->data : NULL; in read_in_block()
1876 if (!trim && peer_device->connection->peer_integrity_tfm) { in read_in_block()
1877 digest_size = crypto_shash_digestsize(peer_device->connection->peer_integrity_tfm); in read_in_block()
1882 err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); in read_in_block()
1885 data_size -= digest_size; in read_in_block()
1893 ds = be32_to_cpu(trim->size); in read_in_block()
1897 ds = be32_to_cpu(zeroes->size); in read_in_block()
1899 if (data_size != queue_logical_block_size(device->rq_queue)) { in read_in_block()
1901 data_size, queue_logical_block_size(device->rq_queue)); in read_in_block()
1904 if (data_size != bdev_logical_block_size(device->ldev->backing_bdev)) { in read_in_block()
1906 data_size, bdev_logical_block_size(device->ldev->backing_bdev)); in read_in_block()
1909 ds = be32_to_cpu(wsame->size); in read_in_block()
1930 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD in read_in_block()
1931 * "criss-cross" setup, that might cause write-out on some other DRBD, in read_in_block()
1937 peer_req->flags |= EE_WRITE; in read_in_block()
1939 peer_req->flags |= EE_TRIM; in read_in_block()
1943 peer_req->flags |= EE_ZEROOUT; in read_in_block()
1947 peer_req->flags |= EE_WRITE_SAME; in read_in_block()
1951 page = peer_req->pages; in read_in_block()
1955 err = drbd_recv_all_warn(peer_device->connection, data, len); in read_in_block()
1958 data[0] = data[0] ^ (unsigned long)-1; in read_in_block()
1965 ds -= len; in read_in_block()
1969 drbd_csum_ee_size(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv, data_size); in read_in_block()
1977 device->recv_cnt += data_size >> 9; in read_in_block()
1999 err = drbd_recv_all_warn(peer_device->connection, data, len); in drbd_drain_block()
2002 data_size -= len; in drbd_drain_block()
2005 drbd_free_pages(peer_device->device, page, 0); in drbd_drain_block()
2016 void *dig_in = peer_device->connection->int_dig_in; in recv_dless_read()
2017 void *dig_vv = peer_device->connection->int_dig_vv; in recv_dless_read()
2020 if (peer_device->connection->peer_integrity_tfm) { in recv_dless_read()
2021 digest_size = crypto_shash_digestsize(peer_device->connection->peer_integrity_tfm); in recv_dless_read()
2022 err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); in recv_dless_read()
2025 data_size -= digest_size; in recv_dless_read()
2030 peer_device->device->recv_cnt += data_size>>9; in recv_dless_read()
2032 bio = req->master_bio; in recv_dless_read()
2033 D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); in recv_dless_read()
2038 err = drbd_recv_all_warn(peer_device->connection, mapped, expect); in recv_dless_read()
2042 data_size -= expect; in recv_dless_read()
2046 drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); in recv_dless_read()
2049 return -EINVAL; in recv_dless_read()
2053 D_ASSERT(peer_device->device, data_size == 0); in recv_dless_read()
2065 struct drbd_peer_device *peer_device = peer_req->peer_device; in e_end_resync_block()
2066 struct drbd_device *device = peer_device->device; in e_end_resync_block()
2067 sector_t sector = peer_req->i.sector; in e_end_resync_block()
2070 D_ASSERT(device, drbd_interval_empty(&peer_req->i)); in e_end_resync_block()
2072 if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { in e_end_resync_block()
2073 drbd_set_in_sync(device, sector, peer_req->i.size); in e_end_resync_block()
2077 drbd_rs_failed_io(device, sector, peer_req->i.size); in e_end_resync_block()
2089 struct drbd_device *device = peer_device->device; in recv_resync_read()
2102 peer_req->w.cb = e_end_resync_block; in recv_resync_read()
2103 peer_req->submit_jif = jiffies; in recv_resync_read()
2105 spin_lock_irq(&device->resource->req_lock); in recv_resync_read()
2106 list_add_tail(&peer_req->w.list, &device->sync_ee); in recv_resync_read()
2107 spin_unlock_irq(&device->resource->req_lock); in recv_resync_read()
2109 atomic_add(pi->size >> 9, &device->rs_sect_ev); in recv_resync_read()
2115 drbd_err(device, "submit failed, triggering re-connect\n"); in recv_resync_read()
2116 spin_lock_irq(&device->resource->req_lock); in recv_resync_read()
2117 list_del(&peer_req->w.list); in recv_resync_read()
2118 spin_unlock_irq(&device->resource->req_lock); in recv_resync_read()
2123 return -EIO; in recv_resync_read()
2134 if (drbd_contains_interval(root, sector, &req->i) && req->i.local) in find_request()
2150 struct p_data *p = pi->data; in receive_DataReply()
2152 peer_device = conn_peer_device(connection, pi->vnr); in receive_DataReply()
2154 return -EIO; in receive_DataReply()
2155 device = peer_device->device; in receive_DataReply()
2157 sector = be64_to_cpu(p->sector); in receive_DataReply()
2159 spin_lock_irq(&device->resource->req_lock); in receive_DataReply()
2160 req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); in receive_DataReply()
2161 spin_unlock_irq(&device->resource->req_lock); in receive_DataReply()
2163 return -EIO; in receive_DataReply()
2165 /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid in receive_DataReply()
2168 err = recv_dless_read(peer_device, req, sector, pi->size); in receive_DataReply()
2173 * in case we are "on-disconnect: freeze" */ in receive_DataReply()
2184 struct p_data *p = pi->data; in receive_RSDataReply()
2186 peer_device = conn_peer_device(connection, pi->vnr); in receive_RSDataReply()
2188 return -EIO; in receive_RSDataReply()
2189 device = peer_device->device; in receive_RSDataReply()
2191 sector = be64_to_cpu(p->sector); in receive_RSDataReply()
2192 D_ASSERT(device, p->block_id == ID_SYNCER); in receive_RSDataReply()
2203 err = drbd_drain_block(peer_device, pi->size); in receive_RSDataReply()
2205 drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); in receive_RSDataReply()
2208 atomic_add(pi->size >> 9, &device->rs_sect_in); in receive_RSDataReply()
2219 drbd_for_each_overlap(i, &device->write_requests, sector, size) { in restart_conflicting_writes()
2220 if (!i->local) in restart_conflicting_writes()
2223 if (req->rq_state & RQ_LOCAL_PENDING || in restart_conflicting_writes()
2224 !(req->rq_state & RQ_POSTPONED)) in restart_conflicting_writes()
2239 struct drbd_peer_device *peer_device = peer_req->peer_device; in e_end_block()
2240 struct drbd_device *device = peer_device->device; in e_end_block()
2241 sector_t sector = peer_req->i.sector; in e_end_block()
2244 if (peer_req->flags & EE_SEND_WRITE_ACK) { in e_end_block()
2245 if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { in e_end_block()
2246 pcmd = (device->state.conn >= C_SYNC_SOURCE && in e_end_block()
2247 device->state.conn <= C_PAUSED_SYNC_T && in e_end_block()
2248 peer_req->flags & EE_MAY_SET_IN_SYNC) ? in e_end_block()
2252 drbd_set_in_sync(device, sector, peer_req->i.size); in e_end_block()
2263 if (peer_req->flags & EE_IN_INTERVAL_TREE) { in e_end_block()
2264 spin_lock_irq(&device->resource->req_lock); in e_end_block()
2265 D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); in e_end_block()
2267 if (peer_req->flags & EE_RESTART_REQUESTS) in e_end_block()
2268 restart_conflicting_writes(device, sector, peer_req->i.size); in e_end_block()
2269 spin_unlock_irq(&device->resource->req_lock); in e_end_block()
2271 D_ASSERT(device, drbd_interval_empty(&peer_req->i)); in e_end_block()
2273 …drbd_may_finish_epoch(peer_device->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)… in e_end_block()
2282 struct drbd_peer_device *peer_device = peer_req->peer_device; in e_send_ack()
2286 dec_unacked(peer_device->device); in e_send_ack()
2300 struct drbd_connection *connection = peer_req->peer_device->connection; in e_send_retry_write()
2302 return e_send_ack(w, connection->agreed_pro_version >= 100 ? in e_send_retry_write()
2309 * We assume 32-bit wrap-around here. in seq_greater()
2310 * For 24-bit wrap-around, we would have to shift: in seq_greater()
2313 return (s32)a - (s32)b > 0; in seq_greater()
2323 struct drbd_device *device = peer_device->device; in update_peer_seq()
2326 if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { in update_peer_seq()
2327 spin_lock(&device->peer_seq_lock); in update_peer_seq()
2328 newest_peer_seq = seq_max(device->peer_seq, peer_seq); in update_peer_seq()
2329 device->peer_seq = newest_peer_seq; in update_peer_seq()
2330 spin_unlock(&device->peer_seq_lock); in update_peer_seq()
2331 /* wake up only if we actually changed device->peer_seq */ in update_peer_seq()
2333 wake_up(&device->seq_wait); in update_peer_seq()
2337 static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) in overlaps() argument
2339 return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); in overlaps()
2348 spin_lock_irq(&device->resource->req_lock); in overlapping_resync_write()
2349 list_for_each_entry(rs_req, &device->sync_ee, w.list) { in overlapping_resync_write()
2350 if (overlaps(peer_req->i.sector, peer_req->i.size, in overlapping_resync_write()
2351 rs_req->i.sector, rs_req->i.size)) { in overlapping_resync_write()
2356 spin_unlock_irq(&device->resource->req_lock); in overlapping_resync_write()
2370 * In case packet_seq is larger than device->peer_seq number, there are
2372 * In case we are the logically next packet, we update device->peer_seq
2381 * -ERESTARTSYS if we were interrupted (by disconnect signal). */
2384 struct drbd_device *device = peer_device->device; in wait_for_and_update_peer_seq()
2389 if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) in wait_for_and_update_peer_seq()
2392 spin_lock(&device->peer_seq_lock); in wait_for_and_update_peer_seq()
2394 if (!seq_greater(peer_seq - 1, device->peer_seq)) { in wait_for_and_update_peer_seq()
2395 device->peer_seq = seq_max(device->peer_seq, peer_seq); in wait_for_and_update_peer_seq()
2400 ret = -ERESTARTSYS; in wait_for_and_update_peer_seq()
2405 tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; in wait_for_and_update_peer_seq()
2412 prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); in wait_for_and_update_peer_seq()
2413 spin_unlock(&device->peer_seq_lock); in wait_for_and_update_peer_seq()
2415 timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; in wait_for_and_update_peer_seq()
2418 spin_lock(&device->peer_seq_lock); in wait_for_and_update_peer_seq()
2420 ret = -ETIMEDOUT; in wait_for_and_update_peer_seq()
2425 spin_unlock(&device->peer_seq_lock); in wait_for_and_update_peer_seq()
2426 finish_wait(&device->seq_wait, &wait); in wait_for_and_update_peer_seq()
2458 drbd_for_each_overlap(i, &device->write_requests, sector, size) { in fail_postponed_requests()
2462 if (!i->local) in fail_postponed_requests()
2465 if (!(req->rq_state & RQ_POSTPONED)) in fail_postponed_requests()
2467 req->rq_state &= ~RQ_POSTPONED; in fail_postponed_requests()
2469 spin_unlock_irq(&device->resource->req_lock); in fail_postponed_requests()
2472 spin_lock_irq(&device->resource->req_lock); in fail_postponed_requests()
2480 struct drbd_connection *connection = peer_req->peer_device->connection; in handle_write_conflicts()
2481 bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); in handle_write_conflicts()
2482 sector_t sector = peer_req->i.sector; in handle_write_conflicts()
2483 const unsigned int size = peer_req->i.size; in handle_write_conflicts()
2492 drbd_insert_interval(&device->write_requests, &peer_req->i); in handle_write_conflicts()
2495 drbd_for_each_overlap(i, &device->write_requests, sector, size) { in handle_write_conflicts()
2496 if (i == &peer_req->i) in handle_write_conflicts()
2498 if (i->completed) in handle_write_conflicts()
2501 if (!i->local) { in handle_write_conflicts()
2504 * should not happen in a two-node setup. Wait for the in handle_write_conflicts()
2513 equal = i->sector == sector && i->size == size; in handle_write_conflicts()
2521 bool superseded = i->sector <= sector && i->sector + in handle_write_conflicts()
2522 (i->size >> 9) >= sector + (size >> 9); in handle_write_conflicts()
2528 (unsigned long long)i->sector, i->size, in handle_write_conflicts()
2532 peer_req->w.cb = superseded ? e_send_superseded : in handle_write_conflicts()
2534 list_add_tail(&peer_req->w.list, &device->done_ee); in handle_write_conflicts()
2535 queue_work(connection->ack_sender, &peer_req->peer_device->send_acks_work); in handle_write_conflicts()
2537 err = -ENOENT; in handle_write_conflicts()
2546 (unsigned long long)i->sector, i->size, in handle_write_conflicts()
2549 if (req->rq_state & RQ_LOCAL_PENDING || in handle_write_conflicts()
2550 !(req->rq_state & RQ_POSTPONED)) { in handle_write_conflicts()
2562 err = drbd_wait_misc(device, &req->i); in handle_write_conflicts()
2574 peer_req->flags |= EE_RESTART_REQUESTS; in handle_write_conflicts()
2593 struct p_data *p = pi->data; in receive_Data()
2594 u32 peer_seq = be32_to_cpu(p->seq_num); in receive_Data()
2599 peer_device = conn_peer_device(connection, pi->vnr); in receive_Data()
2601 return -EIO; in receive_Data()
2602 device = peer_device->device; in receive_Data()
2608 drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); in receive_Data()
2609 atomic_inc(&connection->current_epoch->epoch_size); in receive_Data()
2610 err2 = drbd_drain_block(peer_device, pi->size); in receive_Data()
2622 sector = be64_to_cpu(p->sector); in receive_Data()
2623 peer_req = read_in_block(peer_device, p->block_id, sector, pi); in receive_Data()
2626 return -EIO; in receive_Data()
2629 peer_req->w.cb = e_end_block; in receive_Data()
2630 peer_req->submit_jif = jiffies; in receive_Data()
2631 peer_req->flags |= EE_APPLICATION; in receive_Data()
2633 dp_flags = be32_to_cpu(p->dp_flags); in receive_Data()
2636 if (pi->cmd == P_TRIM) { in receive_Data()
2637 D_ASSERT(peer_device, peer_req->i.size > 0); in receive_Data()
2639 D_ASSERT(peer_device, peer_req->pages == NULL); in receive_Data()
2641 * may mean zero-out while sending P_TRIM. */ in receive_Data()
2642 if (0 == (connection->agreed_features & DRBD_FF_WZEROES)) in receive_Data()
2643 peer_req->flags |= EE_ZEROOUT; in receive_Data()
2644 } else if (pi->cmd == P_ZEROES) { in receive_Data()
2645 D_ASSERT(peer_device, peer_req->i.size > 0); in receive_Data()
2647 D_ASSERT(peer_device, peer_req->pages == NULL); in receive_Data()
2650 peer_req->flags |= EE_TRIM; in receive_Data()
2651 } else if (peer_req->pages == NULL) { in receive_Data()
2652 D_ASSERT(device, peer_req->i.size == 0); in receive_Data()
2657 peer_req->flags |= EE_MAY_SET_IN_SYNC; in receive_Data()
2659 spin_lock(&connection->epoch_lock); in receive_Data()
2660 peer_req->epoch = connection->current_epoch; in receive_Data()
2661 atomic_inc(&peer_req->epoch->epoch_size); in receive_Data()
2662 atomic_inc(&peer_req->epoch->active); in receive_Data()
2663 spin_unlock(&connection->epoch_lock); in receive_Data()
2666 nc = rcu_dereference(peer_device->connection->net_conf); in receive_Data()
2667 tp = nc->two_primaries; in receive_Data()
2668 if (peer_device->connection->agreed_pro_version < 100) { in receive_Data()
2669 switch (nc->wire_protocol) { in receive_Data()
2681 peer_req->flags |= EE_SEND_WRITE_ACK; in receive_Data()
2696 peer_req->flags |= EE_IN_INTERVAL_TREE; in receive_Data()
2700 spin_lock_irq(&device->resource->req_lock); in receive_Data()
2703 spin_unlock_irq(&device->resource->req_lock); in receive_Data()
2704 if (err == -ENOENT) { in receive_Data()
2712 spin_lock_irq(&device->resource->req_lock); in receive_Data()
2718 if ((peer_req->flags & (EE_TRIM|EE_WRITE_SAME|EE_ZEROOUT)) == 0) in receive_Data()
2719 list_add_tail(&peer_req->w.list, &device->active_ee); in receive_Data()
2720 spin_unlock_irq(&device->resource->req_lock); in receive_Data()
2722 if (device->state.conn == C_SYNC_TARGET) in receive_Data()
2723 wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); in receive_Data()
2725 if (device->state.pdsk < D_INCONSISTENT) { in receive_Data()
2727 drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); in receive_Data()
2728 peer_req->flags &= ~EE_MAY_SET_IN_SYNC; in receive_Data()
2729 drbd_al_begin_io(device, &peer_req->i); in receive_Data()
2730 peer_req->flags |= EE_CALL_AL_COMPLETE_IO; in receive_Data()
2739 drbd_err(device, "submit failed, triggering re-connect\n"); in receive_Data()
2740 spin_lock_irq(&device->resource->req_lock); in receive_Data()
2741 list_del(&peer_req->w.list); in receive_Data()
2743 spin_unlock_irq(&device->resource->req_lock); in receive_Data()
2744 if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) { in receive_Data()
2745 peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; in receive_Data()
2746 drbd_al_complete_io(device, &peer_req->i); in receive_Data()
2750 drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT | EV_CLEANUP); in receive_Data()
2776 spin_lock_irq(&device->al_lock); in drbd_rs_should_slow_down()
2777 tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); in drbd_rs_should_slow_down()
2780 if (test_bit(BME_PRIORITY, &bm_ext->flags)) in drbd_rs_should_slow_down()
2785 spin_unlock_irq(&device->al_lock); in drbd_rs_should_slow_down()
2792 struct gendisk *disk = device->ldev->backing_bdev->bd_disk; in drbd_rs_c_min_rate_throttle()
2798 c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; in drbd_rs_c_min_rate_throttle()
2805 curr_events = (int)part_stat_read_accum(disk->part0, sectors) - in drbd_rs_c_min_rate_throttle()
2806 atomic_read(&device->rs_sect_ev); in drbd_rs_c_min_rate_throttle()
2808 if (atomic_read(&device->ap_actlog_cnt) in drbd_rs_c_min_rate_throttle()
2809 || curr_events - device->rs_last_events > 64) { in drbd_rs_c_min_rate_throttle()
2813 device->rs_last_events = curr_events; in drbd_rs_c_min_rate_throttle()
2817 i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; in drbd_rs_c_min_rate_throttle()
2819 if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) in drbd_rs_c_min_rate_throttle()
2820 rs_left = device->ov_left; in drbd_rs_c_min_rate_throttle()
2822 rs_left = drbd_bm_total_weight(device) - device->rs_failed; in drbd_rs_c_min_rate_throttle()
2824 dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; in drbd_rs_c_min_rate_throttle()
2827 db = device->rs_mark_left[i] - rs_left; in drbd_rs_c_min_rate_throttle()
2846 struct p_block_req *p = pi->data; in receive_DataRequest()
2848 peer_device = conn_peer_device(connection, pi->vnr); in receive_DataRequest()
2850 return -EIO; in receive_DataRequest()
2851 device = peer_device->device; in receive_DataRequest()
2852 capacity = get_capacity(device->vdisk); in receive_DataRequest()
2854 sector = be64_to_cpu(p->sector); in receive_DataRequest()
2855 size = be32_to_cpu(p->blksize); in receive_DataRequest()
2860 return -EINVAL; in receive_DataRequest()
2865 return -EINVAL; in receive_DataRequest()
2870 switch (pi->cmd) { in receive_DataRequest()
2893 return drbd_drain_block(peer_device, pi->size); in receive_DataRequest()
2896 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD in receive_DataRequest()
2897 * "criss-cross" setup, that might cause write-out on some other DRBD, in receive_DataRequest()
2899 peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, in receive_DataRequest()
2903 return -ENOMEM; in receive_DataRequest()
2906 switch (pi->cmd) { in receive_DataRequest()
2908 peer_req->w.cb = w_e_end_data_req; in receive_DataRequest()
2911 peer_req->flags |= EE_APPLICATION; in receive_DataRequest()
2919 peer_req->flags |= EE_RS_THIN_REQ; in receive_DataRequest()
2922 peer_req->w.cb = w_e_end_rsdata_req; in receive_DataRequest()
2925 device->bm_resync_fo = BM_SECT_TO_BIT(sector); in receive_DataRequest()
2931 di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); in receive_DataRequest()
2935 di->digest_size = pi->size; in receive_DataRequest()
2936 di->digest = (((char *)di)+sizeof(struct digest_info)); in receive_DataRequest()
2938 peer_req->digest = di; in receive_DataRequest()
2939 peer_req->flags |= EE_HAS_DIGEST; in receive_DataRequest()
2941 if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) in receive_DataRequest()
2944 if (pi->cmd == P_CSUM_RS_REQUEST) { in receive_DataRequest()
2945 D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); in receive_DataRequest()
2946 peer_req->w.cb = w_e_end_csum_rs_req; in receive_DataRequest()
2948 device->bm_resync_fo = BM_SECT_TO_BIT(sector); in receive_DataRequest()
2950 device->use_csums = true; in receive_DataRequest()
2951 } else if (pi->cmd == P_OV_REPLY) { in receive_DataRequest()
2953 atomic_add(size >> 9, &device->rs_sect_in); in receive_DataRequest()
2954 peer_req->w.cb = w_e_end_ov_reply; in receive_DataRequest()
2963 if (device->ov_start_sector == ~(sector_t)0 && in receive_DataRequest()
2964 peer_device->connection->agreed_pro_version >= 90) { in receive_DataRequest()
2967 device->ov_start_sector = sector; in receive_DataRequest()
2968 device->ov_position = sector; in receive_DataRequest()
2969 device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); in receive_DataRequest()
2970 device->rs_total = device->ov_left; in receive_DataRequest()
2972 device->rs_mark_left[i] = device->ov_left; in receive_DataRequest()
2973 device->rs_mark_time[i] = now; in receive_DataRequest()
2978 peer_req->w.cb = w_e_end_ov_req; in receive_DataRequest()
3013 spin_lock_irq(&device->resource->req_lock); in receive_DataRequest()
3014 list_add_tail(&peer_req->w.list, &device->read_ee); in receive_DataRequest()
3015 spin_unlock_irq(&device->resource->req_lock); in receive_DataRequest()
3018 if (device->state.peer != R_PRIMARY in receive_DataRequest()
3026 atomic_add(size >> 9, &device->rs_sect_ev); in receive_DataRequest()
3036 drbd_err(device, "submit failed, triggering re-connect\n"); in receive_DataRequest()
3039 spin_lock_irq(&device->resource->req_lock); in receive_DataRequest()
3040 list_del(&peer_req->w.list); in receive_DataRequest()
3041 spin_unlock_irq(&device->resource->req_lock); in receive_DataRequest()
3046 return -EIO; in receive_DataRequest()
3050 * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries
3054 struct drbd_device *device = peer_device->device; in drbd_asb_recover_0p()
3055 int self, peer, rv = -100; in drbd_asb_recover_0p()
3059 self = device->ldev->md.uuid[UI_BITMAP] & 1; in drbd_asb_recover_0p()
3060 peer = device->p_uuid[UI_BITMAP] & 1; in drbd_asb_recover_0p()
3062 ch_peer = device->p_uuid[UI_SIZE]; in drbd_asb_recover_0p()
3063 ch_self = device->comm_bm_set; in drbd_asb_recover_0p()
3066 after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; in drbd_asb_recover_0p()
3079 rv = -1; in drbd_asb_recover_0p()
3093 rv = -1; in drbd_asb_recover_0p()
3098 "Using discard-least-changes instead\n"); in drbd_asb_recover_0p()
3102 rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) in drbd_asb_recover_0p()
3103 ? -1 : 1; in drbd_asb_recover_0p()
3107 if (ch_self == 0) { rv = -1; break; } in drbd_asb_recover_0p()
3114 rv = -1; in drbd_asb_recover_0p()
3119 rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) in drbd_asb_recover_0p()
3120 ? -1 : 1; in drbd_asb_recover_0p()
3123 rv = -1; in drbd_asb_recover_0p()
3133 * drbd_asb_recover_1p - Recover after split-brain with one remaining primary
3137 struct drbd_device *device = peer_device->device; in drbd_asb_recover_1p()
3138 int hg, rv = -100; in drbd_asb_recover_1p()
3142 after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; in drbd_asb_recover_1p()
3157 if (hg == -1 && device->state.role == R_SECONDARY) in drbd_asb_recover_1p()
3159 if (hg == 1 && device->state.role == R_PRIMARY) in drbd_asb_recover_1p()
3166 return device->state.role == R_PRIMARY ? 1 : -1; in drbd_asb_recover_1p()
3169 if (hg == -1 && device->state.role == R_PRIMARY) { in drbd_asb_recover_1p()
3177 drbd_khelper(device, "pri-lost-after-sb"); in drbd_asb_recover_1p()
3190 * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries
3194 struct drbd_device *device = peer_device->device; in drbd_asb_recover_2p()
3195 int hg, rv = -100; in drbd_asb_recover_2p()
3199 after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; in drbd_asb_recover_2p()
3219 if (hg == -1) { in drbd_asb_recover_2p()
3227 drbd_khelper(device, "pri-lost-after-sb"); in drbd_asb_recover_2p()
3261 -1 C_SYNC_TARGET use BitMap
3262 -2 C_SYNC_TARGET set BitMap
3263 -100 after split brain, disconnect
3264 -1000 unrelated data
3265 -1091 requires proto 91
3266 -1096 requires proto 96
3272 struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL; in drbd_uuid_compare()
3276 self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); in drbd_uuid_compare()
3277 peer = device->p_uuid[UI_CURRENT] & ~((u64)1); in drbd_uuid_compare()
3286 return -2; in drbd_uuid_compare()
3296 if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { in drbd_uuid_compare()
3298 if (connection->agreed_pro_version < 91) in drbd_uuid_compare()
3299 return -1091; in drbd_uuid_compare()
3301 …if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1… in drbd_uuid_compare()
3302 …(device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~… in drbd_uuid_compare()
3305 device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; in drbd_uuid_compare()
3306 device->ldev->md.uuid[UI_BITMAP] = 0; in drbd_uuid_compare()
3308 drbd_uuid_dump(device, "self", device->ldev->md.uuid, in drbd_uuid_compare()
3309 device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); in drbd_uuid_compare()
3319 if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { in drbd_uuid_compare()
3321 if (connection->agreed_pro_version < 91) in drbd_uuid_compare()
3322 return -1091; in drbd_uuid_compare()
3324 …if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1… in drbd_uuid_compare()
3325 …(device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~… in drbd_uuid_compare()
3328 device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; in drbd_uuid_compare()
3329 device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; in drbd_uuid_compare()
3330 device->p_uuid[UI_BITMAP] = 0UL; in drbd_uuid_compare()
3332 … drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); in drbd_uuid_compare()
3339 return -1; in drbd_uuid_compare()
3343 rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + in drbd_uuid_compare()
3344 (device->p_uuid[UI_FLAGS] & 2); in drbd_uuid_compare()
3356 * frozen, so no UUID-bump happened. in drbd_uuid_compare()
3358 * for "new-enough" peer DRBD version. */ in drbd_uuid_compare()
3359 if (device->state.role == R_PRIMARY || peer_role == R_PRIMARY) { in drbd_uuid_compare()
3361 if (!(connection->agreed_features & DRBD_FF_WSAME)) { in drbd_uuid_compare()
3363 return -(0x10000 | PRO_VERSION_MAX | (DRBD_FF_WSAME << 8)); in drbd_uuid_compare()
3365 if (device->state.role == R_PRIMARY && peer_role == R_PRIMARY) { in drbd_uuid_compare()
3370 return -100; in drbd_uuid_compare()
3372 if (device->state.role == R_PRIMARY) in drbd_uuid_compare()
3374 return -1; in drbd_uuid_compare()
3383 case 2: /* !self_pri && peer_pri */ return -1; in drbd_uuid_compare()
3385 dc = test_bit(RESOLVE_CONFLICTS, &connection->flags); in drbd_uuid_compare()
3386 return dc ? -1 : 1; in drbd_uuid_compare()
3391 peer = device->p_uuid[UI_BITMAP] & ~((u64)1); in drbd_uuid_compare()
3393 return -1; in drbd_uuid_compare()
3396 peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); in drbd_uuid_compare()
3398 if (connection->agreed_pro_version < 96 ? in drbd_uuid_compare()
3399 (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == in drbd_uuid_compare()
3400 (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : in drbd_uuid_compare()
3401 peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { in drbd_uuid_compare()
3405 if (connection->agreed_pro_version < 91) in drbd_uuid_compare()
3406 return -1091; in drbd_uuid_compare()
3408 device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; in drbd_uuid_compare()
3409 device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; in drbd_uuid_compare()
3412 … drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); in drbd_uuid_compare()
3414 return -1; in drbd_uuid_compare()
3419 self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); in drbd_uuid_compare()
3421 peer = device->p_uuid[i] & ~((u64)1); in drbd_uuid_compare()
3423 return -2; in drbd_uuid_compare()
3427 self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); in drbd_uuid_compare()
3428 peer = device->p_uuid[UI_CURRENT] & ~((u64)1); in drbd_uuid_compare()
3433 self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); in drbd_uuid_compare()
3435 if (connection->agreed_pro_version < 96 ? in drbd_uuid_compare()
3436 (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == in drbd_uuid_compare()
3437 (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : in drbd_uuid_compare()
3438 self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { in drbd_uuid_compare()
3442 if (connection->agreed_pro_version < 91) in drbd_uuid_compare()
3443 return -1091; in drbd_uuid_compare()
3445 __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); in drbd_uuid_compare()
3446 __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); in drbd_uuid_compare()
3449 drbd_uuid_dump(device, "self", device->ldev->md.uuid, in drbd_uuid_compare()
3450 device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); in drbd_uuid_compare()
3458 peer = device->p_uuid[UI_CURRENT] & ~((u64)1); in drbd_uuid_compare()
3460 self = device->ldev->md.uuid[i] & ~((u64)1); in drbd_uuid_compare()
3466 self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); in drbd_uuid_compare()
3467 peer = device->p_uuid[UI_BITMAP] & ~((u64)1); in drbd_uuid_compare()
3473 self = device->ldev->md.uuid[i] & ~((u64)1); in drbd_uuid_compare()
3475 peer = device->p_uuid[j] & ~((u64)1); in drbd_uuid_compare()
3477 return -100; in drbd_uuid_compare()
3481 return -1000; in drbd_uuid_compare()
3485 CONN_MASK (-1) on failure.
3491 struct drbd_device *device = peer_device->device; in drbd_sync_handshake()
3497 mydisk = device->state.disk; in drbd_sync_handshake()
3499 mydisk = device->new_state_tmp.disk; in drbd_sync_handshake()
3503 spin_lock_irq(&device->ldev->md.uuid_lock); in drbd_sync_handshake()
3504 drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); in drbd_sync_handshake()
3505 drbd_uuid_dump(device, "peer", device->p_uuid, in drbd_sync_handshake()
3506 device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); in drbd_sync_handshake()
3509 spin_unlock_irq(&device->ldev->md.uuid_lock); in drbd_sync_handshake()
3513 if (hg == -1000) { in drbd_sync_handshake()
3517 if (hg < -0x10000) { in drbd_sync_handshake()
3519 hg = -hg; in drbd_sync_handshake()
3526 if (hg < -1000) { in drbd_sync_handshake()
3527 …drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000… in drbd_sync_handshake()
3533 int f = (hg == -100) || abs(hg) == 2; in drbd_sync_handshake()
3534 hg = mydisk > D_INCONSISTENT ? 1 : -1; in drbd_sync_handshake()
3542 drbd_khelper(device, "initial-split-brain"); in drbd_sync_handshake()
3545 nc = rcu_dereference(peer_device->connection->net_conf); in drbd_sync_handshake()
3546 always_asbp = nc->always_asbp; in drbd_sync_handshake()
3547 rr_conflict = nc->rr_conflict; in drbd_sync_handshake()
3548 tentative = nc->tentative; in drbd_sync_handshake()
3551 if (hg == 100 || (hg == -100 && always_asbp)) { in drbd_sync_handshake()
3552 int pcount = (device->state.role == R_PRIMARY) in drbd_sync_handshake()
3554 int forced = (hg == -100); in drbd_sync_handshake()
3568 drbd_warn(device, "Split-Brain detected, %d primaries, " in drbd_sync_handshake()
3579 if (hg == -100) { in drbd_sync_handshake()
3580 if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) in drbd_sync_handshake()
3581 hg = -1; in drbd_sync_handshake()
3582 if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) in drbd_sync_handshake()
3586 drbd_warn(device, "Split-Brain detected, manually solved. " in drbd_sync_handshake()
3591 if (hg == -100) { in drbd_sync_handshake()
3594 * We just refuse to attach -- well, we drop the "connection" in drbd_sync_handshake()
3596 drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); in drbd_sync_handshake()
3597 drbd_khelper(device, "split-brain"); in drbd_sync_handshake()
3607 device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { in drbd_sync_handshake()
3610 drbd_khelper(device, "pri-lost"); in drbd_sync_handshake()
3616 drbd_warn(device, "Becoming SyncTarget, violating the stable-data" in drbd_sync_handshake()
3621 if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { in drbd_sync_handshake()
3623 drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); in drbd_sync_handshake()
3625 drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", in drbd_sync_handshake()
3627 abs(hg) >= 2 ? "full" : "bit-map based"); in drbd_sync_handshake()
3655 /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ in convert_after_sb()
3669 struct p_protocol *p = pi->data; in receive_protocol()
3677 p_proto = be32_to_cpu(p->protocol); in receive_protocol()
3678 p_after_sb_0p = be32_to_cpu(p->after_sb_0p); in receive_protocol()
3679 p_after_sb_1p = be32_to_cpu(p->after_sb_1p); in receive_protocol()
3680 p_after_sb_2p = be32_to_cpu(p->after_sb_2p); in receive_protocol()
3681 p_two_primaries = be32_to_cpu(p->two_primaries); in receive_protocol()
3682 cf = be32_to_cpu(p->conn_flags); in receive_protocol()
3685 if (connection->agreed_pro_version >= 87) { in receive_protocol()
3688 if (pi->size > sizeof(integrity_alg)) in receive_protocol()
3689 return -EIO; in receive_protocol()
3690 err = drbd_recv_all(connection, integrity_alg, pi->size); in receive_protocol()
3693 integrity_alg[SHARED_SECRET_MAX - 1] = 0; in receive_protocol()
3696 if (pi->cmd != P_PROTOCOL_UPDATE) { in receive_protocol()
3697 clear_bit(CONN_DRY_RUN, &connection->flags); in receive_protocol()
3700 set_bit(CONN_DRY_RUN, &connection->flags); in receive_protocol()
3703 nc = rcu_dereference(connection->net_conf); in receive_protocol()
3705 if (p_proto != nc->wire_protocol) { in receive_protocol()
3710 if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { in receive_protocol()
3711 drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); in receive_protocol()
3715 if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { in receive_protocol()
3716 drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); in receive_protocol()
3720 if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { in receive_protocol()
3721 drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); in receive_protocol()
3725 if (p_discard_my_data && nc->discard_my_data) { in receive_protocol()
3726 drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); in receive_protocol()
3730 if (p_two_primaries != nc->two_primaries) { in receive_protocol()
3731 drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); in receive_protocol()
3735 if (strcmp(integrity_alg, nc->integrity_alg)) { in receive_protocol()
3736 drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); in receive_protocol()
3758 drbd_err(connection, "peer data-integrity-alg %s not supported\n", in receive_protocol()
3776 mutex_lock(&connection->data.mutex); in receive_protocol()
3777 mutex_lock(&connection->resource->conf_update); in receive_protocol()
3778 old_net_conf = connection->net_conf; in receive_protocol()
3781 new_net_conf->wire_protocol = p_proto; in receive_protocol()
3782 new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); in receive_protocol()
3783 new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); in receive_protocol()
3784 new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); in receive_protocol()
3785 new_net_conf->two_primaries = p_two_primaries; in receive_protocol()
3787 rcu_assign_pointer(connection->net_conf, new_net_conf); in receive_protocol()
3788 mutex_unlock(&connection->resource->conf_update); in receive_protocol()
3789 mutex_unlock(&connection->data.mutex); in receive_protocol()
3791 crypto_free_shash(connection->peer_integrity_tfm); in receive_protocol()
3792 kfree(connection->int_dig_in); in receive_protocol()
3793 kfree(connection->int_dig_vv); in receive_protocol()
3794 connection->peer_integrity_tfm = peer_integrity_tfm; in receive_protocol()
3795 connection->int_dig_in = int_dig_in; in receive_protocol()
3796 connection->int_dig_vv = int_dig_vv; in receive_protocol()
3798 if (strcmp(old_net_conf->integrity_alg, integrity_alg)) in receive_protocol()
3799 drbd_info(connection, "peer data-integrity-alg: %s\n", in receive_protocol()
3813 return -EIO; in receive_protocol()
3841 void *buffer = connection->data.rbuf; in ignore_remaining_packet()
3842 int size = pi->size; in ignore_remaining_packet()
3852 size -= s; in ignore_remaining_packet()
3855 return -EIO; in ignore_remaining_packet()
3860 * config_unknown_volume - device configuration command for unknown volume
3873 cmdname(pi->cmd), pi->vnr); in config_unknown_volume()
3887 const int apv = connection->agreed_pro_version; in receive_SyncParam()
3892 peer_device = conn_peer_device(connection, pi->vnr); in receive_SyncParam()
3895 device = peer_device->device; in receive_SyncParam()
3903 if (pi->size > exp_max_sz) { in receive_SyncParam()
3905 pi->size, exp_max_sz); in receive_SyncParam()
3906 return -EIO; in receive_SyncParam()
3911 data_size = pi->size - header_size; in receive_SyncParam()
3914 data_size = pi->size - header_size; in receive_SyncParam()
3918 data_size = pi->size - header_size; in receive_SyncParam()
3923 p = pi->data; in receive_SyncParam()
3924 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); in receive_SyncParam()
3926 err = drbd_recv_all(peer_device->connection, p, header_size); in receive_SyncParam()
3930 mutex_lock(&connection->resource->conf_update); in receive_SyncParam()
3931 old_net_conf = peer_device->connection->net_conf; in receive_SyncParam()
3936 mutex_unlock(&connection->resource->conf_update); in receive_SyncParam()
3938 return -ENOMEM; in receive_SyncParam()
3941 old_disk_conf = device->ldev->disk_conf; in receive_SyncParam()
3944 new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); in receive_SyncParam()
3950 drbd_err(device, "verify-alg of wrong size, " in receive_SyncParam()
3953 err = -EIO; in receive_SyncParam()
3957 err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); in receive_SyncParam()
3962 D_ASSERT(device, p->verify_alg[data_size-1] == 0); in receive_SyncParam()
3963 p->verify_alg[data_size-1] = 0; in receive_SyncParam()
3968 D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); in receive_SyncParam()
3969 D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); in receive_SyncParam()
3970 p->verify_alg[SHARED_SECRET_MAX-1] = 0; in receive_SyncParam()
3971 p->csums_alg[SHARED_SECRET_MAX-1] = 0; in receive_SyncParam()
3974 if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { in receive_SyncParam()
3975 if (device->state.conn == C_WF_REPORT_PARAMS) { in receive_SyncParam()
3976 drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", in receive_SyncParam()
3977 old_net_conf->verify_alg, p->verify_alg); in receive_SyncParam()
3981 p->verify_alg, "verify-alg"); in receive_SyncParam()
3988 if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { in receive_SyncParam()
3989 if (device->state.conn == C_WF_REPORT_PARAMS) { in receive_SyncParam()
3990 drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", in receive_SyncParam()
3991 old_net_conf->csums_alg, p->csums_alg); in receive_SyncParam()
3995 p->csums_alg, "csums-alg"); in receive_SyncParam()
4003 new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); in receive_SyncParam()
4004 new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); in receive_SyncParam()
4005 new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); in receive_SyncParam()
4006 new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); in receive_SyncParam()
4008 fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; in receive_SyncParam()
4009 if (fifo_size != device->rs_plan_s->size) { in receive_SyncParam()
4027 strcpy(new_net_conf->verify_alg, p->verify_alg); in receive_SyncParam()
4028 new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; in receive_SyncParam()
4029 crypto_free_shash(peer_device->connection->verify_tfm); in receive_SyncParam()
4030 peer_device->connection->verify_tfm = verify_tfm; in receive_SyncParam()
4031 drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); in receive_SyncParam()
4034 strcpy(new_net_conf->csums_alg, p->csums_alg); in receive_SyncParam()
4035 new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; in receive_SyncParam()
4036 crypto_free_shash(peer_device->connection->csums_tfm); in receive_SyncParam()
4037 peer_device->connection->csums_tfm = csums_tfm; in receive_SyncParam()
4038 drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); in receive_SyncParam()
4040 rcu_assign_pointer(connection->net_conf, new_net_conf); in receive_SyncParam()
4045 rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); in receive_SyncParam()
4050 old_plan = device->rs_plan_s; in receive_SyncParam()
4051 rcu_assign_pointer(device->rs_plan_s, new_plan); in receive_SyncParam()
4054 mutex_unlock(&connection->resource->conf_update); in receive_SyncParam()
4068 mutex_unlock(&connection->resource->conf_update); in receive_SyncParam()
4069 return -EIO; in receive_SyncParam()
4077 mutex_unlock(&connection->resource->conf_update); in receive_SyncParam()
4083 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); in receive_SyncParam()
4084 return -EIO; in receive_SyncParam()
4094 d = (a > b) ? (a - b) : (b - a); in warn_if_differ_considerably()
4104 struct p_sizes *p = pi->data; in receive_sizes()
4105 struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL; in receive_sizes()
4112 peer_device = conn_peer_device(connection, pi->vnr); in receive_sizes()
4115 device = peer_device->device; in receive_sizes()
4116 cur_size = get_capacity(device->vdisk); in receive_sizes()
4118 p_size = be64_to_cpu(p->d_size); in receive_sizes()
4119 p_usize = be64_to_cpu(p->u_size); in receive_sizes()
4120 p_csize = be64_to_cpu(p->c_size); in receive_sizes()
4124 device->p_size = p_size; in receive_sizes()
4128 my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; in receive_sizes()
4132 p_size, drbd_get_max_capacity(device->ldev)); in receive_sizes()
4138 if (device->state.conn == C_WF_REPORT_PARAMS) in receive_sizes()
4144 new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0); in receive_sizes()
4146 device->state.disk >= D_OUTDATED && in receive_sizes()
4147 (device->state.conn < C_CONNECTED || device->state.pdsk == D_DISKLESS)) { in receive_sizes()
4150 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); in receive_sizes()
4152 return -EIO; in receive_sizes()
4161 return -ENOMEM; in receive_sizes()
4164 mutex_lock(&connection->resource->conf_update); in receive_sizes()
4165 old_disk_conf = device->ldev->disk_conf; in receive_sizes()
4167 new_disk_conf->disk_size = p_usize; in receive_sizes()
4169 rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); in receive_sizes()
4170 mutex_unlock(&connection->resource->conf_update); in receive_sizes()
4181 device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); in receive_sizes()
4187 ddsf = be16_to_cpu(p->dds_flags); in receive_sizes()
4189 drbd_reconsider_queue_parameters(device, device->ldev, o); in receive_sizes()
4193 return -EIO; in receive_sizes()
4207 * take his (user-capped or) backing disk size anyways. in receive_sizes()
4221 } else if (new_size < cur_size && device->state.role == R_PRIMARY) { in receive_sizes()
4224 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); in receive_sizes()
4225 return -EIO; in receive_sizes()
4228 * - I don't have a current size myself in receive_sizes()
4229 * - we agree on the size anyways in receive_sizes()
4230 * - I do have a current size, am Secondary, in receive_sizes()
4232 * - I do have a current size, am Primary, in receive_sizes()
4241 if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { in receive_sizes()
4242 device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); in receive_sizes()
4249 if (device->state.conn > C_WF_REPORT_PARAMS) { in receive_sizes()
4250 if (be64_to_cpu(p->c_size) != get_capacity(device->vdisk) || in receive_sizes()
4256 if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || in receive_sizes()
4257 (dd == DS_GREW && device->state.conn == C_CONNECTED)) { in receive_sizes()
4258 if (device->state.pdsk >= D_INCONSISTENT && in receive_sizes()
4259 device->state.disk >= D_INCONSISTENT) { in receive_sizes()
4261 drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); in receive_sizes()
4265 set_bit(RESYNC_AFTER_NEG, &device->flags); in receive_sizes()
4276 struct p_uuids *p = pi->data; in receive_uuids()
4280 peer_device = conn_peer_device(connection, pi->vnr); in receive_uuids()
4283 device = peer_device->device; in receive_uuids()
4290 p_uuid[i] = be64_to_cpu(p->uuid[i]); in receive_uuids()
4292 kfree(device->p_uuid); in receive_uuids()
4293 device->p_uuid = p_uuid; in receive_uuids()
4295 if ((device->state.conn < C_CONNECTED || device->state.pdsk == D_DISKLESS) && in receive_uuids()
4296 device->state.disk < D_INCONSISTENT && in receive_uuids()
4297 device->state.role == R_PRIMARY && in receive_uuids()
4298 (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { in receive_uuids()
4300 (unsigned long long)device->ed_uuid); in receive_uuids()
4301 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); in receive_uuids()
4302 return -EIO; in receive_uuids()
4307 device->state.conn == C_CONNECTED && in receive_uuids()
4308 peer_device->connection->agreed_pro_version >= 90 && in receive_uuids()
4309 device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && in receive_uuids()
4324 } else if (device->state.disk < D_INCONSISTENT && in receive_uuids()
4325 device->state.role == R_PRIMARY) { in receive_uuids()
4335 mutex_lock(device->state_mutex); in receive_uuids()
4336 mutex_unlock(device->state_mutex); in receive_uuids()
4337 if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) in receive_uuids()
4347 * convert_state() - Converts the peer's view of the cluster state to our point of view
4381 struct p_req_state *p = pi->data; in receive_req_state()
4385 peer_device = conn_peer_device(connection, pi->vnr); in receive_req_state()
4387 return -EIO; in receive_req_state()
4388 device = peer_device->device; in receive_req_state()
4390 mask.i = be32_to_cpu(p->mask); in receive_req_state()
4391 val.i = be32_to_cpu(p->val); in receive_req_state()
4393 if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && in receive_req_state()
4394 mutex_is_locked(device->state_mutex)) { in receive_req_state()
4412 struct p_req_state *p = pi->data; in receive_req_conn_state()
4416 mask.i = be32_to_cpu(p->mask); in receive_req_conn_state()
4417 val.i = be32_to_cpu(p->val); in receive_req_conn_state()
4419 if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && in receive_req_conn_state()
4420 mutex_is_locked(&connection->cstate_mutex)) { in receive_req_conn_state()
4438 struct p_state *p = pi->data; in receive_state()
4444 peer_device = conn_peer_device(connection, pi->vnr); in receive_state()
4447 device = peer_device->device; in receive_state()
4449 peer_state.i = be32_to_cpu(p->state); in receive_state()
4453 real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; in receive_state()
4457 spin_lock_irq(&device->resource->req_lock); in receive_state()
4460 spin_unlock_irq(&device->resource->req_lock); in receive_state()
4464 * we must not "re-establish" it here. */ in receive_state()
4466 return -ECONNRESET; in receive_state()
4470 * set) resync started in PausedSyncT, or if the timing of pause-/ in receive_state()
4471 * unpause-sync events has been "just right", the peer disk may in receive_state()
4478 * preparation, ignore its uptodate-ness to avoid flapping, it in receive_state()
4481 * It may have changed syncer-paused flags, however, so we in receive_state()
4492 if (drbd_bm_total_weight(device) <= device->rs_failed) in receive_state()
4540 if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && in receive_state()
4552 * forced to be UpToDate with --force */ in receive_state()
4553 cr |= test_bit(CONSIDER_RESYNC, &device->flags); in receive_state()
4555 * start a sync by "invalidate" or "invalidate-remote" */ in receive_state()
4566 if (device->state.disk == D_NEGOTIATING) { in receive_state()
4573 if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) in receive_state()
4574 return -EIO; in receive_state()
4576 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); in receive_state()
4577 return -EIO; in receive_state()
4582 spin_lock_irq(&device->resource->req_lock); in receive_state()
4585 clear_bit(CONSIDER_RESYNC, &device->flags); in receive_state()
4590 ns.disk = device->new_state_tmp.disk; in receive_state()
4593 test_bit(NEW_CUR_UUID, &device->flags)) { in receive_state()
4596 spin_unlock_irq(&device->resource->req_lock); in receive_state()
4598 tl_clear(peer_device->connection); in receive_state()
4600 clear_bit(NEW_CUR_UUID, &device->flags); in receive_state()
4601 conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); in receive_state()
4602 return -EIO; in receive_state()
4606 spin_unlock_irq(&device->resource->req_lock); in receive_state()
4609 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); in receive_state()
4610 return -EIO; in receive_state()
4624 clear_bit(DISCARD_MY_DATA, &device->flags); in receive_state()
4635 struct p_rs_uuid *p = pi->data; in receive_sync_uuid()
4637 peer_device = conn_peer_device(connection, pi->vnr); in receive_sync_uuid()
4639 return -EIO; in receive_sync_uuid()
4640 device = peer_device->device; in receive_sync_uuid()
4642 wait_event(device->misc_wait, in receive_sync_uuid()
4643 device->state.conn == C_WF_SYNC_UUID || in receive_sync_uuid()
4644 device->state.conn == C_BEHIND || in receive_sync_uuid()
4645 device->state.conn < C_CONNECTED || in receive_sync_uuid()
4646 device->state.disk < D_NEGOTIATING); in receive_sync_uuid()
4648 /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ in receive_sync_uuid()
4653 _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); in receive_sync_uuid()
4676 unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - in receive_bitmap_plain()
4677 drbd_header_size(peer_device->connection); in receive_bitmap_plain()
4679 c->bm_words - c->word_offset); in receive_bitmap_plain()
4685 return -EIO; in receive_bitmap_plain()
4689 err = drbd_recv_all(peer_device->connection, p, want); in receive_bitmap_plain()
4693 drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); in receive_bitmap_plain()
4695 c->word_offset += num_words; in receive_bitmap_plain()
4696 c->bit_offset = c->word_offset * BITS_PER_LONG; in receive_bitmap_plain()
4697 if (c->bit_offset > c->bm_bits) in receive_bitmap_plain()
4698 c->bit_offset = c->bm_bits; in receive_bitmap_plain()
4705 return (enum drbd_bitmap_code)(p->encoding & 0x0f); in dcbp_get_code()
4710 return (p->encoding & 0x80) != 0; in dcbp_get_start()
4715 return (p->encoding >> 4) & 0x7; in dcbp_get_pad_bits()
4734 unsigned long s = c->bit_offset; in recv_bm_rle_bits()
4740 bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); in recv_bm_rle_bits()
4744 return -EIO; in recv_bm_rle_bits()
4749 return -EIO; in recv_bm_rle_bits()
4752 e = s + rl -1; in recv_bm_rle_bits()
4753 if (e >= c->bm_bits) { in recv_bm_rle_bits()
4755 return -EIO; in recv_bm_rle_bits()
4757 _drbd_bm_set_bits(peer_device->device, s, e); in recv_bm_rle_bits()
4763 (unsigned int)(bs.cur.b - p->code), in recv_bm_rle_bits()
4765 return -EIO; in recv_bm_rle_bits()
4772 have -= bits; in recv_bm_rle_bits()
4774 bits = bitstream_get_bits(&bs, &tmp, 64 - have); in recv_bm_rle_bits()
4776 return -EIO; in recv_bm_rle_bits()
4781 c->bit_offset = s; in recv_bm_rle_bits()
4784 return (s != c->bm_bits); in recv_bm_rle_bits()
4800 return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); in decode_bitmap_c()
4806 drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); in decode_bitmap_c()
4807 conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); in decode_bitmap_c()
4808 return -EIO; in decode_bitmap_c()
4815 unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); in INFO_bm_xfer_stats()
4816 unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; in INFO_bm_xfer_stats()
4818 header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + in INFO_bm_xfer_stats()
4819 c->bm_words * sizeof(unsigned long); in INFO_bm_xfer_stats()
4820 unsigned int total = c->bytes[0] + c->bytes[1]; in INFO_bm_xfer_stats()
4838 r = 1000 - r; in INFO_bm_xfer_stats()
4842 c->bytes[1], c->packets[1], in INFO_bm_xfer_stats()
4843 c->bytes[0], c->packets[0], in INFO_bm_xfer_stats()
4862 peer_device = conn_peer_device(connection, pi->vnr); in receive_bitmap()
4864 return -EIO; in receive_bitmap()
4865 device = peer_device->device; in receive_bitmap()
4868 /* you are supposed to send additional out-of-sync information in receive_bitmap()
4877 if (pi->cmd == P_BITMAP) in receive_bitmap()
4878 err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); in receive_bitmap()
4879 else if (pi->cmd == P_COMPRESSED_BITMAP) { in receive_bitmap()
4882 struct p_compressed_bm *p = pi->data; in receive_bitmap()
4884 if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { in receive_bitmap()
4886 err = -EIO; in receive_bitmap()
4889 if (pi->size <= sizeof(*p)) { in receive_bitmap()
4890 drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); in receive_bitmap()
4891 err = -EIO; in receive_bitmap()
4894 err = drbd_recv_all(peer_device->connection, p, pi->size); in receive_bitmap()
4897 err = decode_bitmap_c(peer_device, p, &c, pi->size); in receive_bitmap()
4899 …drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); in receive_bitmap()
4900 err = -EIO; in receive_bitmap()
4904 c.packets[pi->cmd == P_BITMAP]++; in receive_bitmap()
4905 c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; in receive_bitmap()
4912 err = drbd_recv_header(peer_device->connection, pi); in receive_bitmap()
4919 if (device->state.conn == C_WF_BITMAP_T) { in receive_bitmap()
4928 } else if (device->state.conn != C_WF_BITMAP_S) { in receive_bitmap()
4932 drbd_conn_str(device->state.conn)); in receive_bitmap()
4938 if (!err && device->state.conn == C_WF_BITMAP_S) in receive_bitmap()
4946 pi->cmd, pi->size); in receive_skip()
4955 tcp_sock_set_quickack(connection->data.socket->sk, 2); in receive_UnplugRemote()
4963 struct p_block_desc *p = pi->data; in receive_out_of_sync()
4965 peer_device = conn_peer_device(connection, pi->vnr); in receive_out_of_sync()
4967 return -EIO; in receive_out_of_sync()
4968 device = peer_device->device; in receive_out_of_sync()
4970 switch (device->state.conn) { in receive_out_of_sync()
4977 drbd_conn_str(device->state.conn)); in receive_out_of_sync()
4980 drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); in receive_out_of_sync()
4988 struct p_block_desc *p = pi->data; in receive_rs_deallocated()
4993 peer_device = conn_peer_device(connection, pi->vnr); in receive_rs_deallocated()
4995 return -EIO; in receive_rs_deallocated()
4996 device = peer_device->device; in receive_rs_deallocated()
4998 sector = be64_to_cpu(p->sector); in receive_rs_deallocated()
4999 size = be32_to_cpu(p->blksize); in receive_rs_deallocated()
5011 return -ENOMEM; in receive_rs_deallocated()
5014 peer_req->w.cb = e_end_resync_block; in receive_rs_deallocated()
5015 peer_req->submit_jif = jiffies; in receive_rs_deallocated()
5016 peer_req->flags |= EE_TRIM; in receive_rs_deallocated()
5018 spin_lock_irq(&device->resource->req_lock); in receive_rs_deallocated()
5019 list_add_tail(&peer_req->w.list, &device->sync_ee); in receive_rs_deallocated()
5020 spin_unlock_irq(&device->resource->req_lock); in receive_rs_deallocated()
5022 atomic_add(pi->size >> 9, &device->rs_sect_ev); in receive_rs_deallocated()
5026 spin_lock_irq(&device->resource->req_lock); in receive_rs_deallocated()
5027 list_del(&peer_req->w.list); in receive_rs_deallocated()
5028 spin_unlock_irq(&device->resource->req_lock); in receive_rs_deallocated()
5046 atomic_add(size >> 9, &device->rs_sect_in); in receive_rs_deallocated()
5095 while (get_t_state(&connection->receiver) == RUNNING) { in drbdd()
5098 drbd_thread_current_set_cpu(&connection->receiver); in drbdd()
5104 if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { in drbdd()
5110 shs = cmd->pkt_size; in drbdd()
5111 if (pi.cmd == P_SIZES && connection->agreed_features & DRBD_FF_WSAME) in drbdd()
5113 if (pi.size > shs && !cmd->expect_payload) { in drbdd()
5129 pi.size -= shs; in drbdd()
5132 update_receiver_timing_details(connection, cmd->fn); in drbdd()
5133 err = cmd->fn(connection, &pi); in drbdd()
5152 if (connection->cstate == C_STANDALONE) in conn_disconnect()
5163 drbd_thread_stop(&connection->ack_receiver); in conn_disconnect()
5164 if (connection->ack_sender) { in conn_disconnect()
5165 destroy_workqueue(connection->ack_sender); in conn_disconnect()
5166 connection->ack_sender = NULL; in conn_disconnect()
5171 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { in conn_disconnect()
5172 struct drbd_device *device = peer_device->device; in conn_disconnect()
5173 kref_get(&device->kref); in conn_disconnect()
5176 kref_put(&device->kref, drbd_destroy_device); in conn_disconnect()
5181 if (!list_empty(&connection->current_epoch->list)) in conn_disconnect()
5182 drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); in conn_disconnect()
5184 atomic_set(&connection->current_epoch->epoch_size, 0); in conn_disconnect()
5185 connection->send.seen_any_write_yet = false; in conn_disconnect()
5192 spin_lock_irq(&connection->resource->req_lock); in conn_disconnect()
5193 oc = connection->cstate; in conn_disconnect()
5197 spin_unlock_irq(&connection->resource->req_lock); in conn_disconnect()
5205 struct drbd_device *device = peer_device->device; in drbd_disconnected()
5209 spin_lock_irq(&device->resource->req_lock); in drbd_disconnected()
5210 _drbd_wait_ee_list_empty(device, &device->active_ee); in drbd_disconnected()
5211 _drbd_wait_ee_list_empty(device, &device->sync_ee); in drbd_disconnected()
5212 _drbd_wait_ee_list_empty(device, &device->read_ee); in drbd_disconnected()
5213 spin_unlock_irq(&device->resource->req_lock); in drbd_disconnected()
5223 * the disk-IO, while the rs_pending_cnt only tracks the blocks in drbd_disconnected()
5226 device->rs_total = 0; in drbd_disconnected()
5227 device->rs_failed = 0; in drbd_disconnected()
5228 atomic_set(&device->rs_pending_cnt, 0); in drbd_disconnected()
5229 wake_up(&device->misc_wait); in drbd_disconnected()
5231 del_timer_sync(&device->resync_timer); in drbd_disconnected()
5232 resync_timer_fn(&device->resync_timer); in drbd_disconnected()
5237 drbd_flush_workqueue(&peer_device->connection->sender_work); in drbd_disconnected()
5244 drbd_flush_workqueue(&peer_device->connection->sender_work); in drbd_disconnected()
5250 kfree(device->p_uuid); in drbd_disconnected()
5251 device->p_uuid = NULL; in drbd_disconnected()
5254 tl_clear(peer_device->connection); in drbd_disconnected()
5271 i = drbd_free_peer_reqs(device, &device->net_ee); in drbd_disconnected()
5274 i = atomic_read(&device->pp_in_use_by_net); in drbd_disconnected()
5277 i = atomic_read(&device->pp_in_use); in drbd_disconnected()
5281 D_ASSERT(device, list_empty(&device->read_ee)); in drbd_disconnected()
5282 D_ASSERT(device, list_empty(&device->active_ee)); in drbd_disconnected()
5283 D_ASSERT(device, list_empty(&device->sync_ee)); in drbd_disconnected()
5284 D_ASSERT(device, list_empty(&device->done_ee)); in drbd_disconnected()
5303 sock = &connection->data; in drbd_send_features()
5306 return -EIO; in drbd_send_features()
5308 p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); in drbd_send_features()
5309 p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); in drbd_send_features()
5310 p->feature_flags = cpu_to_be32(PRO_FEATURES); in drbd_send_features()
5318 * -1 peer talks different language,
5323 /* ASSERT current == connection->receiver ... */ in drbd_do_features()
5340 return -1; in drbd_do_features()
5346 return -1; in drbd_do_features()
5354 p->protocol_min = be32_to_cpu(p->protocol_min); in drbd_do_features()
5355 p->protocol_max = be32_to_cpu(p->protocol_max); in drbd_do_features()
5356 if (p->protocol_max == 0) in drbd_do_features()
5357 p->protocol_max = p->protocol_min; in drbd_do_features()
5359 if (PRO_VERSION_MAX < p->protocol_min || in drbd_do_features()
5360 PRO_VERSION_MIN > p->protocol_max) in drbd_do_features()
5363 connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); in drbd_do_features()
5364 connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags); in drbd_do_features()
5367 "Agreed network protocol version %d\n", connection->agreed_pro_version); in drbd_do_features()
5370 connection->agreed_features, in drbd_do_features()
5371 connection->agreed_features & DRBD_FF_TRIM ? " TRIM" : "", in drbd_do_features()
5372 connection->agreed_features & DRBD_FF_THIN_RESYNC ? " THIN_RESYNC" : "", in drbd_do_features()
5373 connection->agreed_features & DRBD_FF_WSAME ? " WRITE_SAME" : "", in drbd_do_features()
5374 connection->agreed_features & DRBD_FF_WZEROES ? " WRITE_ZEROES" : in drbd_do_features()
5375 connection->agreed_features ? "" : " none"); in drbd_do_features()
5381 "I support %d-%d, peer supports %d-%d\n", in drbd_do_features()
5383 p->protocol_min, p->protocol_max); in drbd_do_features()
5384 return -1; in drbd_do_features()
5391 drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); in drbd_do_auth()
5392 return -1; in drbd_do_auth()
5398 1 - auth succeeded,
5399 0 - failed, try again (network error),
5400 -1 - auth failed, don't try again.
5421 nc = rcu_dereference(connection->net_conf); in drbd_do_auth()
5422 key_len = strlen(nc->shared_secret); in drbd_do_auth()
5423 memcpy(secret, nc->shared_secret, key_len); in drbd_do_auth()
5427 crypto_shash_descsize(connection->cram_hmac_tfm), in drbd_do_auth()
5430 rv = -1; in drbd_do_auth()
5433 desc->tfm = connection->cram_hmac_tfm; in drbd_do_auth()
5435 rv = crypto_shash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); in drbd_do_auth()
5438 rv = -1; in drbd_do_auth()
5444 sock = &connection->data; in drbd_do_auth()
5463 rv = -1; in drbd_do_auth()
5469 rv = -1; in drbd_do_auth()
5475 rv = -1; in drbd_do_auth()
5481 rv = -1; in drbd_do_auth()
5493 rv = -1; in drbd_do_auth()
5497 resp_size = crypto_shash_digestsize(connection->cram_hmac_tfm); in drbd_do_auth()
5500 rv = -1; in drbd_do_auth()
5507 rv = -1; in drbd_do_auth()
5547 rv = -1; in drbd_do_auth()
5555 rv = -1; in drbd_do_auth()
5565 rv = -1; in drbd_do_auth()
5582 struct drbd_connection *connection = thi->connection; in drbd_receiver()
5593 if (h == -1) { in drbd_receiver()
5600 blk_start_plug(&connection->receiver_plug); in drbd_receiver()
5602 blk_finish_plug(&connection->receiver_plug); in drbd_receiver()
5615 struct p_req_state_reply *p = pi->data; in got_conn_RqSReply()
5616 int retcode = be32_to_cpu(p->retcode); in got_conn_RqSReply()
5619 set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); in got_conn_RqSReply()
5621 set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); in got_conn_RqSReply()
5625 wake_up(&connection->ping_wait); in got_conn_RqSReply()
5634 struct p_req_state_reply *p = pi->data; in got_RqSReply()
5635 int retcode = be32_to_cpu(p->retcode); in got_RqSReply()
5637 peer_device = conn_peer_device(connection, pi->vnr); in got_RqSReply()
5639 return -EIO; in got_RqSReply()
5640 device = peer_device->device; in got_RqSReply()
5642 if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { in got_RqSReply()
5643 D_ASSERT(device, connection->agreed_pro_version < 100); in got_RqSReply()
5648 set_bit(CL_ST_CHG_SUCCESS, &device->flags); in got_RqSReply()
5650 set_bit(CL_ST_CHG_FAIL, &device->flags); in got_RqSReply()
5654 wake_up(&device->state_wait); in got_RqSReply()
5668 connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; in got_PingAck()
5669 if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) in got_PingAck()
5670 wake_up(&connection->ping_wait); in got_PingAck()
5679 struct p_block_ack *p = pi->data; in got_IsInSync()
5680 sector_t sector = be64_to_cpu(p->sector); in got_IsInSync()
5681 int blksize = be32_to_cpu(p->blksize); in got_IsInSync()
5683 peer_device = conn_peer_device(connection, pi->vnr); in got_IsInSync()
5685 return -EIO; in got_IsInSync()
5686 device = peer_device->device; in got_IsInSync()
5688 D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); in got_IsInSync()
5690 update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); in got_IsInSync()
5696 device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); in got_IsInSync()
5700 atomic_add(blksize >> 9, &device->rs_sect_in); in got_IsInSync()
5713 spin_lock_irq(&device->resource->req_lock); in validate_req_change_req_state()
5716 spin_unlock_irq(&device->resource->req_lock); in validate_req_change_req_state()
5717 return -EIO; in validate_req_change_req_state()
5720 spin_unlock_irq(&device->resource->req_lock); in validate_req_change_req_state()
5731 struct p_block_ack *p = pi->data; in got_BlockAck()
5732 sector_t sector = be64_to_cpu(p->sector); in got_BlockAck()
5733 int blksize = be32_to_cpu(p->blksize); in got_BlockAck()
5736 peer_device = conn_peer_device(connection, pi->vnr); in got_BlockAck()
5738 return -EIO; in got_BlockAck()
5739 device = peer_device->device; in got_BlockAck()
5741 update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); in got_BlockAck()
5743 if (p->block_id == ID_SYNCER) { in got_BlockAck()
5748 switch (pi->cmd) { in got_BlockAck()
5768 return validate_req_change_req_state(device, p->block_id, sector, in got_BlockAck()
5769 &device->write_requests, __func__, in got_BlockAck()
5777 struct p_block_ack *p = pi->data; in got_NegAck()
5778 sector_t sector = be64_to_cpu(p->sector); in got_NegAck()
5779 int size = be32_to_cpu(p->blksize); in got_NegAck()
5782 peer_device = conn_peer_device(connection, pi->vnr); in got_NegAck()
5784 return -EIO; in got_NegAck()
5785 device = peer_device->device; in got_NegAck()
5787 update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); in got_NegAck()
5789 if (p->block_id == ID_SYNCER) { in got_NegAck()
5795 err = validate_req_change_req_state(device, p->block_id, sector, in got_NegAck()
5796 &device->write_requests, __func__, in got_NegAck()
5813 struct p_block_ack *p = pi->data; in got_NegDReply()
5814 sector_t sector = be64_to_cpu(p->sector); in got_NegDReply()
5816 peer_device = conn_peer_device(connection, pi->vnr); in got_NegDReply()
5818 return -EIO; in got_NegDReply()
5819 device = peer_device->device; in got_NegDReply()
5821 update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); in got_NegDReply()
5824 (unsigned long long)sector, be32_to_cpu(p->blksize)); in got_NegDReply()
5826 return validate_req_change_req_state(device, p->block_id, sector, in got_NegDReply()
5827 &device->read_requests, __func__, in got_NegDReply()
5837 struct p_block_ack *p = pi->data; in got_NegRSDReply()
5839 peer_device = conn_peer_device(connection, pi->vnr); in got_NegRSDReply()
5841 return -EIO; in got_NegRSDReply()
5842 device = peer_device->device; in got_NegRSDReply()
5844 sector = be64_to_cpu(p->sector); in got_NegRSDReply()
5845 size = be32_to_cpu(p->blksize); in got_NegRSDReply()
5847 update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); in got_NegRSDReply()
5853 switch (pi->cmd) { in got_NegRSDReply()
5870 struct p_barrier_ack *p = pi->data; in got_BarrierAck()
5874 tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); in got_BarrierAck()
5877 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { in got_BarrierAck()
5878 struct drbd_device *device = peer_device->device; in got_BarrierAck()
5880 if (device->state.conn == C_AHEAD && in got_BarrierAck()
5881 atomic_read(&device->ap_in_flight) == 0 && in got_BarrierAck()
5882 !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { in got_BarrierAck()
5883 device->start_resync_timer.expires = jiffies + HZ; in got_BarrierAck()
5884 add_timer(&device->start_resync_timer); in got_BarrierAck()
5896 struct p_block_ack *p = pi->data; in got_OVResult()
5901 peer_device = conn_peer_device(connection, pi->vnr); in got_OVResult()
5903 return -EIO; in got_OVResult()
5904 device = peer_device->device; in got_OVResult()
5906 sector = be64_to_cpu(p->sector); in got_OVResult()
5907 size = be32_to_cpu(p->blksize); in got_OVResult()
5909 update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); in got_OVResult()
5911 if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) in got_OVResult()
5922 --device->ov_left; in got_OVResult()
5925 if ((device->ov_left & 0x200) == 0x200) in got_OVResult()
5926 drbd_advance_rs_marks(device, device->ov_left); in got_OVResult()
5928 if (device->ov_left == 0) { in got_OVResult()
5931 dw->w.cb = w_ov_finished; in got_OVResult()
5932 dw->device = device; in got_OVResult()
5933 drbd_queue_work(&peer_device->connection->sender_work, &dw->w); in got_OVResult()
5960 nc = rcu_dereference(connection->net_conf); in set_rcvtimeo()
5961 t = ping_timeout ? nc->ping_timeo : nc->ping_int; in set_rcvtimeo()
5968 connection->meta.socket->sk->sk_rcvtimeo = t; in set_rcvtimeo()
6003 struct drbd_connection *connection = thi->connection; in drbd_ack_receiver()
6008 void *buf = connection->meta.rbuf; in drbd_ack_receiver()
6021 if (test_and_clear_bit(SEND_PING, &connection->flags)) { in drbd_ack_receiver()
6031 rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); in drbd_ack_receiver()
6034 * -EINTR (on meta) we got a signal in drbd_ack_receiver()
6035 * -EAGAIN (on meta) rcvtimeo expired in drbd_ack_receiver()
6036 * -ECONNRESET other side closed the connection in drbd_ack_receiver()
6037 * -ERESTARTSYS (on data) we got a signal in drbd_ack_receiver()
6047 if (test_bit(DISCONNECT_SENT, &connection->flags)) { in drbd_ack_receiver()
6050 t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; in drbd_ack_receiver()
6053 t = wait_event_timeout(connection->ping_wait, in drbd_ack_receiver()
6054 connection->cstate < C_WF_REPORT_PARAMS, in drbd_ack_receiver()
6061 } else if (rv == -EAGAIN) { in drbd_ack_receiver()
6064 if (time_after(connection->last_received, pre_recv_jif)) in drbd_ack_receiver()
6070 set_bit(SEND_PING, &connection->flags); in drbd_ack_receiver()
6072 } else if (rv == -EINTR) { in drbd_ack_receiver()
6084 if (decode_header(connection, connection->meta.rbuf, &pi)) in drbd_ack_receiver()
6087 if (pi.cmd >= ARRAY_SIZE(ack_receiver_tbl) || !cmd->fn) { in drbd_ack_receiver()
6092 expect = header_size + cmd->pkt_size; in drbd_ack_receiver()
6093 if (pi.size != expect - header_size) { in drbd_ack_receiver()
6102 err = cmd->fn(connection, &pi); in drbd_ack_receiver()
6104 drbd_err(connection, "%ps failed\n", cmd->fn); in drbd_ack_receiver()
6108 connection->last_received = jiffies; in drbd_ack_receiver()
6115 buf = connection->meta.rbuf; in drbd_ack_receiver()
6137 void drbd_send_acks_wf(struct work_struct *ws) in drbd_send_acks_wf() argument
6140 container_of(ws, struct drbd_peer_device, send_acks_work); in drbd_send_acks_wf()
6141 struct drbd_connection *connection = peer_device->connection; in drbd_send_acks_wf()
6142 struct drbd_device *device = peer_device->device; in drbd_send_acks_wf()
6147 nc = rcu_dereference(connection->net_conf); in drbd_send_acks_wf()
6148 tcp_cork = nc->tcp_cork; in drbd_send_acks_wf()
6152 tcp_sock_set_cork(connection->meta.socket->sk, true); in drbd_send_acks_wf()
6155 kref_put(&device->kref, drbd_destroy_device); in drbd_send_acks_wf()
6165 tcp_sock_set_cork(connection->meta.socket->sk, false); in drbd_send_acks_wf()