messenger.c 63.9 KB
Newer Older
1
#include <linux/ceph/ceph_debug.h>
S
Sage Weil 已提交
2 3 4 5 6 7 8

#include <linux/crc32c.h>
#include <linux/ctype.h>
#include <linux/highmem.h>
#include <linux/inet.h>
#include <linux/kthread.h>
#include <linux/net.h>
9
#include <linux/slab.h>
S
Sage Weil 已提交
10 11
#include <linux/socket.h>
#include <linux/string.h>
12 13
#include <linux/bio.h>
#include <linux/blkdev.h>
N
Noah Watkins 已提交
14
#include <linux/dns_resolver.h>
S
Sage Weil 已提交
15 16
#include <net/tcp.h>

17 18 19 20
#include <linux/ceph/libceph.h>
#include <linux/ceph/messenger.h>
#include <linux/ceph/decode.h>
#include <linux/ceph/pagelist.h>
21
#include <linux/export.h>
S
Sage Weil 已提交
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

/*
 * Ceph uses the messenger to exchange ceph_msg messages with other
 * hosts in the system.  The messenger provides ordered and reliable
 * delivery.  We tolerate TCP disconnects by reconnecting (with
 * exponential backoff) in the case of a fault (disconnection, bad
 * crc, protocol error).  Acks allow sent messages to be discarded by
 * the sender.
 */

/* static tag bytes (protocol control messages) */
static char tag_msg = CEPH_MSGR_TAG_MSG;
static char tag_ack = CEPH_MSGR_TAG_ACK;
static char tag_keepalive = CEPH_MSGR_TAG_KEEPALIVE;

37 38 39 40
#ifdef CONFIG_LOCKDEP
static struct lock_class_key socket_class;
#endif

S
Sage Weil 已提交
41 42 43 44 45 46

static void queue_con(struct ceph_connection *con);
static void con_work(struct work_struct *);
static void ceph_fault(struct ceph_connection *con);

/*
47 48
 * Nicely render a sockaddr as a string.  An array of formatted
 * strings is used, to approximate reentrancy.
S
Sage Weil 已提交
49
 */
50 51 52 53 54 55 56
#define ADDR_STR_COUNT_LOG	5	/* log2(# address strings in array) */
#define ADDR_STR_COUNT		(1 << ADDR_STR_COUNT_LOG)
#define ADDR_STR_COUNT_MASK	(ADDR_STR_COUNT - 1)
#define MAX_ADDR_STR_LEN	64	/* 54 is enough */

static char addr_str[ADDR_STR_COUNT][MAX_ADDR_STR_LEN];
static atomic_t addr_str_seq = ATOMIC_INIT(0);
S
Sage Weil 已提交
57

58 59 60
static struct page *zero_page;		/* used in certain error cases */
static void *zero_page_address;		/* kernel virtual addr of zero_page */

61
const char *ceph_pr_addr(const struct sockaddr_storage *ss)
S
Sage Weil 已提交
62 63 64 65 66 67
{
	int i;
	char *s;
	struct sockaddr_in *in4 = (void *)ss;
	struct sockaddr_in6 *in6 = (void *)ss;

68
	i = atomic_inc_return(&addr_str_seq) & ADDR_STR_COUNT_MASK;
S
Sage Weil 已提交
69 70 71 72
	s = addr_str[i];

	switch (ss->ss_family) {
	case AF_INET:
S
Sage Weil 已提交
73 74
		snprintf(s, MAX_ADDR_STR_LEN, "%pI4:%u", &in4->sin_addr,
			 (unsigned int)ntohs(in4->sin_port));
S
Sage Weil 已提交
75 76 77
		break;

	case AF_INET6:
S
Sage Weil 已提交
78 79
		snprintf(s, MAX_ADDR_STR_LEN, "[%pI6c]:%u", &in6->sin6_addr,
			 (unsigned int)ntohs(in6->sin6_port));
S
Sage Weil 已提交
80 81 82
		break;

	default:
83 84
		snprintf(s, MAX_ADDR_STR_LEN, "(unknown sockaddr family %d)",
			 (int)ss->ss_family);
S
Sage Weil 已提交
85 86 87 88
	}

	return s;
}
89
EXPORT_SYMBOL(ceph_pr_addr);
S
Sage Weil 已提交
90

91 92 93 94 95 96
static void encode_my_addr(struct ceph_messenger *msgr)
{
	memcpy(&msgr->my_enc_addr, &msgr->inst.addr, sizeof(msgr->my_enc_addr));
	ceph_encode_addr(&msgr->my_enc_addr);
}

S
Sage Weil 已提交
97 98 99 100 101
/*
 * work queue for all reading and writing to/from the socket.
 */
struct workqueue_struct *ceph_msgr_wq;

102
int ceph_msgr_init(void)
S
Sage Weil 已提交
103
{
104 105 106 107 108 109 110
	BUG_ON(zero_page != NULL);
	zero_page = ZERO_PAGE(0);
	page_cache_get(zero_page);

	BUG_ON(zero_page_address != NULL);
	zero_page_address = kmap(zero_page);

111
	ceph_msgr_wq = alloc_workqueue("ceph-msgr", WQ_NON_REENTRANT, 0);
S
Sage Weil 已提交
112 113
	if (!ceph_msgr_wq) {
		pr_err("msgr_init failed to create workqueue\n");
114 115 116 117 118 119

		zero_page_address = NULL;
		kunmap(zero_page);
		page_cache_release(zero_page);
		zero_page = NULL;

S
Sage Weil 已提交
120
		return -ENOMEM;
S
Sage Weil 已提交
121
	}
122

S
Sage Weil 已提交
123 124
	return 0;
}
125
EXPORT_SYMBOL(ceph_msgr_init);
S
Sage Weil 已提交
126 127 128

void ceph_msgr_exit(void)
{
129
	BUG_ON(ceph_msgr_wq == NULL);
S
Sage Weil 已提交
130
	destroy_workqueue(ceph_msgr_wq);
131 132 133 134 135 136 137 138

	BUG_ON(zero_page_address == NULL);
	zero_page_address = NULL;

	BUG_ON(zero_page == NULL);
	kunmap(zero_page);
	page_cache_release(zero_page);
	zero_page = NULL;
S
Sage Weil 已提交
139
}
140
EXPORT_SYMBOL(ceph_msgr_exit);
S
Sage Weil 已提交
141

Y
Yehuda Sadeh 已提交
142
void ceph_msgr_flush(void)
143 144 145
{
	flush_workqueue(ceph_msgr_wq);
}
146
EXPORT_SYMBOL(ceph_msgr_flush);
147 148


S
Sage Weil 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
/*
 * socket callback functions
 */

/* data available on socket, or listen socket received a connect */
static void ceph_data_ready(struct sock *sk, int count_unused)
{
	struct ceph_connection *con =
		(struct ceph_connection *)sk->sk_user_data;
	if (sk->sk_state != TCP_CLOSE_WAIT) {
		dout("ceph_data_ready on %p state = %lu, queueing work\n",
		     con, con->state);
		queue_con(con);
	}
}

/* socket has buffer space for writing */
static void ceph_write_space(struct sock *sk)
{
	struct ceph_connection *con =
		(struct ceph_connection *)sk->sk_user_data;

171 172 173 174 175 176 177
	/* only queue to workqueue if there is data we want to write,
	 * and there is sufficient space in the socket buffer to accept
	 * more data.  clear SOCK_NOSPACE so that ceph_write_space()
	 * doesn't get called again until try_write() fills the socket
	 * buffer. See net/ipv4/tcp_input.c:tcp_check_space()
	 * and net/core/stream.c:sk_stream_write_space().
	 */
S
Sage Weil 已提交
178
	if (test_bit(WRITE_PENDING, &con->state)) {
179 180 181 182 183
		if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
			dout("ceph_write_space %p queueing write work\n", con);
			clear_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
			queue_con(con);
		}
S
Sage Weil 已提交
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
	} else {
		dout("ceph_write_space %p nothing to write\n", con);
	}
}

/* socket's state has changed */
static void ceph_state_change(struct sock *sk)
{
	struct ceph_connection *con =
		(struct ceph_connection *)sk->sk_user_data;

	dout("ceph_state_change %p state = %lu sk_state = %u\n",
	     con, con->state, sk->sk_state);

	if (test_bit(CLOSED, &con->state))
		return;

	switch (sk->sk_state) {
	case TCP_CLOSE:
		dout("ceph_state_change TCP_CLOSE\n");
	case TCP_CLOSE_WAIT:
		dout("ceph_state_change TCP_CLOSE_WAIT\n");
		if (test_and_set_bit(SOCK_CLOSED, &con->state) == 0) {
			if (test_bit(CONNECTING, &con->state))
				con->error_msg = "connection failed";
			else
				con->error_msg = "socket closed";
			queue_con(con);
		}
		break;
	case TCP_ESTABLISHED:
		dout("ceph_state_change TCP_ESTABLISHED\n");
		queue_con(con);
		break;
	}
}

/*
 * set up socket callbacks
 */
static void set_sock_callbacks(struct socket *sock,
			       struct ceph_connection *con)
{
	struct sock *sk = sock->sk;
	sk->sk_user_data = (void *)con;
	sk->sk_data_ready = ceph_data_ready;
	sk->sk_write_space = ceph_write_space;
	sk->sk_state_change = ceph_state_change;
}


/*
 * socket helpers
 */

/*
 * initiate connection to a remote socket.
 */
static struct socket *ceph_tcp_connect(struct ceph_connection *con)
{
S
Sage Weil 已提交
244
	struct sockaddr_storage *paddr = &con->peer_addr.in_addr;
S
Sage Weil 已提交
245 246 247 248
	struct socket *sock;
	int ret;

	BUG_ON(con->sock);
S
Sage Weil 已提交
249 250
	ret = sock_create_kern(con->peer_addr.in_addr.ss_family, SOCK_STREAM,
			       IPPROTO_TCP, &sock);
S
Sage Weil 已提交
251 252 253 254
	if (ret)
		return ERR_PTR(ret);
	sock->sk->sk_allocation = GFP_NOFS;

255 256 257 258
#ifdef CONFIG_LOCKDEP
	lockdep_set_class(&sock->sk->sk_lock, &socket_class);
#endif

S
Sage Weil 已提交
259 260
	set_sock_callbacks(sock, con);

261
	dout("connect %s\n", ceph_pr_addr(&con->peer_addr.in_addr));
S
Sage Weil 已提交
262

S
Sage Weil 已提交
263 264
	ret = sock->ops->connect(sock, (struct sockaddr *)paddr, sizeof(*paddr),
				 O_NONBLOCK);
S
Sage Weil 已提交
265 266
	if (ret == -EINPROGRESS) {
		dout("connect %s EINPROGRESS sk_state = %u\n",
267
		     ceph_pr_addr(&con->peer_addr.in_addr),
S
Sage Weil 已提交
268
		     sock->sk->sk_state);
269
	} else if (ret < 0) {
S
Sage Weil 已提交
270
		pr_err("connect %s error %d\n",
271
		       ceph_pr_addr(&con->peer_addr.in_addr), ret);
S
Sage Weil 已提交
272 273 274 275
		sock_release(sock);
		con->error_msg = "connect error";

		return ERR_PTR(ret);
276 277 278
	}
	con->sock = sock;

S
Sage Weil 已提交
279 280 281 282 283 284 285
	return sock;
}

static int ceph_tcp_recvmsg(struct socket *sock, void *buf, size_t len)
{
	struct kvec iov = {buf, len};
	struct msghdr msg = { .msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL };
286
	int r;
S
Sage Weil 已提交
287

288 289 290 291
	r = kernel_recvmsg(sock, &msg, &iov, 1, len, msg.msg_flags);
	if (r == -EAGAIN)
		r = 0;
	return r;
S
Sage Weil 已提交
292 293 294 295 296 297 298 299 300 301
}

/*
 * write something.  @more is true if caller will be sending more data
 * shortly.
 */
static int ceph_tcp_sendmsg(struct socket *sock, struct kvec *iov,
		     size_t kvlen, size_t len, int more)
{
	struct msghdr msg = { .msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL };
302
	int r;
S
Sage Weil 已提交
303 304 305 306 307 308

	if (more)
		msg.msg_flags |= MSG_MORE;
	else
		msg.msg_flags |= MSG_EOR;  /* superfluous, but what the hell */

309 310 311 312
	r = kernel_sendmsg(sock, &msg, iov, kvlen, len);
	if (r == -EAGAIN)
		r = 0;
	return r;
S
Sage Weil 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
}


/*
 * Shutdown/close the socket for the given connection.
 */
static int con_close_socket(struct ceph_connection *con)
{
	int rc;

	dout("con_close_socket on %p sock %p\n", con, con->sock);
	if (!con->sock)
		return 0;
	set_bit(SOCK_CLOSED, &con->state);
	rc = con->sock->ops->shutdown(con->sock, SHUT_RDWR);
	sock_release(con->sock);
	con->sock = NULL;
	clear_bit(SOCK_CLOSED, &con->state);
	return rc;
}

/*
 * Reset a connection.  Discard all incoming and outgoing messages
 * and clear *_seq state.
 */
static void ceph_msg_remove(struct ceph_msg *msg)
{
	list_del_init(&msg->list_head);
	ceph_msg_put(msg);
}
static void ceph_msg_remove_list(struct list_head *head)
{
	while (!list_empty(head)) {
		struct ceph_msg *msg = list_first_entry(head, struct ceph_msg,
							list_head);
		ceph_msg_remove(msg);
	}
}

static void reset_connection(struct ceph_connection *con)
{
	/* reset connection, out_queue, msg_ and connect_seq */
	/* discard existing out_queue and msg_seq */
	ceph_msg_remove_list(&con->out_queue);
	ceph_msg_remove_list(&con->out_sent);

359 360 361 362 363
	if (con->in_msg) {
		ceph_msg_put(con->in_msg);
		con->in_msg = NULL;
	}

S
Sage Weil 已提交
364 365
	con->connect_seq = 0;
	con->out_seq = 0;
366 367 368 369
	if (con->out_msg) {
		ceph_msg_put(con->out_msg);
		con->out_msg = NULL;
	}
S
Sage Weil 已提交
370
	con->in_seq = 0;
371
	con->in_seq_acked = 0;
S
Sage Weil 已提交
372 373 374 375 376 377 378
}

/*
 * mark a peer down.  drop any open connections.
 */
void ceph_con_close(struct ceph_connection *con)
{
379 380
	dout("con_close %p peer %s\n", con,
	     ceph_pr_addr(&con->peer_addr.in_addr));
S
Sage Weil 已提交
381 382
	set_bit(CLOSED, &con->state);  /* in case there's queued work */
	clear_bit(STANDBY, &con->state);  /* avoid connect_seq bump */
S
Sage Weil 已提交
383 384 385
	clear_bit(LOSSYTX, &con->state);  /* so we retry next connect */
	clear_bit(KEEPALIVE_PENDING, &con->state);
	clear_bit(WRITE_PENDING, &con->state);
386
	mutex_lock(&con->mutex);
S
Sage Weil 已提交
387
	reset_connection(con);
S
Sage Weil 已提交
388
	con->peer_global_seq = 0;
389
	cancel_delayed_work(&con->work);
390
	mutex_unlock(&con->mutex);
S
Sage Weil 已提交
391 392
	queue_con(con);
}
393
EXPORT_SYMBOL(ceph_con_close);
S
Sage Weil 已提交
394 395 396 397 398 399

/*
 * Reopen a closed connection, with a new peer address.
 */
void ceph_con_open(struct ceph_connection *con, struct ceph_entity_addr *addr)
{
400
	dout("con_open %p %s\n", con, ceph_pr_addr(&addr->in_addr));
S
Sage Weil 已提交
401 402 403
	set_bit(OPENING, &con->state);
	clear_bit(CLOSED, &con->state);
	memcpy(&con->peer_addr, addr, sizeof(*addr));
404
	con->delay = 0;      /* reset backoff memory */
S
Sage Weil 已提交
405 406
	queue_con(con);
}
407
EXPORT_SYMBOL(ceph_con_open);
S
Sage Weil 已提交
408

409 410 411 412 413 414 415 416
/*
 * return true if this connection ever successfully opened
 */
bool ceph_con_opened(struct ceph_connection *con)
{
	return con->connect_seq > 0;
}

S
Sage Weil 已提交
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
/*
 * generic get/put
 */
struct ceph_connection *ceph_con_get(struct ceph_connection *con)
{
	dout("con_get %p nref = %d -> %d\n", con,
	     atomic_read(&con->nref), atomic_read(&con->nref) + 1);
	if (atomic_inc_not_zero(&con->nref))
		return con;
	return NULL;
}

void ceph_con_put(struct ceph_connection *con)
{
	dout("con_put %p nref = %d -> %d\n", con,
	     atomic_read(&con->nref), atomic_read(&con->nref) - 1);
	BUG_ON(atomic_read(&con->nref) == 0);
	if (atomic_dec_and_test(&con->nref)) {
435
		BUG_ON(con->sock);
S
Sage Weil 已提交
436 437 438 439 440 441 442 443 444 445 446 447 448
		kfree(con);
	}
}

/*
 * initialize a new connection.
 */
void ceph_con_init(struct ceph_messenger *msgr, struct ceph_connection *con)
{
	dout("con_init %p\n", con);
	memset(con, 0, sizeof(*con));
	atomic_set(&con->nref, 1);
	con->msgr = msgr;
449
	mutex_init(&con->mutex);
S
Sage Weil 已提交
450 451 452 453
	INIT_LIST_HEAD(&con->out_queue);
	INIT_LIST_HEAD(&con->out_sent);
	INIT_DELAYED_WORK(&con->work, con_work);
}
454
EXPORT_SYMBOL(ceph_con_init);
S
Sage Weil 已提交
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488


/*
 * We maintain a global counter to order connection attempts.  Get
 * a unique seq greater than @gt.
 */
static u32 get_global_seq(struct ceph_messenger *msgr, u32 gt)
{
	u32 ret;

	spin_lock(&msgr->global_seq_lock);
	if (msgr->global_seq < gt)
		msgr->global_seq = gt;
	ret = ++msgr->global_seq;
	spin_unlock(&msgr->global_seq_lock);
	return ret;
}


/*
 * Prepare footer for currently outgoing message, and finish things
 * off.  Assumes out_kvec* are already valid.. we just add on to the end.
 */
static void prepare_write_message_footer(struct ceph_connection *con, int v)
{
	struct ceph_msg *m = con->out_msg;

	dout("prepare_write_message_footer %p\n", con);
	con->out_kvec_is_msg = true;
	con->out_kvec[v].iov_base = &m->footer;
	con->out_kvec[v].iov_len = sizeof(m->footer);
	con->out_kvec_bytes += sizeof(m->footer);
	con->out_kvec_left++;
	con->out_more = m->more_to_follow;
489
	con->out_msg_done = true;
S
Sage Weil 已提交
490 491 492 493 494 495 496 497 498 499 500 501
}

/*
 * Prepare headers for the next outgoing message.
 */
static void prepare_write_message(struct ceph_connection *con)
{
	struct ceph_msg *m;
	int v = 0;

	con->out_kvec_bytes = 0;
	con->out_kvec_is_msg = true;
502
	con->out_msg_done = false;
S
Sage Weil 已提交
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517

	/* Sneak an ack in there first?  If we can get it into the same
	 * TCP packet that's a good thing. */
	if (con->in_seq > con->in_seq_acked) {
		con->in_seq_acked = con->in_seq;
		con->out_kvec[v].iov_base = &tag_ack;
		con->out_kvec[v++].iov_len = 1;
		con->out_temp_ack = cpu_to_le64(con->in_seq_acked);
		con->out_kvec[v].iov_base = &con->out_temp_ack;
		con->out_kvec[v++].iov_len = sizeof(con->out_temp_ack);
		con->out_kvec_bytes = 1 + sizeof(con->out_temp_ack);
	}

	m = list_first_entry(&con->out_queue,
		       struct ceph_msg, list_head);
518
	con->out_msg = m;
519 520 521 522

	/* put message on sent list */
	ceph_msg_get(m);
	list_move_tail(&m->list_head, &con->out_sent);
S
Sage Weil 已提交
523

524 525 526 527 528 529 530 531
	/*
	 * only assign outgoing seq # if we haven't sent this message
	 * yet.  if it is requeued, resend with it's original seq.
	 */
	if (m->needs_out_seq) {
		m->hdr.seq = cpu_to_le64(++con->out_seq);
		m->needs_out_seq = false;
	}
S
Sage Weil 已提交
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574

	dout("prepare_write_message %p seq %lld type %d len %d+%d+%d %d pgs\n",
	     m, con->out_seq, le16_to_cpu(m->hdr.type),
	     le32_to_cpu(m->hdr.front_len), le32_to_cpu(m->hdr.middle_len),
	     le32_to_cpu(m->hdr.data_len),
	     m->nr_pages);
	BUG_ON(le32_to_cpu(m->hdr.front_len) != m->front.iov_len);

	/* tag + hdr + front + middle */
	con->out_kvec[v].iov_base = &tag_msg;
	con->out_kvec[v++].iov_len = 1;
	con->out_kvec[v].iov_base = &m->hdr;
	con->out_kvec[v++].iov_len = sizeof(m->hdr);
	con->out_kvec[v++] = m->front;
	if (m->middle)
		con->out_kvec[v++] = m->middle->vec;
	con->out_kvec_left = v;
	con->out_kvec_bytes += 1 + sizeof(m->hdr) + m->front.iov_len +
		(m->middle ? m->middle->vec.iov_len : 0);
	con->out_kvec_cur = con->out_kvec;

	/* fill in crc (except data pages), footer */
	con->out_msg->hdr.crc =
		cpu_to_le32(crc32c(0, (void *)&m->hdr,
				      sizeof(m->hdr) - sizeof(m->hdr.crc)));
	con->out_msg->footer.flags = CEPH_MSG_FOOTER_COMPLETE;
	con->out_msg->footer.front_crc =
		cpu_to_le32(crc32c(0, m->front.iov_base, m->front.iov_len));
	if (m->middle)
		con->out_msg->footer.middle_crc =
			cpu_to_le32(crc32c(0, m->middle->vec.iov_base,
					   m->middle->vec.iov_len));
	else
		con->out_msg->footer.middle_crc = 0;
	con->out_msg->footer.data_crc = 0;
	dout("prepare_write_message front_crc %u data_crc %u\n",
	     le32_to_cpu(con->out_msg->footer.front_crc),
	     le32_to_cpu(con->out_msg->footer.middle_crc));

	/* is there a data payload? */
	if (le32_to_cpu(m->hdr.data_len) > 0) {
		/* initialize page iterator */
		con->out_msg_pos.page = 0;
575
		if (m->pages)
576
			con->out_msg_pos.page_pos = m->page_alignment;
577 578
		else
			con->out_msg_pos.page_pos = 0;
S
Sage Weil 已提交
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
		con->out_msg_pos.data_pos = 0;
		con->out_msg_pos.did_page_crc = 0;
		con->out_more = 1;  /* data + footer will follow */
	} else {
		/* no, queue up footer too and be done */
		prepare_write_message_footer(con, v);
	}

	set_bit(WRITE_PENDING, &con->state);
}

/*
 * Prepare an ack.
 */
static void prepare_write_ack(struct ceph_connection *con)
{
	dout("prepare_write_ack %p %llu -> %llu\n", con,
	     con->in_seq_acked, con->in_seq);
	con->in_seq_acked = con->in_seq;

	con->out_kvec[0].iov_base = &tag_ack;
	con->out_kvec[0].iov_len = 1;
	con->out_temp_ack = cpu_to_le64(con->in_seq_acked);
	con->out_kvec[1].iov_base = &con->out_temp_ack;
	con->out_kvec[1].iov_len = sizeof(con->out_temp_ack);
	con->out_kvec_left = 2;
	con->out_kvec_bytes = 1 + sizeof(con->out_temp_ack);
	con->out_kvec_cur = con->out_kvec;
	con->out_more = 1;  /* more will follow.. eventually.. */
	set_bit(WRITE_PENDING, &con->state);
}

/*
 * Prepare to write keepalive byte.
 */
static void prepare_write_keepalive(struct ceph_connection *con)
{
	dout("prepare_write_keepalive %p\n", con);
	con->out_kvec[0].iov_base = &tag_keepalive;
	con->out_kvec[0].iov_len = 1;
	con->out_kvec_left = 1;
	con->out_kvec_bytes = 1;
	con->out_kvec_cur = con->out_kvec;
	set_bit(WRITE_PENDING, &con->state);
}

/*
 * Connection negotiation.
 */

629
static int prepare_connect_authorizer(struct ceph_connection *con)
630 631 632 633 634
{
	void *auth_buf;
	int auth_len = 0;
	int auth_protocol = 0;

635
	mutex_unlock(&con->mutex);
636 637 638 639 640
	if (con->ops->get_authorizer)
		con->ops->get_authorizer(con, &auth_buf, &auth_len,
					 &auth_protocol, &con->auth_reply_buf,
					 &con->auth_reply_buf_len,
					 con->auth_retry);
641
	mutex_lock(&con->mutex);
642

643 644 645 646
	if (test_bit(CLOSED, &con->state) ||
	    test_bit(OPENING, &con->state))
		return -EAGAIN;

647 648 649
	con->out_connect.authorizer_protocol = cpu_to_le32(auth_protocol);
	con->out_connect.authorizer_len = cpu_to_le32(auth_len);

650 651 652 653 654 655
	if (auth_len) {
		con->out_kvec[con->out_kvec_left].iov_base = auth_buf;
		con->out_kvec[con->out_kvec_left].iov_len = auth_len;
		con->out_kvec_left++;
		con->out_kvec_bytes += auth_len;
	}
656
	return 0;
657 658
}

S
Sage Weil 已提交
659 660 661
/*
 * We connected to a peer and are saying hello.
 */
662 663
static void prepare_write_banner(struct ceph_messenger *msgr,
				 struct ceph_connection *con)
S
Sage Weil 已提交
664 665
{
	int len = strlen(CEPH_BANNER);
666 667 668 669 670 671 672 673 674 675 676 677

	con->out_kvec[0].iov_base = CEPH_BANNER;
	con->out_kvec[0].iov_len = len;
	con->out_kvec[1].iov_base = &msgr->my_enc_addr;
	con->out_kvec[1].iov_len = sizeof(msgr->my_enc_addr);
	con->out_kvec_left = 2;
	con->out_kvec_bytes = len + sizeof(msgr->my_enc_addr);
	con->out_kvec_cur = con->out_kvec;
	con->out_more = 0;
	set_bit(WRITE_PENDING, &con->state);
}

678 679 680
static int prepare_write_connect(struct ceph_messenger *msgr,
				 struct ceph_connection *con,
				 int after_banner)
681
{
S
Sage Weil 已提交
682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
	unsigned global_seq = get_global_seq(con->msgr, 0);
	int proto;

	switch (con->peer_name.type) {
	case CEPH_ENTITY_TYPE_MON:
		proto = CEPH_MONC_PROTOCOL;
		break;
	case CEPH_ENTITY_TYPE_OSD:
		proto = CEPH_OSDC_PROTOCOL;
		break;
	case CEPH_ENTITY_TYPE_MDS:
		proto = CEPH_MDSC_PROTOCOL;
		break;
	default:
		BUG();
	}

	dout("prepare_write_connect %p cseq=%d gseq=%d proto=%d\n", con,
	     con->connect_seq, global_seq, proto);
701

702
	con->out_connect.features = cpu_to_le64(msgr->supported_features);
S
Sage Weil 已提交
703 704 705 706 707 708
	con->out_connect.host_type = cpu_to_le32(CEPH_ENTITY_TYPE_CLIENT);
	con->out_connect.connect_seq = cpu_to_le32(con->connect_seq);
	con->out_connect.global_seq = cpu_to_le32(global_seq);
	con->out_connect.protocol_version = cpu_to_le32(proto);
	con->out_connect.flags = 0;

709 710 711 712 713 714 715 716
	if (!after_banner) {
		con->out_kvec_left = 0;
		con->out_kvec_bytes = 0;
	}
	con->out_kvec[con->out_kvec_left].iov_base = &con->out_connect;
	con->out_kvec[con->out_kvec_left].iov_len = sizeof(con->out_connect);
	con->out_kvec_left++;
	con->out_kvec_bytes += sizeof(con->out_connect);
S
Sage Weil 已提交
717 718 719
	con->out_kvec_cur = con->out_kvec;
	con->out_more = 0;
	set_bit(WRITE_PENDING, &con->state);
720

721
	return prepare_connect_authorizer(con);
S
Sage Weil 已提交
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
}


/*
 * write as much of pending kvecs to the socket as we can.
 *  1 -> done
 *  0 -> socket full, but more to do
 * <0 -> error
 */
static int write_partial_kvec(struct ceph_connection *con)
{
	int ret;

	dout("write_partial_kvec %p %d left\n", con, con->out_kvec_bytes);
	while (con->out_kvec_bytes > 0) {
		ret = ceph_tcp_sendmsg(con->sock, con->out_kvec_cur,
				       con->out_kvec_left, con->out_kvec_bytes,
				       con->out_more);
		if (ret <= 0)
			goto out;
		con->out_kvec_bytes -= ret;
		if (con->out_kvec_bytes == 0)
			break;            /* done */
		while (ret > 0) {
			if (ret >= con->out_kvec_cur->iov_len) {
				ret -= con->out_kvec_cur->iov_len;
				con->out_kvec_cur++;
				con->out_kvec_left--;
			} else {
				con->out_kvec_cur->iov_len -= ret;
				con->out_kvec_cur->iov_base += ret;
				ret = 0;
				break;
			}
		}
	}
	con->out_kvec_left = 0;
	con->out_kvec_is_msg = false;
	ret = 1;
out:
	dout("write_partial_kvec %p %d left in %d kvecs ret = %d\n", con,
	     con->out_kvec_bytes, con->out_kvec_left, ret);
	return ret;  /* done! */
}

767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
#ifdef CONFIG_BLOCK
static void init_bio_iter(struct bio *bio, struct bio **iter, int *seg)
{
	if (!bio) {
		*iter = NULL;
		*seg = 0;
		return;
	}
	*iter = bio;
	*seg = bio->bi_idx;
}

static void iter_bio_next(struct bio **bio_iter, int *seg)
{
	if (*bio_iter == NULL)
		return;

	BUG_ON(*seg >= (*bio_iter)->bi_vcnt);

	(*seg)++;
	if (*seg == (*bio_iter)->bi_vcnt)
		init_bio_iter((*bio_iter)->bi_next, bio_iter, seg);
}
#endif

S
Sage Weil 已提交
792 793 794 795 796 797 798 799 800 801 802 803 804 805
/*
 * Write as much message data payload as we can.  If we finish, queue
 * up the footer.
 *  1 -> done, footer is now queued in out_kvec[].
 *  0 -> socket full, but more to do
 * <0 -> error
 */
static int write_partial_msg_pages(struct ceph_connection *con)
{
	struct ceph_msg *msg = con->out_msg;
	unsigned data_len = le32_to_cpu(msg->hdr.data_len);
	size_t len;
	int crc = con->msgr->nocrc;
	int ret;
806 807 808
	int total_max_write;
	int in_trail = 0;
	size_t trail_len = (msg->trail ? msg->trail->length : 0);
S
Sage Weil 已提交
809 810 811 812 813

	dout("write_partial_msg_pages %p msg %p page %d/%d offset %d\n",
	     con, con->out_msg, con->out_msg_pos.page, con->out_msg->nr_pages,
	     con->out_msg_pos.page_pos);

814 815 816 817 818 819
#ifdef CONFIG_BLOCK
	if (msg->bio && !msg->bio_iter)
		init_bio_iter(msg->bio, &msg->bio_iter, &msg->bio_seg);
#endif

	while (data_len > con->out_msg_pos.data_pos) {
S
Sage Weil 已提交
820 821
		struct page *page = NULL;
		void *kaddr = NULL;
822 823 824 825 826
		int max_write = PAGE_SIZE;
		int page_shift = 0;

		total_max_write = data_len - trail_len -
			con->out_msg_pos.data_pos;
S
Sage Weil 已提交
827 828 829 830 831 832

		/*
		 * if we are calculating the data crc (the default), we need
		 * to map the page.  if our pages[] has been revoked, use the
		 * zero page.
		 */
833 834 835 836 837 838 839 840 841 842 843 844 845

		/* have we reached the trail part of the data? */
		if (con->out_msg_pos.data_pos >= data_len - trail_len) {
			in_trail = 1;

			total_max_write = data_len - con->out_msg_pos.data_pos;

			page = list_first_entry(&msg->trail->head,
						struct page, lru);
			if (crc)
				kaddr = kmap(page);
			max_write = PAGE_SIZE;
		} else if (msg->pages) {
S
Sage Weil 已提交
846 847 848
			page = msg->pages[con->out_msg_pos.page];
			if (crc)
				kaddr = kmap(page);
849 850 851 852 853
		} else if (msg->pagelist) {
			page = list_first_entry(&msg->pagelist->head,
						struct page, lru);
			if (crc)
				kaddr = kmap(page);
854 855 856 857 858 859 860 861 862 863 864
#ifdef CONFIG_BLOCK
		} else if (msg->bio) {
			struct bio_vec *bv;

			bv = bio_iovec_idx(msg->bio_iter, msg->bio_seg);
			page = bv->bv_page;
			page_shift = bv->bv_offset;
			if (crc)
				kaddr = kmap(page) + page_shift;
			max_write = bv->bv_len;
#endif
S
Sage Weil 已提交
865
		} else {
866
			page = zero_page;
S
Sage Weil 已提交
867
			if (crc)
868
				kaddr = zero_page_address;
S
Sage Weil 已提交
869
		}
870 871 872
		len = min_t(int, max_write - con->out_msg_pos.page_pos,
			    total_max_write);

S
Sage Weil 已提交
873 874 875 876 877 878 879 880 881 882
		if (crc && !con->out_msg_pos.did_page_crc) {
			void *base = kaddr + con->out_msg_pos.page_pos;
			u32 tmpcrc = le32_to_cpu(con->out_msg->footer.data_crc);

			BUG_ON(kaddr == NULL);
			con->out_msg->footer.data_crc =
				cpu_to_le32(crc32c(tmpcrc, base, len));
			con->out_msg_pos.did_page_crc = 1;
		}
		ret = kernel_sendpage(con->sock, page,
883 884
				      con->out_msg_pos.page_pos + page_shift,
				      len,
S
Sage Weil 已提交
885 886 887
				      MSG_DONTWAIT | MSG_NOSIGNAL |
				      MSG_MORE);

888 889
		if (crc &&
		    (msg->pages || msg->pagelist || msg->bio || in_trail))
S
Sage Weil 已提交
890 891
			kunmap(page);

892 893
		if (ret == -EAGAIN)
			ret = 0;
S
Sage Weil 已提交
894 895 896 897 898 899 900 901 902
		if (ret <= 0)
			goto out;

		con->out_msg_pos.data_pos += ret;
		con->out_msg_pos.page_pos += ret;
		if (ret == len) {
			con->out_msg_pos.page_pos = 0;
			con->out_msg_pos.page++;
			con->out_msg_pos.did_page_crc = 0;
903 904 905 906
			if (in_trail)
				list_move_tail(&page->lru,
					       &msg->trail->head);
			else if (msg->pagelist)
907 908
				list_move_tail(&page->lru,
					       &msg->pagelist->head);
909 910 911 912
#ifdef CONFIG_BLOCK
			else if (msg->bio)
				iter_bio_next(&msg->bio_iter, &msg->bio_seg);
#endif
S
Sage Weil 已提交
913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
		}
	}

	dout("write_partial_msg_pages %p msg %p done\n", con, msg);

	/* prepare and queue up footer, too */
	if (!crc)
		con->out_msg->footer.flags |= CEPH_MSG_FOOTER_NOCRC;
	con->out_kvec_bytes = 0;
	con->out_kvec_left = 0;
	con->out_kvec_cur = con->out_kvec;
	prepare_write_message_footer(con, 0);
	ret = 1;
out:
	return ret;
}

/*
 * write some zeros
 */
static int write_partial_skip(struct ceph_connection *con)
{
	int ret;

	while (con->out_skip > 0) {
		struct kvec iov = {
939
			.iov_base = zero_page_address,
S
Sage Weil 已提交
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
			.iov_len = min(con->out_skip, (int)PAGE_CACHE_SIZE)
		};

		ret = ceph_tcp_sendmsg(con->sock, &iov, 1, iov.iov_len, 1);
		if (ret <= 0)
			goto out;
		con->out_skip -= ret;
	}
	ret = 1;
out:
	return ret;
}

/*
 * Prepare to read connection handshake, or an ack.
 */
956 957 958 959 960 961
static void prepare_read_banner(struct ceph_connection *con)
{
	dout("prepare_read_banner %p\n", con);
	con->in_base_pos = 0;
}

S
Sage Weil 已提交
962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
static void prepare_read_connect(struct ceph_connection *con)
{
	dout("prepare_read_connect %p\n", con);
	con->in_base_pos = 0;
}

static void prepare_read_ack(struct ceph_connection *con)
{
	dout("prepare_read_ack %p\n", con);
	con->in_base_pos = 0;
}

static void prepare_read_tag(struct ceph_connection *con)
{
	dout("prepare_read_tag %p\n", con);
	con->in_base_pos = 0;
	con->in_tag = CEPH_MSGR_TAG_READY;
}

/*
 * Prepare to read a message.
 */
static int prepare_read_message(struct ceph_connection *con)
{
	dout("prepare_read_message %p\n", con);
	BUG_ON(con->in_msg != NULL);
	con->in_base_pos = 0;
	con->in_front_crc = con->in_middle_crc = con->in_data_crc = 0;
	return 0;
}


static int read_partial(struct ceph_connection *con,
			int *to, int size, void *object)
{
	*to += size;
	while (con->in_base_pos < *to) {
		int left = *to - con->in_base_pos;
		int have = size - left;
		int ret = ceph_tcp_recvmsg(con->sock, object + have, left);
		if (ret <= 0)
			return ret;
		con->in_base_pos += ret;
	}
	return 1;
}


/*
 * Read all or part of the connect-side handshake on a new connection
 */
1013
static int read_partial_banner(struct ceph_connection *con)
S
Sage Weil 已提交
1014 1015 1016
{
	int ret, to = 0;

1017
	dout("read_partial_banner %p at %d\n", con, con->in_base_pos);
S
Sage Weil 已提交
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030

	/* peer's banner */
	ret = read_partial(con, &to, strlen(CEPH_BANNER), con->in_banner);
	if (ret <= 0)
		goto out;
	ret = read_partial(con, &to, sizeof(con->actual_peer_addr),
			   &con->actual_peer_addr);
	if (ret <= 0)
		goto out;
	ret = read_partial(con, &to, sizeof(con->peer_addr_for_me),
			   &con->peer_addr_for_me);
	if (ret <= 0)
		goto out;
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
out:
	return ret;
}

static int read_partial_connect(struct ceph_connection *con)
{
	int ret, to = 0;

	dout("read_partial_connect %p at %d\n", con, con->in_base_pos);

S
Sage Weil 已提交
1041 1042 1043
	ret = read_partial(con, &to, sizeof(con->in_reply), &con->in_reply);
	if (ret <= 0)
		goto out;
1044 1045 1046 1047
	ret = read_partial(con, &to, le32_to_cpu(con->in_reply.authorizer_len),
			   con->auth_reply_buf);
	if (ret <= 0)
		goto out;
S
Sage Weil 已提交
1048

1049 1050 1051
	dout("read_partial_connect %p tag %d, con_seq = %u, g_seq = %u\n",
	     con, (int)con->in_reply.tag,
	     le32_to_cpu(con->in_reply.connect_seq),
S
Sage Weil 已提交
1052 1053 1054
	     le32_to_cpu(con->in_reply.global_seq));
out:
	return ret;
1055

S
Sage Weil 已提交
1056 1057 1058 1059 1060 1061 1062 1063
}

/*
 * Verify the hello banner looks okay.
 */
static int verify_hello(struct ceph_connection *con)
{
	if (memcmp(con->in_banner, CEPH_BANNER, strlen(CEPH_BANNER))) {
1064
		pr_err("connect to %s got bad banner\n",
1065
		       ceph_pr_addr(&con->peer_addr.in_addr));
S
Sage Weil 已提交
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
		con->error_msg = "protocol error, bad banner";
		return -1;
	}
	return 0;
}

static bool addr_is_blank(struct sockaddr_storage *ss)
{
	switch (ss->ss_family) {
	case AF_INET:
		return ((struct sockaddr_in *)ss)->sin_addr.s_addr == 0;
	case AF_INET6:
		return
		     ((struct sockaddr_in6 *)ss)->sin6_addr.s6_addr32[0] == 0 &&
		     ((struct sockaddr_in6 *)ss)->sin6_addr.s6_addr32[1] == 0 &&
		     ((struct sockaddr_in6 *)ss)->sin6_addr.s6_addr32[2] == 0 &&
		     ((struct sockaddr_in6 *)ss)->sin6_addr.s6_addr32[3] == 0;
	}
	return false;
}

static int addr_port(struct sockaddr_storage *ss)
{
	switch (ss->ss_family) {
	case AF_INET:
S
Sage Weil 已提交
1091
		return ntohs(((struct sockaddr_in *)ss)->sin_port);
S
Sage Weil 已提交
1092
	case AF_INET6:
S
Sage Weil 已提交
1093
		return ntohs(((struct sockaddr_in6 *)ss)->sin6_port);
S
Sage Weil 已提交
1094 1095 1096 1097 1098 1099 1100 1101 1102
	}
	return 0;
}

static void addr_set_port(struct sockaddr_storage *ss, int p)
{
	switch (ss->ss_family) {
	case AF_INET:
		((struct sockaddr_in *)ss)->sin_port = htons(p);
1103
		break;
S
Sage Weil 已提交
1104 1105
	case AF_INET6:
		((struct sockaddr_in6 *)ss)->sin6_port = htons(p);
1106
		break;
S
Sage Weil 已提交
1107 1108 1109
	}
}

N
Noah Watkins 已提交
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
/*
 * Unlike other *_pton function semantics, zero indicates success.
 */
static int ceph_pton(const char *str, size_t len, struct sockaddr_storage *ss,
		char delim, const char **ipend)
{
	struct sockaddr_in *in4 = (void *)ss;
	struct sockaddr_in6 *in6 = (void *)ss;

	memset(ss, 0, sizeof(*ss));

	if (in4_pton(str, len, (u8 *)&in4->sin_addr.s_addr, delim, ipend)) {
		ss->ss_family = AF_INET;
		return 0;
	}

	if (in6_pton(str, len, (u8 *)&in6->sin6_addr.s6_addr, delim, ipend)) {
		ss->ss_family = AF_INET6;
		return 0;
	}

	return -EINVAL;
}

/*
 * Extract hostname string and resolve using kernel DNS facility.
 */
#ifdef CONFIG_CEPH_LIB_USE_DNS_RESOLVER
static int ceph_dns_resolve_name(const char *name, size_t namelen,
		struct sockaddr_storage *ss, char delim, const char **ipend)
{
	const char *end, *delim_p;
	char *colon_p, *ip_addr = NULL;
	int ip_len, ret;

	/*
	 * The end of the hostname occurs immediately preceding the delimiter or
	 * the port marker (':') where the delimiter takes precedence.
	 */
	delim_p = memchr(name, delim, namelen);
	colon_p = memchr(name, ':', namelen);

	if (delim_p && colon_p)
		end = delim_p < colon_p ? delim_p : colon_p;
	else if (!delim_p && colon_p)
		end = colon_p;
	else {
		end = delim_p;
		if (!end) /* case: hostname:/ */
			end = name + namelen;
	}

	if (end <= name)
		return -EINVAL;

	/* do dns_resolve upcall */
	ip_len = dns_query(NULL, name, end - name, NULL, &ip_addr, NULL);
	if (ip_len > 0)
		ret = ceph_pton(ip_addr, ip_len, ss, -1, NULL);
	else
		ret = -ESRCH;

	kfree(ip_addr);

	*ipend = end;

	pr_info("resolve '%.*s' (ret=%d): %s\n", (int)(end - name), name,
			ret, ret ? "failed" : ceph_pr_addr(ss));

	return ret;
}
#else
static inline int ceph_dns_resolve_name(const char *name, size_t namelen,
		struct sockaddr_storage *ss, char delim, const char **ipend)
{
	return -EINVAL;
}
#endif

/*
 * Parse a server name (IP or hostname). If a valid IP address is not found
 * then try to extract a hostname to resolve using userspace DNS upcall.
 */
static int ceph_parse_server_name(const char *name, size_t namelen,
			struct sockaddr_storage *ss, char delim, const char **ipend)
{
	int ret;

	ret = ceph_pton(name, namelen, ss, delim, ipend);
	if (ret)
		ret = ceph_dns_resolve_name(name, namelen, ss, delim, ipend);

	return ret;
}

S
Sage Weil 已提交
1205 1206 1207 1208 1209 1210 1211 1212
/*
 * Parse an ip[:port] list into an addr array.  Use the default
 * monitor port if a port isn't specified.
 */
int ceph_parse_ips(const char *c, const char *end,
		   struct ceph_entity_addr *addr,
		   int max_count, int *count)
{
N
Noah Watkins 已提交
1213
	int i, ret = -EINVAL;
S
Sage Weil 已提交
1214 1215 1216 1217 1218 1219 1220
	const char *p = c;

	dout("parse_ips on '%.*s'\n", (int)(end-c), c);
	for (i = 0; i < max_count; i++) {
		const char *ipend;
		struct sockaddr_storage *ss = &addr[i].in_addr;
		int port;
S
Sage Weil 已提交
1221 1222 1223 1224 1225 1226
		char delim = ',';

		if (*p == '[') {
			delim = ']';
			p++;
		}
S
Sage Weil 已提交
1227

N
Noah Watkins 已提交
1228 1229
		ret = ceph_parse_server_name(p, end - p, ss, delim, &ipend);
		if (ret)
S
Sage Weil 已提交
1230
			goto bad;
N
Noah Watkins 已提交
1231 1232
		ret = -EINVAL;

S
Sage Weil 已提交
1233 1234
		p = ipend;

S
Sage Weil 已提交
1235 1236 1237 1238 1239 1240 1241 1242
		if (delim == ']') {
			if (*p != ']') {
				dout("missing matching ']'\n");
				goto bad;
			}
			p++;
		}

S
Sage Weil 已提交
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
		/* port? */
		if (p < end && *p == ':') {
			port = 0;
			p++;
			while (p < end && *p >= '0' && *p <= '9') {
				port = (port * 10) + (*p - '0');
				p++;
			}
			if (port > 65535 || port == 0)
				goto bad;
		} else {
			port = CEPH_MON_PORT;
		}

		addr_set_port(ss, port);

1259
		dout("parse_ips got %s\n", ceph_pr_addr(ss));
S
Sage Weil 已提交
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275

		if (p == end)
			break;
		if (*p != ',')
			goto bad;
		p++;
	}

	if (p != end)
		goto bad;

	if (count)
		*count = i + 1;
	return 0;

bad:
S
Sage Weil 已提交
1276
	pr_err("parse_ips bad ip '%.*s'\n", (int)(end - c), c);
N
Noah Watkins 已提交
1277
	return ret;
S
Sage Weil 已提交
1278
}
1279
EXPORT_SYMBOL(ceph_parse_ips);
S
Sage Weil 已提交
1280

1281
static int process_banner(struct ceph_connection *con)
S
Sage Weil 已提交
1282
{
1283
	dout("process_banner on %p\n", con);
S
Sage Weil 已提交
1284 1285 1286 1287

	if (verify_hello(con) < 0)
		return -1;

1288 1289 1290
	ceph_decode_addr(&con->actual_peer_addr);
	ceph_decode_addr(&con->peer_addr_for_me);

S
Sage Weil 已提交
1291 1292 1293 1294 1295
	/*
	 * Make sure the other end is who we wanted.  note that the other
	 * end may not yet know their ip address, so if it's 0.0.0.0, give
	 * them the benefit of the doubt.
	 */
S
Sage Weil 已提交
1296 1297
	if (memcmp(&con->peer_addr, &con->actual_peer_addr,
		   sizeof(con->peer_addr)) != 0 &&
S
Sage Weil 已提交
1298 1299
	    !(addr_is_blank(&con->actual_peer_addr.in_addr) &&
	      con->actual_peer_addr.nonce == con->peer_addr.nonce)) {
Y
Yehuda Sadeh 已提交
1300
		pr_warning("wrong peer, want %s/%d, got %s/%d\n",
1301
			   ceph_pr_addr(&con->peer_addr.in_addr),
Y
Yehuda Sadeh 已提交
1302
			   (int)le32_to_cpu(con->peer_addr.nonce),
1303
			   ceph_pr_addr(&con->actual_peer_addr.in_addr),
Y
Yehuda Sadeh 已提交
1304
			   (int)le32_to_cpu(con->actual_peer_addr.nonce));
1305
		con->error_msg = "wrong peer at address";
S
Sage Weil 已提交
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
		return -1;
	}

	/*
	 * did we learn our address?
	 */
	if (addr_is_blank(&con->msgr->inst.addr.in_addr)) {
		int port = addr_port(&con->msgr->inst.addr.in_addr);

		memcpy(&con->msgr->inst.addr.in_addr,
		       &con->peer_addr_for_me.in_addr,
		       sizeof(con->peer_addr_for_me.in_addr));
		addr_set_port(&con->msgr->inst.addr.in_addr, port);
1319
		encode_my_addr(con->msgr);
1320
		dout("process_banner learned my addr is %s\n",
1321
		     ceph_pr_addr(&con->msgr->inst.addr.in_addr));
S
Sage Weil 已提交
1322 1323
	}

1324 1325 1326 1327 1328
	set_bit(NEGOTIATING, &con->state);
	prepare_read_connect(con);
	return 0;
}

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
static void fail_protocol(struct ceph_connection *con)
{
	reset_connection(con);
	set_bit(CLOSED, &con->state);  /* in case there's queued work */

	mutex_unlock(&con->mutex);
	if (con->ops->bad_proto)
		con->ops->bad_proto(con);
	mutex_lock(&con->mutex);
}

1340 1341
static int process_connect(struct ceph_connection *con)
{
1342 1343
	u64 sup_feat = con->msgr->supported_features;
	u64 req_feat = con->msgr->required_features;
1344
	u64 server_feat = le64_to_cpu(con->in_reply.features);
1345
	int ret;
1346

1347 1348
	dout("process_connect on %p tag %d\n", con, (int)con->in_tag);

S
Sage Weil 已提交
1349
	switch (con->in_reply.tag) {
1350 1351 1352 1353
	case CEPH_MSGR_TAG_FEATURES:
		pr_err("%s%lld %s feature set mismatch,"
		       " my %llx < server's %llx, missing %llx\n",
		       ENTITY_NAME(con->peer_name),
1354
		       ceph_pr_addr(&con->peer_addr.in_addr),
1355 1356 1357 1358 1359
		       sup_feat, server_feat, server_feat & ~sup_feat);
		con->error_msg = "missing required protocol features";
		fail_protocol(con);
		return -1;

S
Sage Weil 已提交
1360 1361 1362 1363
	case CEPH_MSGR_TAG_BADPROTOVER:
		pr_err("%s%lld %s protocol version mismatch,"
		       " my %d != server's %d\n",
		       ENTITY_NAME(con->peer_name),
1364
		       ceph_pr_addr(&con->peer_addr.in_addr),
S
Sage Weil 已提交
1365 1366 1367
		       le32_to_cpu(con->out_connect.protocol_version),
		       le32_to_cpu(con->in_reply.protocol_version));
		con->error_msg = "protocol version mismatch";
1368
		fail_protocol(con);
S
Sage Weil 已提交
1369 1370
		return -1;

1371 1372 1373 1374 1375 1376 1377 1378 1379
	case CEPH_MSGR_TAG_BADAUTHORIZER:
		con->auth_retry++;
		dout("process_connect %p got BADAUTHORIZER attempt %d\n", con,
		     con->auth_retry);
		if (con->auth_retry == 2) {
			con->error_msg = "connect authorization failure";
			return -1;
		}
		con->auth_retry = 1;
1380 1381 1382
		ret = prepare_write_connect(con->msgr, con, 0);
		if (ret < 0)
			return ret;
S
Sage Weil 已提交
1383
		prepare_read_connect(con);
1384
		break;
S
Sage Weil 已提交
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397

	case CEPH_MSGR_TAG_RESETSESSION:
		/*
		 * If we connected with a large connect_seq but the peer
		 * has no record of a session with us (no connection, or
		 * connect_seq == 0), they will send RESETSESION to indicate
		 * that they must have reset their session, and may have
		 * dropped messages.
		 */
		dout("process_connect got RESET peer seq %u\n",
		     le32_to_cpu(con->in_connect.connect_seq));
		pr_err("%s%lld %s connection reset\n",
		       ENTITY_NAME(con->peer_name),
1398
		       ceph_pr_addr(&con->peer_addr.in_addr));
S
Sage Weil 已提交
1399
		reset_connection(con);
1400
		prepare_write_connect(con->msgr, con, 0);
S
Sage Weil 已提交
1401 1402 1403
		prepare_read_connect(con);

		/* Tell ceph about it. */
1404
		mutex_unlock(&con->mutex);
S
Sage Weil 已提交
1405 1406 1407
		pr_info("reset on %s%lld\n", ENTITY_NAME(con->peer_name));
		if (con->ops->peer_reset)
			con->ops->peer_reset(con);
1408
		mutex_lock(&con->mutex);
1409 1410 1411
		if (test_bit(CLOSED, &con->state) ||
		    test_bit(OPENING, &con->state))
			return -EAGAIN;
S
Sage Weil 已提交
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
		break;

	case CEPH_MSGR_TAG_RETRY_SESSION:
		/*
		 * If we sent a smaller connect_seq than the peer has, try
		 * again with a larger value.
		 */
		dout("process_connect got RETRY my seq = %u, peer_seq = %u\n",
		     le32_to_cpu(con->out_connect.connect_seq),
		     le32_to_cpu(con->in_connect.connect_seq));
		con->connect_seq = le32_to_cpu(con->in_connect.connect_seq);
1423
		prepare_write_connect(con->msgr, con, 0);
S
Sage Weil 已提交
1424 1425 1426 1427 1428 1429 1430 1431
		prepare_read_connect(con);
		break;

	case CEPH_MSGR_TAG_RETRY_GLOBAL:
		/*
		 * If we sent a smaller global_seq than the peer has, try
		 * again with a larger value.
		 */
1432
		dout("process_connect got RETRY_GLOBAL my %u peer_gseq %u\n",
S
Sage Weil 已提交
1433 1434 1435 1436
		     con->peer_global_seq,
		     le32_to_cpu(con->in_connect.global_seq));
		get_global_seq(con->msgr,
			       le32_to_cpu(con->in_connect.global_seq));
1437
		prepare_write_connect(con->msgr, con, 0);
S
Sage Weil 已提交
1438 1439 1440 1441
		prepare_read_connect(con);
		break;

	case CEPH_MSGR_TAG_READY:
1442 1443 1444 1445
		if (req_feat & ~server_feat) {
			pr_err("%s%lld %s protocol feature mismatch,"
			       " my required %llx > server's %llx, need %llx\n",
			       ENTITY_NAME(con->peer_name),
1446
			       ceph_pr_addr(&con->peer_addr.in_addr),
1447 1448 1449 1450 1451
			       req_feat, server_feat, req_feat & ~server_feat);
			con->error_msg = "missing required protocol features";
			fail_protocol(con);
			return -1;
		}
S
Sage Weil 已提交
1452 1453 1454
		clear_bit(CONNECTING, &con->state);
		con->peer_global_seq = le32_to_cpu(con->in_reply.global_seq);
		con->connect_seq++;
1455
		con->peer_features = server_feat;
S
Sage Weil 已提交
1456 1457 1458 1459 1460 1461
		dout("process_connect got READY gseq %d cseq %d (%d)\n",
		     con->peer_global_seq,
		     le32_to_cpu(con->in_reply.connect_seq),
		     con->connect_seq);
		WARN_ON(con->connect_seq !=
			le32_to_cpu(con->in_reply.connect_seq));
S
Sage Weil 已提交
1462 1463 1464 1465

		if (con->in_reply.flags & CEPH_MSG_CONNECT_LOSSY)
			set_bit(LOSSYTX, &con->state);

S
Sage Weil 已提交
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
		prepare_read_tag(con);
		break;

	case CEPH_MSGR_TAG_WAIT:
		/*
		 * If there is a connection race (we are opening
		 * connections to each other), one of us may just have
		 * to WAIT.  This shouldn't happen if we are the
		 * client.
		 */
S
Sage Weil 已提交
1476 1477 1478
		pr_err("process_connect got WAIT as client\n");
		con->error_msg = "protocol error, got WAIT as client";
		return -1;
S
Sage Weil 已提交
1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517

	default:
		pr_err("connect protocol error, will retry\n");
		con->error_msg = "protocol error, garbage tag during connect";
		return -1;
	}
	return 0;
}


/*
 * read (part of) an ack
 */
static int read_partial_ack(struct ceph_connection *con)
{
	int to = 0;

	return read_partial(con, &to, sizeof(con->in_temp_ack),
			    &con->in_temp_ack);
}


/*
 * We can finally discard anything that's been acked.
 */
static void process_ack(struct ceph_connection *con)
{
	struct ceph_msg *m;
	u64 ack = le64_to_cpu(con->in_temp_ack);
	u64 seq;

	while (!list_empty(&con->out_sent)) {
		m = list_first_entry(&con->out_sent, struct ceph_msg,
				     list_head);
		seq = le64_to_cpu(m->hdr.seq);
		if (seq > ack)
			break;
		dout("got ack for seq %llu type %d at %p\n", seq,
		     le16_to_cpu(m->hdr.type), m);
1518
		m->ack_stamp = jiffies;
S
Sage Weil 已提交
1519 1520 1521 1522 1523 1524 1525 1526
		ceph_msg_remove(m);
	}
	prepare_read_tag(con);
}




1527
static int read_partial_message_section(struct ceph_connection *con,
S
Sage Weil 已提交
1528 1529
					struct kvec *section,
					unsigned int sec_len, u32 *crc)
1530
{
1531
	int ret, left;
1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546

	BUG_ON(!section);

	while (section->iov_len < sec_len) {
		BUG_ON(section->iov_base == NULL);
		left = sec_len - section->iov_len;
		ret = ceph_tcp_recvmsg(con->sock, (char *)section->iov_base +
				       section->iov_len, left);
		if (ret <= 0)
			return ret;
		section->iov_len += ret;
		if (section->iov_len == sec_len)
			*crc = crc32c(0, section->iov_base,
				      section->iov_len);
	}
S
Sage Weil 已提交
1547

1548 1549
	return 1;
}
S
Sage Weil 已提交
1550

1551 1552 1553
static struct ceph_msg *ceph_alloc_msg(struct ceph_connection *con,
				struct ceph_msg_header *hdr,
				int *skip);
1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624


static int read_partial_message_pages(struct ceph_connection *con,
				      struct page **pages,
				      unsigned data_len, int datacrc)
{
	void *p;
	int ret;
	int left;

	left = min((int)(data_len - con->in_msg_pos.data_pos),
		   (int)(PAGE_SIZE - con->in_msg_pos.page_pos));
	/* (page) data */
	BUG_ON(pages == NULL);
	p = kmap(pages[con->in_msg_pos.page]);
	ret = ceph_tcp_recvmsg(con->sock, p + con->in_msg_pos.page_pos,
			       left);
	if (ret > 0 && datacrc)
		con->in_data_crc =
			crc32c(con->in_data_crc,
				  p + con->in_msg_pos.page_pos, ret);
	kunmap(pages[con->in_msg_pos.page]);
	if (ret <= 0)
		return ret;
	con->in_msg_pos.data_pos += ret;
	con->in_msg_pos.page_pos += ret;
	if (con->in_msg_pos.page_pos == PAGE_SIZE) {
		con->in_msg_pos.page_pos = 0;
		con->in_msg_pos.page++;
	}

	return ret;
}

#ifdef CONFIG_BLOCK
static int read_partial_message_bio(struct ceph_connection *con,
				    struct bio **bio_iter, int *bio_seg,
				    unsigned data_len, int datacrc)
{
	struct bio_vec *bv = bio_iovec_idx(*bio_iter, *bio_seg);
	void *p;
	int ret, left;

	if (IS_ERR(bv))
		return PTR_ERR(bv);

	left = min((int)(data_len - con->in_msg_pos.data_pos),
		   (int)(bv->bv_len - con->in_msg_pos.page_pos));

	p = kmap(bv->bv_page) + bv->bv_offset;

	ret = ceph_tcp_recvmsg(con->sock, p + con->in_msg_pos.page_pos,
			       left);
	if (ret > 0 && datacrc)
		con->in_data_crc =
			crc32c(con->in_data_crc,
				  p + con->in_msg_pos.page_pos, ret);
	kunmap(bv->bv_page);
	if (ret <= 0)
		return ret;
	con->in_msg_pos.data_pos += ret;
	con->in_msg_pos.page_pos += ret;
	if (con->in_msg_pos.page_pos == bv->bv_len) {
		con->in_msg_pos.page_pos = 0;
		iter_bio_next(bio_iter, bio_seg);
	}

	return ret;
}
#endif

S
Sage Weil 已提交
1625 1626 1627 1628 1629 1630 1631
/*
 * read (part of) a message.
 */
static int read_partial_message(struct ceph_connection *con)
{
	struct ceph_msg *m = con->in_msg;
	int ret;
1632
	int to, left;
1633
	unsigned front_len, middle_len, data_len;
S
Sage Weil 已提交
1634
	int datacrc = con->msgr->nocrc;
1635
	int skip;
1636
	u64 seq;
S
Sage Weil 已提交
1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669

	dout("read_partial_message con %p msg %p\n", con, m);

	/* header */
	while (con->in_base_pos < sizeof(con->in_hdr)) {
		left = sizeof(con->in_hdr) - con->in_base_pos;
		ret = ceph_tcp_recvmsg(con->sock,
				       (char *)&con->in_hdr + con->in_base_pos,
				       left);
		if (ret <= 0)
			return ret;
		con->in_base_pos += ret;
		if (con->in_base_pos == sizeof(con->in_hdr)) {
			u32 crc = crc32c(0, (void *)&con->in_hdr,
				 sizeof(con->in_hdr) - sizeof(con->in_hdr.crc));
			if (crc != le32_to_cpu(con->in_hdr.crc)) {
				pr_err("read_partial_message bad hdr "
				       " crc %u != expected %u\n",
				       crc, con->in_hdr.crc);
				return -EBADMSG;
			}
		}
	}
	front_len = le32_to_cpu(con->in_hdr.front_len);
	if (front_len > CEPH_MSG_MAX_FRONT_LEN)
		return -EIO;
	middle_len = le32_to_cpu(con->in_hdr.middle_len);
	if (middle_len > CEPH_MSG_MAX_DATA_LEN)
		return -EIO;
	data_len = le32_to_cpu(con->in_hdr.data_len);
	if (data_len > CEPH_MSG_MAX_DATA_LEN)
		return -EIO;

1670 1671 1672
	/* verify seq# */
	seq = le64_to_cpu(con->in_hdr.seq);
	if ((s64)seq - (s64)con->in_seq < 1) {
S
Sage Weil 已提交
1673
		pr_info("skipping %s%lld %s seq %lld expected %lld\n",
1674
			ENTITY_NAME(con->peer_name),
1675
			ceph_pr_addr(&con->peer_addr.in_addr),
1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
			seq, con->in_seq + 1);
		con->in_base_pos = -front_len - middle_len - data_len -
			sizeof(m->footer);
		con->in_tag = CEPH_MSGR_TAG_READY;
		return 0;
	} else if ((s64)seq - (s64)con->in_seq > 1) {
		pr_err("read_partial_message bad seq %lld expected %lld\n",
		       seq, con->in_seq + 1);
		con->error_msg = "bad message sequence # for incoming message";
		return -EBADMSG;
	}

S
Sage Weil 已提交
1688 1689 1690 1691
	/* allocate message? */
	if (!con->in_msg) {
		dout("got hdr type %d front %d data %d\n", con->in_hdr.type,
		     con->in_hdr.front_len, con->in_hdr.data_len);
1692
		skip = 0;
1693 1694
		con->in_msg = ceph_alloc_msg(con, &con->in_hdr, &skip);
		if (skip) {
S
Sage Weil 已提交
1695
			/* skip this message */
1696
			dout("alloc_msg said skip message\n");
1697
			BUG_ON(con->in_msg);
S
Sage Weil 已提交
1698 1699 1700
			con->in_base_pos = -front_len - middle_len - data_len -
				sizeof(m->footer);
			con->in_tag = CEPH_MSGR_TAG_READY;
1701
			con->in_seq++;
S
Sage Weil 已提交
1702 1703
			return 0;
		}
1704
		if (!con->in_msg) {
1705 1706
			con->error_msg =
				"error allocating memory for incoming message";
1707
			return -ENOMEM;
S
Sage Weil 已提交
1708 1709 1710
		}
		m = con->in_msg;
		m->front.iov_len = 0;    /* haven't read it yet */
1711 1712
		if (m->middle)
			m->middle->vec.iov_len = 0;
1713 1714

		con->in_msg_pos.page = 0;
1715
		if (m->pages)
1716
			con->in_msg_pos.page_pos = m->page_alignment;
1717 1718
		else
			con->in_msg_pos.page_pos = 0;
1719
		con->in_msg_pos.data_pos = 0;
S
Sage Weil 已提交
1720 1721 1722
	}

	/* front */
1723 1724 1725 1726
	ret = read_partial_message_section(con, &m->front, front_len,
					   &con->in_front_crc);
	if (ret <= 0)
		return ret;
S
Sage Weil 已提交
1727 1728

	/* middle */
1729
	if (m->middle) {
S
Sage Weil 已提交
1730 1731
		ret = read_partial_message_section(con, &m->middle->vec,
						   middle_len,
1732
						   &con->in_middle_crc);
S
Sage Weil 已提交
1733 1734 1735
		if (ret <= 0)
			return ret;
	}
1736 1737 1738 1739
#ifdef CONFIG_BLOCK
	if (m->bio && !m->bio_iter)
		init_bio_iter(m->bio, &m->bio_iter, &m->bio_seg);
#endif
S
Sage Weil 已提交
1740 1741 1742

	/* (page) data */
	while (con->in_msg_pos.data_pos < data_len) {
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758
		if (m->pages) {
			ret = read_partial_message_pages(con, m->pages,
						 data_len, datacrc);
			if (ret <= 0)
				return ret;
#ifdef CONFIG_BLOCK
		} else if (m->bio) {

			ret = read_partial_message_bio(con,
						 &m->bio_iter, &m->bio_seg,
						 data_len, datacrc);
			if (ret <= 0)
				return ret;
#endif
		} else {
			BUG_ON(1);
S
Sage Weil 已提交
1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
		}
	}

	/* footer */
	to = sizeof(m->hdr) + sizeof(m->footer);
	while (con->in_base_pos < to) {
		left = to - con->in_base_pos;
		ret = ceph_tcp_recvmsg(con->sock, (char *)&m->footer +
				       (con->in_base_pos - sizeof(m->hdr)),
				       left);
		if (ret <= 0)
			return ret;
		con->in_base_pos += ret;
	}
	dout("read_partial_message got msg %p %d (%u) + %d (%u) + %d (%u)\n",
	     m, front_len, m->footer.front_crc, middle_len,
	     m->footer.middle_crc, data_len, m->footer.data_crc);

	/* crc ok? */
	if (con->in_front_crc != le32_to_cpu(m->footer.front_crc)) {
		pr_err("read_partial_message %p front crc %u != exp. %u\n",
		       m, con->in_front_crc, m->footer.front_crc);
		return -EBADMSG;
	}
	if (con->in_middle_crc != le32_to_cpu(m->footer.middle_crc)) {
		pr_err("read_partial_message %p middle crc %u != exp %u\n",
		       m, con->in_middle_crc, m->footer.middle_crc);
		return -EBADMSG;
	}
	if (datacrc &&
	    (m->footer.flags & CEPH_MSG_FOOTER_NOCRC) == 0 &&
	    con->in_data_crc != le32_to_cpu(m->footer.data_crc)) {
		pr_err("read_partial_message %p data crc %u != exp. %u\n", m,
		       con->in_data_crc, le32_to_cpu(m->footer.data_crc));
		return -EBADMSG;
	}

	return 1; /* done! */
}

/*
 * Process message.  This happens in the worker thread.  The callback should
 * be careful not to do anything that waits on other incoming messages or it
 * may deadlock.
 */
static void process_message(struct ceph_connection *con)
{
S
Sage Weil 已提交
1806
	struct ceph_msg *msg;
S
Sage Weil 已提交
1807

S
Sage Weil 已提交
1808
	msg = con->in_msg;
S
Sage Weil 已提交
1809 1810 1811 1812
	con->in_msg = NULL;

	/* if first message, set peer_name */
	if (con->peer_name.type == 0)
1813
		con->peer_name = msg->hdr.src;
S
Sage Weil 已提交
1814 1815

	con->in_seq++;
1816
	mutex_unlock(&con->mutex);
S
Sage Weil 已提交
1817 1818 1819

	dout("===== %p %llu from %s%lld %d=%s len %d+%d (%u %u %u) =====\n",
	     msg, le64_to_cpu(msg->hdr.seq),
1820
	     ENTITY_NAME(msg->hdr.src),
S
Sage Weil 已提交
1821 1822 1823 1824 1825 1826
	     le16_to_cpu(msg->hdr.type),
	     ceph_msg_type_name(le16_to_cpu(msg->hdr.type)),
	     le32_to_cpu(msg->hdr.front_len),
	     le32_to_cpu(msg->hdr.data_len),
	     con->in_front_crc, con->in_middle_crc, con->in_data_crc);
	con->ops->dispatch(con, msg);
1827 1828

	mutex_lock(&con->mutex);
S
Sage Weil 已提交
1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849
	prepare_read_tag(con);
}


/*
 * Write something to the socket.  Called in a worker thread when the
 * socket appears to be writeable and we have something ready to send.
 */
static int try_write(struct ceph_connection *con)
{
	struct ceph_messenger *msgr = con->msgr;
	int ret = 1;

	dout("try_write start %p state %lu nref %d\n", con, con->state,
	     atomic_read(&con->nref));

more:
	dout("try_write out_kvec_bytes %d\n", con->out_kvec_bytes);

	/* open the socket first? */
	if (con->sock == NULL) {
1850 1851 1852
		prepare_write_banner(msgr, con);
		prepare_write_connect(msgr, con, 1);
		prepare_read_banner(con);
S
Sage Weil 已提交
1853
		set_bit(CONNECTING, &con->state);
1854
		clear_bit(NEGOTIATING, &con->state);
S
Sage Weil 已提交
1855

1856
		BUG_ON(con->in_msg);
S
Sage Weil 已提交
1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
		con->in_tag = CEPH_MSGR_TAG_READY;
		dout("try_write initiating connect on %p new state %lu\n",
		     con, con->state);
		con->sock = ceph_tcp_connect(con);
		if (IS_ERR(con->sock)) {
			con->sock = NULL;
			con->error_msg = "connect error";
			ret = -1;
			goto out;
		}
	}

more_kvec:
	/* kvec data queued? */
	if (con->out_skip) {
		ret = write_partial_skip(con);
		if (ret <= 0)
1874
			goto out;
S
Sage Weil 已提交
1875 1876 1877 1878
	}
	if (con->out_kvec_left) {
		ret = write_partial_kvec(con);
		if (ret <= 0)
1879
			goto out;
S
Sage Weil 已提交
1880 1881 1882 1883
	}

	/* msg pages? */
	if (con->out_msg) {
1884 1885 1886 1887 1888 1889
		if (con->out_msg_done) {
			ceph_msg_put(con->out_msg);
			con->out_msg = NULL;   /* we're done with this one */
			goto do_next;
		}

S
Sage Weil 已提交
1890 1891 1892 1893
		ret = write_partial_msg_pages(con);
		if (ret == 1)
			goto more_kvec;  /* we need to send the footer, too! */
		if (ret == 0)
1894
			goto out;
S
Sage Weil 已提交
1895 1896 1897
		if (ret < 0) {
			dout("try_write write_partial_msg_pages err %d\n",
			     ret);
1898
			goto out;
S
Sage Weil 已提交
1899 1900 1901
		}
	}

1902
do_next:
S
Sage Weil 已提交
1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
	if (!test_bit(CONNECTING, &con->state)) {
		/* is anything else pending? */
		if (!list_empty(&con->out_queue)) {
			prepare_write_message(con);
			goto more;
		}
		if (con->in_seq > con->in_seq_acked) {
			prepare_write_ack(con);
			goto more;
		}
		if (test_and_clear_bit(KEEPALIVE_PENDING, &con->state)) {
			prepare_write_keepalive(con);
			goto more;
		}
	}

	/* Nothing to do! */
	clear_bit(WRITE_PENDING, &con->state);
	dout("try_write nothing else to write.\n");
	ret = 0;
out:
1924
	dout("try_write done on %p ret %d\n", con, ret);
S
Sage Weil 已提交
1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943
	return ret;
}



/*
 * Read what we can from the socket.
 */
static int try_read(struct ceph_connection *con)
{
	int ret = -1;

	if (!con->sock)
		return 0;

	if (test_bit(STANDBY, &con->state))
		return 0;

	dout("try_read start on %p\n", con);
1944

S
Sage Weil 已提交
1945 1946 1947
more:
	dout("try_read tag %d in_base_pos %d\n", (int)con->in_tag,
	     con->in_base_pos);
1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958

	/*
	 * process_connect and process_message drop and re-take
	 * con->mutex.  make sure we handle a racing close or reopen.
	 */
	if (test_bit(CLOSED, &con->state) ||
	    test_bit(OPENING, &con->state)) {
		ret = -EAGAIN;
		goto out;
	}

S
Sage Weil 已提交
1959
	if (test_bit(CONNECTING, &con->state)) {
1960 1961 1962 1963 1964
		if (!test_bit(NEGOTIATING, &con->state)) {
			dout("try_read connecting\n");
			ret = read_partial_banner(con);
			if (ret <= 0)
				goto out;
1965 1966 1967
			ret = process_banner(con);
			if (ret < 0)
				goto out;
1968
		}
S
Sage Weil 已提交
1969 1970 1971
		ret = read_partial_connect(con);
		if (ret <= 0)
			goto out;
1972 1973 1974
		ret = process_connect(con);
		if (ret < 0)
			goto out;
S
Sage Weil 已提交
1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
		goto more;
	}

	if (con->in_base_pos < 0) {
		/*
		 * skipping + discarding content.
		 *
		 * FIXME: there must be a better way to do this!
		 */
		static char buf[1024];
		int skip = min(1024, -con->in_base_pos);
		dout("skipping %d / %d bytes\n", skip, -con->in_base_pos);
		ret = ceph_tcp_recvmsg(con->sock, buf, skip);
		if (ret <= 0)
1989
			goto out;
S
Sage Weil 已提交
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
		con->in_base_pos += ret;
		if (con->in_base_pos)
			goto more;
	}
	if (con->in_tag == CEPH_MSGR_TAG_READY) {
		/*
		 * what's next?
		 */
		ret = ceph_tcp_recvmsg(con->sock, &con->in_tag, 1);
		if (ret <= 0)
2000
			goto out;
S
Sage Weil 已提交
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
		dout("try_read got tag %d\n", (int)con->in_tag);
		switch (con->in_tag) {
		case CEPH_MSGR_TAG_MSG:
			prepare_read_message(con);
			break;
		case CEPH_MSGR_TAG_ACK:
			prepare_read_ack(con);
			break;
		case CEPH_MSGR_TAG_CLOSE:
			set_bit(CLOSED, &con->state);   /* fixme */
2011
			goto out;
S
Sage Weil 已提交
2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022
		default:
			goto bad_tag;
		}
	}
	if (con->in_tag == CEPH_MSGR_TAG_MSG) {
		ret = read_partial_message(con);
		if (ret <= 0) {
			switch (ret) {
			case -EBADMSG:
				con->error_msg = "bad crc";
				ret = -EIO;
2023
				break;
S
Sage Weil 已提交
2024 2025
			case -EIO:
				con->error_msg = "io error";
2026
				break;
S
Sage Weil 已提交
2027
			}
2028
			goto out;
S
Sage Weil 已提交
2029 2030 2031 2032 2033 2034 2035 2036 2037
		}
		if (con->in_tag == CEPH_MSGR_TAG_READY)
			goto more;
		process_message(con);
		goto more;
	}
	if (con->in_tag == CEPH_MSGR_TAG_ACK) {
		ret = read_partial_ack(con);
		if (ret <= 0)
2038
			goto out;
S
Sage Weil 已提交
2039 2040 2041 2042 2043
		process_ack(con);
		goto more;
	}

out:
2044
	dout("try_read done on %p ret %d\n", con, ret);
S
Sage Weil 已提交
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071
	return ret;

bad_tag:
	pr_err("try_read bad con->in_tag = %d\n", (int)con->in_tag);
	con->error_msg = "protocol error, garbage tag";
	ret = -1;
	goto out;
}


/*
 * Atomically queue work on a connection.  Bump @con reference to
 * avoid races with connection teardown.
 */
static void queue_con(struct ceph_connection *con)
{
	if (test_bit(DEAD, &con->state)) {
		dout("queue_con %p ignoring: DEAD\n",
		     con);
		return;
	}

	if (!con->ops->get(con)) {
		dout("queue_con %p ref count 0\n", con);
		return;
	}

2072
	if (!queue_delayed_work(ceph_msgr_wq, &con->work, 0)) {
S
Sage Weil 已提交
2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
		dout("queue_con %p - already queued\n", con);
		con->ops->put(con);
	} else {
		dout("queue_con %p\n", con);
	}
}

/*
 * Do some work on a connection.  Drop a connection ref when we're done.
 */
static void con_work(struct work_struct *work)
{
	struct ceph_connection *con = container_of(work, struct ceph_connection,
						   work.work);
2087
	int ret;
S
Sage Weil 已提交
2088

S
Sage Weil 已提交
2089
	mutex_lock(&con->mutex);
2090
restart:
S
Sage Weil 已提交
2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
	if (test_and_clear_bit(BACKOFF, &con->state)) {
		dout("con_work %p backing off\n", con);
		if (queue_delayed_work(ceph_msgr_wq, &con->work,
				       round_jiffies_relative(con->delay))) {
			dout("con_work %p backoff %lu\n", con, con->delay);
			mutex_unlock(&con->mutex);
			return;
		} else {
			con->ops->put(con);
			dout("con_work %p FAILED to back off %lu\n", con,
			     con->delay);
		}
	}
S
Sage Weil 已提交
2104

S
Sage Weil 已提交
2105 2106 2107 2108
	if (test_bit(STANDBY, &con->state)) {
		dout("con_work %p STANDBY\n", con);
		goto done;
	}
S
Sage Weil 已提交
2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119
	if (test_bit(CLOSED, &con->state)) { /* e.g. if we are replaced */
		dout("con_work CLOSED\n");
		con_close_socket(con);
		goto done;
	}
	if (test_and_clear_bit(OPENING, &con->state)) {
		/* reopen w/ new peer */
		dout("con_work OPENING\n");
		con_close_socket(con);
	}

2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133
	if (test_and_clear_bit(SOCK_CLOSED, &con->state))
		goto fault;

	ret = try_read(con);
	if (ret == -EAGAIN)
		goto restart;
	if (ret < 0)
		goto fault;

	ret = try_write(con);
	if (ret == -EAGAIN)
		goto restart;
	if (ret < 0)
		goto fault;
S
Sage Weil 已提交
2134 2135

done:
S
Sage Weil 已提交
2136 2137
	mutex_unlock(&con->mutex);
done_unlocked:
S
Sage Weil 已提交
2138
	con->ops->put(con);
2139 2140 2141 2142 2143 2144
	return;

fault:
	mutex_unlock(&con->mutex);
	ceph_fault(con);     /* error/fault path */
	goto done_unlocked;
S
Sage Weil 已提交
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
}


/*
 * Generic error/fault handler.  A retry mechanism is used with
 * exponential backoff
 */
static void ceph_fault(struct ceph_connection *con)
{
	pr_err("%s%lld %s %s\n", ENTITY_NAME(con->peer_name),
2155
	       ceph_pr_addr(&con->peer_addr.in_addr), con->error_msg);
S
Sage Weil 已提交
2156
	dout("fault %p state %lu to peer %s\n",
2157
	     con, con->state, ceph_pr_addr(&con->peer_addr.in_addr));
S
Sage Weil 已提交
2158 2159 2160 2161 2162 2163

	if (test_bit(LOSSYTX, &con->state)) {
		dout("fault on LOSSYTX channel\n");
		goto out;
	}

2164
	mutex_lock(&con->mutex);
2165 2166
	if (test_bit(CLOSED, &con->state))
		goto out_unlock;
2167

S
Sage Weil 已提交
2168
	con_close_socket(con);
S
Sage Weil 已提交
2169 2170 2171 2172 2173

	if (con->in_msg) {
		ceph_msg_put(con->in_msg);
		con->in_msg = NULL;
	}
S
Sage Weil 已提交
2174

2175 2176
	/* Requeue anything that hasn't been acked */
	list_splice_init(&con->out_sent, &con->out_queue);
2177

S
Sage Weil 已提交
2178 2179 2180 2181
	/* If there are no messages queued or keepalive pending, place
	 * the connection in a STANDBY state */
	if (list_empty(&con->out_queue) &&
	    !test_bit(KEEPALIVE_PENDING, &con->state)) {
S
Sage Weil 已提交
2182 2183
		dout("fault %p setting STANDBY clearing WRITE_PENDING\n", con);
		clear_bit(WRITE_PENDING, &con->state);
S
Sage Weil 已提交
2184
		set_bit(STANDBY, &con->state);
2185 2186 2187 2188 2189 2190 2191 2192
	} else {
		/* retry after a delay. */
		if (con->delay == 0)
			con->delay = BASE_DELAY_INTERVAL;
		else if (con->delay < MAX_DELAY_INTERVAL)
			con->delay *= 2;
		con->ops->get(con);
		if (queue_delayed_work(ceph_msgr_wq, &con->work,
S
Sage Weil 已提交
2193 2194 2195
				       round_jiffies_relative(con->delay))) {
			dout("fault queued %p delay %lu\n", con, con->delay);
		} else {
2196
			con->ops->put(con);
S
Sage Weil 已提交
2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
			dout("fault failed to queue %p delay %lu, backoff\n",
			     con, con->delay);
			/*
			 * In many cases we see a socket state change
			 * while con_work is running and end up
			 * queuing (non-delayed) work, such that we
			 * can't backoff with a delay.  Set a flag so
			 * that when con_work restarts we schedule the
			 * delay then.
			 */
			set_bit(BACKOFF, &con->state);
		}
S
Sage Weil 已提交
2209 2210
	}

2211 2212
out_unlock:
	mutex_unlock(&con->mutex);
S
Sage Weil 已提交
2213
out:
2214 2215 2216
	/*
	 * in case we faulted due to authentication, invalidate our
	 * current tickets so that we can get new ones.
S
Sage Weil 已提交
2217
	 */
2218 2219 2220 2221 2222
	if (con->auth_retry && con->ops->invalidate_authorizer) {
		dout("calling invalidate_authorizer()\n");
		con->ops->invalidate_authorizer(con);
	}

S
Sage Weil 已提交
2223 2224 2225 2226 2227 2228 2229 2230 2231
	if (con->ops->fault)
		con->ops->fault(con);
}



/*
 * create a new messenger instance
 */
2232 2233 2234
struct ceph_messenger *ceph_messenger_create(struct ceph_entity_addr *myaddr,
					     u32 supported_features,
					     u32 required_features)
S
Sage Weil 已提交
2235 2236 2237 2238 2239 2240 2241
{
	struct ceph_messenger *msgr;

	msgr = kzalloc(sizeof(*msgr), GFP_KERNEL);
	if (msgr == NULL)
		return ERR_PTR(-ENOMEM);

2242 2243 2244
	msgr->supported_features = supported_features;
	msgr->required_features = required_features;

S
Sage Weil 已提交
2245 2246 2247 2248 2249 2250
	spin_lock_init(&msgr->global_seq_lock);

	if (myaddr)
		msgr->inst.addr = *myaddr;

	/* select a random nonce */
2251
	msgr->inst.addr.type = 0;
S
Sage Weil 已提交
2252
	get_random_bytes(&msgr->inst.addr.nonce, sizeof(msgr->inst.addr.nonce));
2253
	encode_my_addr(msgr);
S
Sage Weil 已提交
2254 2255 2256 2257

	dout("messenger_create %p\n", msgr);
	return msgr;
}
2258
EXPORT_SYMBOL(ceph_messenger_create);
S
Sage Weil 已提交
2259 2260 2261 2262 2263 2264 2265

void ceph_messenger_destroy(struct ceph_messenger *msgr)
{
	dout("destroy %p\n", msgr);
	kfree(msgr);
	dout("destroyed messenger %p\n", msgr);
}
2266
EXPORT_SYMBOL(ceph_messenger_destroy);
S
Sage Weil 已提交
2267

S
Sage Weil 已提交
2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
static void clear_standby(struct ceph_connection *con)
{
	/* come back from STANDBY? */
	if (test_and_clear_bit(STANDBY, &con->state)) {
		mutex_lock(&con->mutex);
		dout("clear_standby %p and ++connect_seq\n", con);
		con->connect_seq++;
		WARN_ON(test_bit(WRITE_PENDING, &con->state));
		WARN_ON(test_bit(KEEPALIVE_PENDING, &con->state));
		mutex_unlock(&con->mutex);
	}
}

S
Sage Weil 已提交
2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292
/*
 * Queue up an outgoing message on the given connection.
 */
void ceph_con_send(struct ceph_connection *con, struct ceph_msg *msg)
{
	if (test_bit(CLOSED, &con->state)) {
		dout("con_send %p closed, dropping %p\n", con, msg);
		ceph_msg_put(msg);
		return;
	}

	/* set src+dst */
2293
	msg->hdr.src = con->msgr->inst.name;
S
Sage Weil 已提交
2294

2295 2296
	BUG_ON(msg->front.iov_len != le32_to_cpu(msg->hdr.front_len));

2297 2298
	msg->needs_out_seq = true;

S
Sage Weil 已提交
2299
	/* queue */
2300
	mutex_lock(&con->mutex);
S
Sage Weil 已提交
2301 2302 2303 2304 2305 2306 2307 2308
	BUG_ON(!list_empty(&msg->list_head));
	list_add_tail(&msg->list_head, &con->out_queue);
	dout("----- %p to %s%lld %d=%s len %d+%d+%d -----\n", msg,
	     ENTITY_NAME(con->peer_name), le16_to_cpu(msg->hdr.type),
	     ceph_msg_type_name(le16_to_cpu(msg->hdr.type)),
	     le32_to_cpu(msg->hdr.front_len),
	     le32_to_cpu(msg->hdr.middle_len),
	     le32_to_cpu(msg->hdr.data_len));
2309
	mutex_unlock(&con->mutex);
S
Sage Weil 已提交
2310 2311 2312

	/* if there wasn't anything waiting to send before, queue
	 * new work */
S
Sage Weil 已提交
2313
	clear_standby(con);
S
Sage Weil 已提交
2314 2315 2316
	if (test_and_set_bit(WRITE_PENDING, &con->state) == 0)
		queue_con(con);
}
2317
EXPORT_SYMBOL(ceph_con_send);
S
Sage Weil 已提交
2318 2319 2320 2321 2322 2323

/*
 * Revoke a message that was previously queued for send
 */
void ceph_con_revoke(struct ceph_connection *con, struct ceph_msg *msg)
{
2324
	mutex_lock(&con->mutex);
S
Sage Weil 已提交
2325
	if (!list_empty(&msg->list_head)) {
S
Sage Weil 已提交
2326
		dout("con_revoke %p msg %p - was on queue\n", con, msg);
S
Sage Weil 已提交
2327 2328 2329
		list_del_init(&msg->list_head);
		ceph_msg_put(msg);
		msg->hdr.seq = 0;
S
Sage Weil 已提交
2330 2331 2332 2333
	}
	if (con->out_msg == msg) {
		dout("con_revoke %p msg %p - was sending\n", con, msg);
		con->out_msg = NULL;
S
Sage Weil 已提交
2334 2335 2336 2337
		if (con->out_kvec_is_msg) {
			con->out_skip = con->out_kvec_bytes;
			con->out_kvec_is_msg = false;
		}
S
Sage Weil 已提交
2338 2339
		ceph_msg_put(msg);
		msg->hdr.seq = 0;
S
Sage Weil 已提交
2340
	}
2341
	mutex_unlock(&con->mutex);
S
Sage Weil 已提交
2342 2343
}

2344
/*
2345
 * Revoke a message that we may be reading data into
2346
 */
2347
void ceph_con_revoke_message(struct ceph_connection *con, struct ceph_msg *msg)
2348 2349
{
	mutex_lock(&con->mutex);
2350 2351 2352
	if (con->in_msg && con->in_msg == msg) {
		unsigned front_len = le32_to_cpu(con->in_hdr.front_len);
		unsigned middle_len = le32_to_cpu(con->in_hdr.middle_len);
2353 2354 2355
		unsigned data_len = le32_to_cpu(con->in_hdr.data_len);

		/* skip rest of message */
2356
		dout("con_revoke_pages %p msg %p revoked\n", con, msg);
2357 2358
			con->in_base_pos = con->in_base_pos -
				sizeof(struct ceph_msg_header) -
2359 2360 2361
				front_len -
				middle_len -
				data_len -
2362 2363 2364 2365
				sizeof(struct ceph_msg_footer);
		ceph_msg_put(con->in_msg);
		con->in_msg = NULL;
		con->in_tag = CEPH_MSGR_TAG_READY;
2366
		con->in_seq++;
2367 2368
	} else {
		dout("con_revoke_pages %p msg %p pages %p no-op\n",
2369
		     con, con->in_msg, msg);
2370 2371 2372 2373
	}
	mutex_unlock(&con->mutex);
}

S
Sage Weil 已提交
2374 2375 2376 2377 2378
/*
 * Queue a keepalive byte to ensure the tcp connection is alive.
 */
void ceph_con_keepalive(struct ceph_connection *con)
{
S
Sage Weil 已提交
2379 2380
	dout("con_keepalive %p\n", con);
	clear_standby(con);
S
Sage Weil 已提交
2381 2382 2383 2384
	if (test_and_set_bit(KEEPALIVE_PENDING, &con->state) == 0 &&
	    test_and_set_bit(WRITE_PENDING, &con->state) == 0)
		queue_con(con);
}
2385
EXPORT_SYMBOL(ceph_con_keepalive);
S
Sage Weil 已提交
2386 2387 2388 2389 2390 2391


/*
 * construct a new message with given type, size
 * the new msg has a ref count of 1.
 */
2392 2393
struct ceph_msg *ceph_msg_new(int type, int front_len, gfp_t flags,
			      bool can_fail)
S
Sage Weil 已提交
2394 2395 2396
{
	struct ceph_msg *m;

2397
	m = kmalloc(sizeof(*m), flags);
S
Sage Weil 已提交
2398 2399
	if (m == NULL)
		goto out;
S
Sage Weil 已提交
2400
	kref_init(&m->kref);
S
Sage Weil 已提交
2401 2402
	INIT_LIST_HEAD(&m->list_head);

2403
	m->hdr.tid = 0;
S
Sage Weil 已提交
2404
	m->hdr.type = cpu_to_le16(type);
2405 2406
	m->hdr.priority = cpu_to_le16(CEPH_MSG_PRIO_DEFAULT);
	m->hdr.version = 0;
S
Sage Weil 已提交
2407 2408
	m->hdr.front_len = cpu_to_le32(front_len);
	m->hdr.middle_len = 0;
S
Sage Weil 已提交
2409 2410
	m->hdr.data_len = 0;
	m->hdr.data_off = 0;
2411
	m->hdr.reserved = 0;
S
Sage Weil 已提交
2412 2413 2414
	m->footer.front_crc = 0;
	m->footer.middle_crc = 0;
	m->footer.data_crc = 0;
2415
	m->footer.flags = 0;
S
Sage Weil 已提交
2416 2417 2418
	m->front_max = front_len;
	m->front_is_vmalloc = false;
	m->more_to_follow = false;
2419
	m->ack_stamp = 0;
S
Sage Weil 已提交
2420 2421
	m->pool = NULL;

2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434
	/* middle */
	m->middle = NULL;

	/* data */
	m->nr_pages = 0;
	m->page_alignment = 0;
	m->pages = NULL;
	m->pagelist = NULL;
	m->bio = NULL;
	m->bio_iter = NULL;
	m->bio_seg = 0;
	m->trail = NULL;

S
Sage Weil 已提交
2435 2436 2437
	/* front */
	if (front_len) {
		if (front_len > PAGE_CACHE_SIZE) {
2438
			m->front.iov_base = __vmalloc(front_len, flags,
S
Sage Weil 已提交
2439 2440 2441
						      PAGE_KERNEL);
			m->front_is_vmalloc = true;
		} else {
2442
			m->front.iov_base = kmalloc(front_len, flags);
S
Sage Weil 已提交
2443 2444
		}
		if (m->front.iov_base == NULL) {
2445
			dout("ceph_msg_new can't allocate %d bytes\n",
S
Sage Weil 已提交
2446 2447 2448 2449 2450 2451 2452 2453
			     front_len);
			goto out2;
		}
	} else {
		m->front.iov_base = NULL;
	}
	m->front.iov_len = front_len;

S
Sage Weil 已提交
2454
	dout("ceph_msg_new %p front %d\n", m, front_len);
S
Sage Weil 已提交
2455 2456 2457 2458 2459
	return m;

out2:
	ceph_msg_put(m);
out:
2460 2461 2462
	if (!can_fail) {
		pr_err("msg_new can't create type %d front %d\n", type,
		       front_len);
2463
		WARN_ON(1);
2464 2465 2466 2467
	} else {
		dout("msg_new can't create type %d front %d\n", type,
		     front_len);
	}
2468
	return NULL;
S
Sage Weil 已提交
2469
}
2470
EXPORT_SYMBOL(ceph_msg_new);
S
Sage Weil 已提交
2471 2472 2473 2474 2475 2476 2477 2478

/*
 * Allocate "middle" portion of a message, if it is needed and wasn't
 * allocated by alloc_msg.  This allows us to read a small fixed-size
 * per-type header in the front and then gracefully fail (i.e.,
 * propagate the error to the caller based on info in the front) when
 * the middle is too large.
 */
2479
static int ceph_alloc_middle(struct ceph_connection *con, struct ceph_msg *msg)
S
Sage Weil 已提交
2480 2481 2482 2483 2484 2485 2486 2487 2488
{
	int type = le16_to_cpu(msg->hdr.type);
	int middle_len = le32_to_cpu(msg->hdr.middle_len);

	dout("alloc_middle %p type %d %s middle_len %d\n", msg, type,
	     ceph_msg_type_name(type), middle_len);
	BUG_ON(!middle_len);
	BUG_ON(msg->middle);

S
Sage Weil 已提交
2489
	msg->middle = ceph_buffer_new(middle_len, GFP_NOFS);
S
Sage Weil 已提交
2490 2491 2492 2493 2494
	if (!msg->middle)
		return -ENOMEM;
	return 0;
}

2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508
/*
 * Generic message allocator, for incoming messages.
 */
static struct ceph_msg *ceph_alloc_msg(struct ceph_connection *con,
				struct ceph_msg_header *hdr,
				int *skip)
{
	int type = le16_to_cpu(hdr->type);
	int front_len = le32_to_cpu(hdr->front_len);
	int middle_len = le32_to_cpu(hdr->middle_len);
	struct ceph_msg *msg = NULL;
	int ret;

	if (con->ops->alloc_msg) {
2509
		mutex_unlock(&con->mutex);
2510
		msg = con->ops->alloc_msg(con, hdr, skip);
2511
		mutex_lock(&con->mutex);
2512
		if (!msg || *skip)
2513 2514 2515 2516
			return NULL;
	}
	if (!msg) {
		*skip = 0;
2517
		msg = ceph_msg_new(type, front_len, GFP_NOFS, false);
2518 2519 2520
		if (!msg) {
			pr_err("unable to allocate msg type %d len %d\n",
			       type, front_len);
2521
			return NULL;
2522
		}
2523
		msg->page_alignment = le16_to_cpu(hdr->data_off);
2524
	}
2525
	memcpy(&msg->hdr, &con->in_hdr, sizeof(con->in_hdr));
2526

S
Sage Weil 已提交
2527
	if (middle_len && !msg->middle) {
2528 2529 2530
		ret = ceph_alloc_middle(con, msg);
		if (ret < 0) {
			ceph_msg_put(msg);
2531
			return NULL;
2532 2533
		}
	}
2534

2535 2536 2537
	return msg;
}

S
Sage Weil 已提交
2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554

/*
 * Free a generically kmalloc'd message.
 */
void ceph_msg_kfree(struct ceph_msg *m)
{
	dout("msg_kfree %p\n", m);
	if (m->front_is_vmalloc)
		vfree(m->front.iov_base);
	else
		kfree(m->front.iov_base);
	kfree(m);
}

/*
 * Drop a msg ref.  Destroy as needed.
 */
S
Sage Weil 已提交
2555 2556 2557
void ceph_msg_last_put(struct kref *kref)
{
	struct ceph_msg *m = container_of(kref, struct ceph_msg, kref);
S
Sage Weil 已提交
2558

S
Sage Weil 已提交
2559 2560 2561 2562 2563 2564 2565
	dout("ceph_msg_put last one on %p\n", m);
	WARN_ON(!list_empty(&m->list_head));

	/* drop middle, data, if any */
	if (m->middle) {
		ceph_buffer_put(m->middle);
		m->middle = NULL;
S
Sage Weil 已提交
2566
	}
S
Sage Weil 已提交
2567 2568 2569
	m->nr_pages = 0;
	m->pages = NULL;

2570 2571 2572 2573 2574 2575
	if (m->pagelist) {
		ceph_pagelist_release(m->pagelist);
		kfree(m->pagelist);
		m->pagelist = NULL;
	}

2576 2577
	m->trail = NULL;

S
Sage Weil 已提交
2578 2579 2580 2581
	if (m->pool)
		ceph_msgpool_put(m->pool, m);
	else
		ceph_msg_kfree(m);
S
Sage Weil 已提交
2582
}
2583
EXPORT_SYMBOL(ceph_msg_last_put);
2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603

void ceph_msg_dump(struct ceph_msg *msg)
{
	pr_debug("msg_dump %p (front_max %d nr_pages %d)\n", msg,
		 msg->front_max, msg->nr_pages);
	print_hex_dump(KERN_DEBUG, "header: ",
		       DUMP_PREFIX_OFFSET, 16, 1,
		       &msg->hdr, sizeof(msg->hdr), true);
	print_hex_dump(KERN_DEBUG, " front: ",
		       DUMP_PREFIX_OFFSET, 16, 1,
		       msg->front.iov_base, msg->front.iov_len, true);
	if (msg->middle)
		print_hex_dump(KERN_DEBUG, "middle: ",
			       DUMP_PREFIX_OFFSET, 16, 1,
			       msg->middle->vec.iov_base,
			       msg->middle->vec.iov_len, true);
	print_hex_dump(KERN_DEBUG, "footer: ",
		       DUMP_PREFIX_OFFSET, 16, 1,
		       &msg->footer, sizeof(msg->footer), true);
}
2604
EXPORT_SYMBOL(ceph_msg_dump);