block/drbd/drbd_main.c

161  * @connection:	DRBD connection.
167  * termination of the connection.
169 void tl_release(struct drbd_connection *connection, unsigned int barrier_nr,
177 	spin_lock_irq(&connection->resource->req_lock);
181 	list_for_each_entry(r, &connection->transfer_log, tl_requests) {
206 		drbd_err(connection, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
211 		drbd_err(connection, "BAD! BarrierAck #%u received, expected #%u!\n",
217 		drbd_err(connection, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
226 	list_for_each_entry(req, &connection->transfer_log, tl_requests)
231 	req = list_prepare_entry(tmp, &connection->transfer_log, tl_requests);
232 	list_for_each_entry_safe_from(req, r, &connection->transfer_log, tl_requests) {
236 		peer_device = conn_peer_device(connection, req->device->vnr);
239 	spin_unlock_irq(&connection->resource->req_lock);
244 	spin_unlock_irq(&connection->resource->req_lock);
245 	conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
251  * @connection:	DRBD connection to operate on.
258 void _tl_restart(struct drbd_connection *connection, enum drbd_req_event what)
263 	list_for_each_entry_safe(req, r, &connection->transfer_log, tl_requests) {
264 		peer_device = conn_peer_device(connection, req->device->vnr);
269 void tl_restart(struct drbd_connection *connection, enum drbd_req_event what)
271 	spin_lock_irq(&connection->resource->req_lock);
272 	_tl_restart(connection, what);
273 	spin_unlock_irq(&connection->resource->req_lock);
278  * @connection:	DRBD connection.
280  * This is called after the connection to the peer was lost. The storage covered
284 void tl_clear(struct drbd_connection *connection)
286 	tl_restart(connection, CONNECTION_LOST_WHILE_PENDING);
295 	struct drbd_connection *connection = first_peer_device(device)->connection;
298 	spin_lock_irq(&connection->resource->req_lock);
299 	list_for_each_entry_safe(req, r, &connection->transfer_log, tl_requests) {
306 	spin_unlock_irq(&connection->resource->req_lock);
354 	if (thi->connection)
355 		kref_put(&thi->connection->kref, drbd_destroy_connection);
369 	thi->connection = NULL;
396 		if (thi->connection)
397 			kref_get(&thi->connection->kref);
411 			if (thi->connection)
412 				kref_put(&thi->connection->kref, drbd_destroy_connection);
474 int conn_lowest_minor(struct drbd_connection *connection)
480 	peer_device = idr_get_next(&connection->peer_devices, &vnr);
554 unsigned int drbd_header_size(struct drbd_connection *connection)
556 	if (connection->agreed_pro_version >= 100) {
594 static unsigned int prepare_header(struct drbd_connection *connection, int vnr,
597 	if (connection->agreed_pro_version >= 100)
599 	else if (connection->agreed_pro_version >= 95 &&
606 static void *__conn_prepare_command(struct drbd_connection *connection,
611 	return sock->sbuf + drbd_header_size(connection);
614 void *conn_prepare_command(struct drbd_connection *connection, struct drbd_socket *sock)
619 	p = __conn_prepare_command(connection, sock);
628 	return conn_prepare_command(peer_device->connection, sock);
631 static int __send_command(struct drbd_connection *connection, int vnr,
648 	header_size += prepare_header(connection, vnr, sock->sbuf, cmd,
650 	err = drbd_send_all(connection, sock->socket, sock->sbuf, header_size,
653 		err = drbd_send_all(connection, sock->socket, data, size, 0);
662 static int __conn_send_command(struct drbd_connection *connection, struct drbd_socket *sock,
666 	return __send_command(connection, 0, sock, cmd, header_size, data, size);
669 int conn_send_command(struct drbd_connection *connection, struct drbd_socket *sock,
675 	err = __conn_send_command(connection, sock, cmd, header_size, data, size);
686 	err = __send_command(peer_device->connection, peer_device->device->vnr,
692 int drbd_send_ping(struct drbd_connection *connection)
696 	sock = &connection->meta;
697 	if (!conn_prepare_command(connection, sock))
699 	return conn_send_command(connection, sock, P_PING, 0, NULL, 0);
702 int drbd_send_ping_ack(struct drbd_connection *connection)
706 	sock = &connection->meta;
707 	if (!conn_prepare_command(connection, sock))
709 	return conn_send_command(connection, sock, P_PING_ACK, 0, NULL, 0);
717 	const int apv = peer_device->connection->agreed_pro_version;
722 	sock = &peer_device->connection->data;
728 	nc = rcu_dereference(peer_device->connection->net_conf);
767 int __drbd_send_protocol(struct drbd_connection *connection, enum drbd_packet cmd)
774 	sock = &connection->data;
775 	p = __conn_prepare_command(connection, sock);
780 	nc = rcu_dereference(connection->net_conf);
782 	if (nc->tentative && connection->agreed_pro_version < 92) {
784 		drbd_err(connection, "--dry-run is not supported by peer");
789 	if (connection->agreed_pro_version >= 87)
804 	if (connection->agreed_pro_version >= 87)
808 	return __conn_send_command(connection, sock, cmd, size, NULL, 0);
811 int drbd_send_protocol(struct drbd_connection *connection)
815 	mutex_lock(&connection->data.mutex);
816 	err = __drbd_send_protocol(connection, P_PROTOCOL);
817 	mutex_unlock(&connection->data.mutex);
832 	sock = &peer_device->connection->data;
846 	uuid_flags |= rcu_dereference(peer_device->connection->net_conf)->discard_my_data ? 1 : 0;
902 	sock = &peer_device->connection->data;
920 	sock = &peer_device->connection->data;
926 	if (peer_device->connection->agreed_features & DRBD_FF_WSAME)
969 	if (peer_device->connection->agreed_pro_version <= 94)
971 	else if (peer_device->connection->agreed_pro_version < 100)
996 	sock = &peer_device->connection->data;
1019 	sock = &peer_device->connection->data;
1032 	sock = &peer_device->connection->data;
1041 int conn_send_state_req(struct drbd_connection *connection, union drbd_state mask, union drbd_state val)
1047 	cmd = connection->agreed_pro_version < 100 ? P_STATE_CHG_REQ : P_CONN_ST_CHG_REQ;
1048 	sock = &connection->data;
1049 	p = conn_prepare_command(connection, sock);
1054 	return conn_send_command(connection, sock, cmd, sizeof(*p), NULL, 0);
1062 	sock = &peer_device->connection->meta;
1070 void conn_send_sr_reply(struct drbd_connection *connection, enum drbd_state_rv retcode)
1074 	enum drbd_packet cmd = connection->agreed_pro_version < 100 ? P_STATE_CHG_REPLY : P_CONN_ST_CHG_REPLY;
1076 	sock = &connection->meta;
1077 	p = conn_prepare_command(connection, sock);
1080 		conn_send_command(connection, sock, cmd, sizeof(*p), NULL, 0);
1116 	use_rle = rcu_dereference(first_peer_device(device)->connection->net_conf)->use_rle;
1118 	if (!use_rle || first_peer_device(device)->connection->agreed_pro_version < 90)
1208 	struct drbd_socket *sock = &peer_device->connection->data;
1209 	unsigned int header_size = drbd_header_size(peer_device->connection);
1220 		err = __send_command(peer_device->connection, device->vnr, sock,
1241 		err = __send_command(peer_device->connection, device->vnr, sock, P_BITMAP,
1303 	struct drbd_socket *sock = &peer_device->connection->data;
1313 void drbd_send_b_ack(struct drbd_connection *connection, u32 barrier_nr, u32 set_size)
1318 	if (connection->cstate < C_WF_REPORT_PARAMS)
1321 	sock = &connection->meta;
1322 	p = conn_prepare_command(connection, sock);
1327 	conn_send_command(connection, sock, P_BARRIER_ACK, sizeof(*p), NULL, 0);
1347 	sock = &peer_device->connection->meta;
1364 	if (peer_device->connection->peer_integrity_tfm)
1365 		data_size -= crypto_shash_digestsize(peer_device->connection->peer_integrity_tfm);
1408 	sock = &peer_device->connection->data;
1424 	sock = &peer_device->connection->data;
1442 	sock = &peer_device->connection->data;
1457 	sock = &peer_device->connection->data;
1469  * true if we think connection is dead
1471 static int we_should_drop_the_connection(struct drbd_connection *connection, struct socket *sock)
1476 	drop_it =   connection->meta.socket == sock
1477 		|| !connection->ack_receiver.task
1478 		|| get_t_state(&connection->ack_receiver) != RUNNING
1479 		|| connection->cstate < C_WF_REPORT_PARAMS;
1484 	drop_it = !--connection->ko_count;
1486 		drbd_err(connection, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
1487 			 current->comm, current->pid, connection->ko_count);
1488 		request_ping(connection);
1494 static void drbd_update_congested(struct drbd_connection *connection)
1496 	struct sock *sk = connection->data.socket->sk;
1498 		set_bit(NET_CONGESTED, &connection->flags);
1529 	socket = peer_device->connection->data.socket;
1531 	err = drbd_send_all(peer_device->connection, socket, addr, size, msg_flags);
1541 	struct socket *socket = peer_device->connection->data.socket;
1556 	drbd_update_congested(peer_device->connection);
1566 				if (we_should_drop_the_connection(peer_device->connection, socket))
1579 	clear_bit(NET_CONGESTED, &peer_device->connection->flags);
1645 static u32 bio_flags_to_wire(struct drbd_connection *connection,
1648 	if (connection->agreed_pro_version >= 95)
1654 			  ((connection->agreed_features & DRBD_FF_WZEROES) ?
1675 	sock = &peer_device->connection->data;
1677 	digest_size = peer_device->connection->integrity_tfm ?
1678 		      crypto_shash_digestsize(peer_device->connection->integrity_tfm) : 0;
1685 	dp_flags = bio_flags_to_wire(peer_device->connection, req->master_bio);
1689 	if (peer_device->connection->agreed_pro_version >= 100) {
1704 		err = __send_command(peer_device->connection, device->vnr, sock, cmd, sizeof(*t), NULL, 0);
1712 		drbd_csum_bio(peer_device->connection->integrity_tfm, req->master_bio, digest_out);
1713 	err = __send_command(peer_device->connection, device->vnr, sock, P_DATA,
1737 			drbd_csum_bio(peer_device->connection->integrity_tfm, req->master_bio, digest);
1766 	sock = &peer_device->connection->data;
1769 	digest_size = peer_device->connection->integrity_tfm ?
1770 		      crypto_shash_digestsize(peer_device->connection->integrity_tfm) : 0;
1779 		drbd_csum_ee(peer_device->connection->integrity_tfm, peer_req, p + 1);
1780 	err = __send_command(peer_device->connection, device->vnr, sock, cmd, sizeof(*p) + digest_size, NULL, peer_req->i.size);
1793 	sock = &peer_device->connection->data;
1818 int drbd_send(struct drbd_connection *connection, struct socket *sock,
1832 	if (sock == connection->data.socket) {
1834 		connection->ko_count = rcu_dereference(connection->net_conf)->ko_count;
1836 		drbd_update_congested(connection);
1841 			if (we_should_drop_the_connection(connection, sock))
1855 	if (sock == connection->data.socket)
1856 		clear_bit(NET_CONGESTED, &connection->flags);
1860 			drbd_err(connection, "%s_sendmsg returned %d\n",
1861 				 sock == connection->meta.socket ? "msock" : "sock",
1863 			conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD);
1865 			conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD);
1876 int drbd_send_all(struct drbd_connection *connection, struct socket *sock, void *buffer,
1881 	err = drbd_send(connection, sock, buffer, size, msg_flags);
1931 				&first_peer_device(device)->connection->sender_work,
2022 	if (first_peer_device(device)->connection->receiver.t_state != NONE)
2024 				first_peer_device(device)->connection->receiver.t_state);
2042 	D_ASSERT(device, first_peer_device(device)->connection->net_conf == NULL);
2062 	D_ASSERT(device, list_empty(&first_peer_device(device)->connection->sender_work.q));
2225 	/* not for_each_connection(connection, resource):
2229 		kref_put(&peer_device->connection->kref, drbd_destroy_connection);
2330 	struct drbd_connection *connection, *tmp;
2332 	for_each_connection_safe(connection, tmp, resource) {
2333 		list_del(&connection->connections);
2334 		drbd_debugfs_connection_cleanup(connection);
2335 		kref_put(&connection->kref, drbd_destroy_connection);
2437 	struct drbd_connection *connection;
2441 		for_each_connection_rcu(connection, resource) {
2442 			if (connection->my_addr_len == my_addr_len &&
2443 			    connection->peer_addr_len == peer_addr_len &&
2444 			    !memcmp(&connection->my_addr, my_addr, my_addr_len) &&
2445 			    !memcmp(&connection->peer_addr, peer_addr, peer_addr_len)) {
2446 				kref_get(&connection->kref);
2451 	connection = NULL;
2454 	return connection;
2474 void conn_free_crypto(struct drbd_connection *connection)
2476 	drbd_free_sock(connection);
2478 	crypto_free_shash(connection->csums_tfm);
2479 	crypto_free_shash(connection->verify_tfm);
2480 	crypto_free_shash(connection->cram_hmac_tfm);
2481 	crypto_free_shash(connection->integrity_tfm);
2482 	crypto_free_shash(connection->peer_integrity_tfm);
2483 	kfree(connection->int_dig_in);
2484 	kfree(connection->int_dig_vv);
2486 	connection->csums_tfm = NULL;
2487 	connection->verify_tfm = NULL;
2488 	connection->cram_hmac_tfm = NULL;
2489 	connection->integrity_tfm = NULL;
2490 	connection->peer_integrity_tfm = NULL;
2491 	connection->int_dig_in = NULL;
2492 	connection->int_dig_vv = NULL;
2497 	struct drbd_connection *connection;
2533 		for_each_connection_rcu(connection, resource) {
2534 			connection->receiver.reset_cpu_mask = 1;
2535 			connection->ack_receiver.reset_cpu_mask = 1;
2536 			connection->worker.reset_cpu_mask = 1;
2582 	struct drbd_connection *connection;
2584 	connection = kzalloc(sizeof(struct drbd_connection), GFP_KERNEL);
2585 	if (!connection)
2588 	if (drbd_alloc_socket(&connection->data))
2590 	if (drbd_alloc_socket(&connection->meta))
2593 	connection->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
2594 	if (!connection->current_epoch)
2597 	INIT_LIST_HEAD(&connection->transfer_log);
2599 	INIT_LIST_HEAD(&connection->current_epoch->list);
2600 	connection->epochs = 1;
2601 	spin_lock_init(&connection->epoch_lock);
2603 	connection->send.seen_any_write_yet = false;
2604 	connection->send.current_epoch_nr = 0;
2605 	connection->send.current_epoch_writes = 0;
2611 	connection->cstate = C_STANDALONE;
2612 	mutex_init(&connection->cstate_mutex);
2613 	init_waitqueue_head(&connection->ping_wait);
2614 	idr_init(&connection->peer_devices);
2616 	drbd_init_workqueue(&connection->sender_work);
2617 	mutex_init(&connection->data.mutex);
2618 	mutex_init(&connection->meta.mutex);
2620 	drbd_thread_init(resource, &connection->receiver, drbd_receiver, "receiver");
2621 	connection->receiver.connection = connection;
2622 	drbd_thread_init(resource, &connection->worker, drbd_worker, "worker");
2623 	connection->worker.connection = connection;
2624 	drbd_thread_init(resource, &connection->ack_receiver, drbd_ack_receiver, "ack_recv");
2625 	connection->ack_receiver.connection = connection;
2627 	kref_init(&connection->kref);
2629 	connection->resource = resource;
2635 	list_add_tail_rcu(&connection->connections, &resource->connections);
2636 	drbd_debugfs_connection_add(connection);
2637 	return connection;
2643 	kfree(connection->current_epoch);
2644 	drbd_free_socket(&connection->meta);
2645 	drbd_free_socket(&connection->data);
2646 	kfree(connection);
2652 	struct drbd_connection *connection = container_of(kref, struct drbd_connection, kref);
2653 	struct drbd_resource *resource = connection->resource;
2655 	if (atomic_read(&connection->current_epoch->epoch_size) !=  0)
2656 		drbd_err(connection, "epoch_size:%d\n", atomic_read(&connection->current_epoch->epoch_size));
2657 	kfree(connection->current_epoch);
2659 	idr_destroy(&connection->peer_devices);
2661 	drbd_free_socket(&connection->meta);
2662 	drbd_free_socket(&connection->data);
2663 	kfree(connection->int_dig_in);
2664 	kfree(connection->int_dig_vv);
2665 	kfree(connection);
2686 	struct drbd_connection *connection, *n;
2768 	for_each_connection(connection, resource) {
2772 		peer_device->connection = connection;
2778 		id = idr_alloc(&connection->peer_devices, peer_device, vnr, vnr + 1, GFP_KERNEL);
2784 		kref_get(&connection->kref);
2797 	/* inherit the connection state */
2812 	for_each_connection_safe(connection, n, resource) {
2813 		peer_device = idr_remove(&connection->peer_devices, vnr);
2815 			kref_put(&connection->kref, drbd_destroy_connection);
2840 	struct drbd_connection *connection;
2847 	for_each_connection(connection, resource) {
2848 		idr_remove(&connection->peer_devices, device->vnr);
2950 void drbd_free_sock(struct drbd_connection *connection)
2952 	if (connection->data.socket)
2953 		drbd_free_one_sock(&connection->data);
2954 	if (connection->meta.socket)
2955 		drbd_free_one_sock(&connection->meta);
2960 void conn_md_sync(struct drbd_connection *connection)
2966 	idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
3519 	D_ASSERT(device, current == peer_device->connection->worker.task);
3540 			drbd_queue_work(&peer_device->connection->sender_work,
3565 	D_ASSERT(device, current != first_peer_device(device)->connection->worker.task);
3693 	nc = rcu_dereference(first_peer_device(device)->connection->net_conf);