output.c 17.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/* RxRPC packet transmission
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

12 13
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

14
#include <linux/net.h>
15
#include <linux/gfp.h>
16
#include <linux/skbuff.h>
17
#include <linux/export.h>
18 19 20 21
#include <net/sock.h>
#include <net/af_rxrpc.h>
#include "ar-internal.h"

22
struct rxrpc_ack_buffer {
23
	struct rxrpc_wire_header whdr;
24 25 26
	struct rxrpc_ackpacket ack;
	u8 acks[255];
	u8 pad[3];
27 28 29
	struct rxrpc_ackinfo ackinfo;
};

30 31 32 33 34
struct rxrpc_abort_buffer {
	struct rxrpc_wire_header whdr;
	__be32 abort_code;
};

35 36
static const char rxrpc_keepalive_string[] = "";

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
/*
 * Increase Tx backoff on transmission failure and clear it on success.
 */
static void rxrpc_tx_backoff(struct rxrpc_call *call, int ret)
{
	if (ret < 0) {
		u16 tx_backoff = READ_ONCE(call->tx_backoff);

		if (tx_backoff < HZ)
			WRITE_ONCE(call->tx_backoff, tx_backoff + 1);
	} else {
		WRITE_ONCE(call->tx_backoff, 0);
	}
}

D
David Howells 已提交
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
/*
 * Arrange for a keepalive ping a certain time after we last transmitted.  This
 * lets the far side know we're still interested in this call and helps keep
 * the route through any intervening firewall open.
 *
 * Receiving a response to the ping will prevent the ->expect_rx_by timer from
 * expiring.
 */
static void rxrpc_set_keepalive(struct rxrpc_call *call)
{
	unsigned long now = jiffies, keepalive_at = call->next_rx_timo / 6;

	keepalive_at += now;
	WRITE_ONCE(call->keepalive_at, keepalive_at);
	rxrpc_reduce_call_timer(call, keepalive_at, now,
				rxrpc_timer_set_for_keepalive);
}

70 71 72
/*
 * Fill out an ACK packet.
 */
73 74
static size_t rxrpc_fill_out_ack(struct rxrpc_connection *conn,
				 struct rxrpc_call *call,
75
				 struct rxrpc_ack_buffer *pkt,
76
				 rxrpc_seq_t *_hard_ack,
77 78
				 rxrpc_seq_t *_top,
				 u8 reason)
79
{
80
	rxrpc_serial_t serial;
81 82
	rxrpc_seq_t hard_ack, top, seq;
	int ix;
83 84 85
	u32 mtu, jmax;
	u8 *ackp = pkt->acks;

86
	/* Barrier against rxrpc_input_data(). */
87
	serial = call->ackr_serial;
88 89
	hard_ack = READ_ONCE(call->rx_hard_ack);
	top = smp_load_acquire(&call->rx_top);
90 91
	*_hard_ack = hard_ack;
	*_top = top;
92

93
	pkt->ack.bufferSpace	= htons(8);
94 95
	pkt->ack.maxSkew	= htons(call->ackr_skew);
	pkt->ack.firstPacket	= htonl(hard_ack + 1);
96
	pkt->ack.previousPacket	= htonl(call->ackr_prev_seq);
97
	pkt->ack.serial		= htonl(serial);
98
	pkt->ack.reason		= reason;
99 100
	pkt->ack.nAcks		= top - hard_ack;

101
	if (reason == RXRPC_ACK_PING)
102 103
		pkt->whdr.flags |= RXRPC_REQUEST_ACK;

104 105 106 107 108 109 110 111 112 113 114
	if (after(top, hard_ack)) {
		seq = hard_ack + 1;
		do {
			ix = seq & RXRPC_RXTX_BUFF_MASK;
			if (call->rxtx_buffer[ix])
				*ackp++ = RXRPC_ACK_TYPE_ACK;
			else
				*ackp++ = RXRPC_ACK_TYPE_NACK;
			seq++;
		} while (before_eq(seq, top));
	}
115

116 117
	mtu = conn->params.peer->if_mtu;
	mtu -= conn->params.peer->hdrsize;
118
	jmax = (call->nr_jumbo_bad > 3) ? 1 : rxrpc_rx_jumbo_max;
119 120
	pkt->ackinfo.rxMTU	= htonl(rxrpc_rx_mtu);
	pkt->ackinfo.maxMTU	= htonl(mtu);
121
	pkt->ackinfo.rwind	= htonl(call->rx_winsize);
122 123 124 125 126
	pkt->ackinfo.jumbo_max	= htonl(jmax);

	*ackp++ = 0;
	*ackp++ = 0;
	*ackp++ = 0;
127
	return top - hard_ack + 3;
128 129 130
}

/*
131
 * Send an ACK call packet.
132
 */
133 134
int rxrpc_send_ack_packet(struct rxrpc_call *call, bool ping,
			  rxrpc_serial_t *_serial)
135 136
{
	struct rxrpc_connection *conn = NULL;
137
	struct rxrpc_ack_buffer *pkt;
138 139 140
	struct msghdr msg;
	struct kvec iov[2];
	rxrpc_serial_t serial;
141
	rxrpc_seq_t hard_ack, top;
142
	size_t len, n;
143
	int ret;
144
	u8 reason;
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168

	spin_lock_bh(&call->lock);
	if (call->conn)
		conn = rxrpc_get_connection_maybe(call->conn);
	spin_unlock_bh(&call->lock);
	if (!conn)
		return -ECONNRESET;

	pkt = kzalloc(sizeof(*pkt), GFP_KERNEL);
	if (!pkt) {
		rxrpc_put_connection(conn);
		return -ENOMEM;
	}

	msg.msg_name	= &call->peer->srx.transport;
	msg.msg_namelen	= call->peer->srx.transport_len;
	msg.msg_control	= NULL;
	msg.msg_controllen = 0;
	msg.msg_flags	= 0;

	pkt->whdr.epoch		= htonl(conn->proto.epoch);
	pkt->whdr.cid		= htonl(call->cid);
	pkt->whdr.callNumber	= htonl(call->call_id);
	pkt->whdr.seq		= 0;
169 170
	pkt->whdr.type		= RXRPC_PACKET_TYPE_ACK;
	pkt->whdr.flags		= RXRPC_SLOW_START_OK | conn->out_clientflag;
171 172 173 174 175
	pkt->whdr.userStatus	= 0;
	pkt->whdr.securityIndex	= call->security_ix;
	pkt->whdr._rsvd		= 0;
	pkt->whdr.serviceId	= htons(call->service_id);

176
	spin_lock_bh(&call->lock);
177 178 179 180 181 182 183 184 185 186
	if (ping) {
		reason = RXRPC_ACK_PING;
	} else {
		reason = call->ackr_reason;
		if (!call->ackr_reason) {
			spin_unlock_bh(&call->lock);
			ret = 0;
			goto out;
		}
		call->ackr_reason = 0;
187
	}
188
	n = rxrpc_fill_out_ack(conn, call, pkt, &hard_ack, &top, reason);
189 190 191 192 193 194 195 196

	spin_unlock_bh(&call->lock);

	iov[0].iov_base	= pkt;
	iov[0].iov_len	= sizeof(pkt->whdr) + sizeof(pkt->ack) + n;
	iov[1].iov_base = &pkt->ackinfo;
	iov[1].iov_len	= sizeof(pkt->ackinfo);
	len = iov[0].iov_len + iov[1].iov_len;
197

198 199
	serial = atomic_inc_return(&conn->serial);
	pkt->whdr.serial = htonl(serial);
D
David Howells 已提交
200
	trace_rxrpc_tx_ack(call->debug_id, serial,
201 202 203
			   ntohl(pkt->ack.firstPacket),
			   ntohl(pkt->ack.serial),
			   pkt->ack.reason, pkt->ack.nAcks);
204 205
	if (_serial)
		*_serial = serial;
206

207
	if (ping) {
208
		call->ping_serial = serial;
209 210 211 212
		smp_wmb();
		/* We need to stick a time in before we send the packet in case
		 * the reply gets back before kernel_sendmsg() completes - but
		 * asking UDP to send the packet can take a relatively long
D
David Howells 已提交
213
		 * time.
214
		 */
215
		call->ping_time = ktime_get_real();
216 217 218
		set_bit(RXRPC_CALL_PINGING, &call->flags);
		trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_ping, serial);
	}
219 220

	ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len);
221
	conn->params.peer->last_tx_at = ktime_get_seconds();
222 223
	if (ret < 0)
		trace_rxrpc_tx_fail(call->debug_id, serial, ret,
D
David Howells 已提交
224 225 226 227
				    rxrpc_tx_point_call_ack);
	else
		trace_rxrpc_tx_packet(call->debug_id, &pkt->whdr,
				      rxrpc_tx_point_call_ack);
228
	rxrpc_tx_backoff(call, ret);
229

230
	if (call->state < RXRPC_CALL_COMPLETE) {
231
		if (ret < 0) {
232 233
			if (ping)
				clear_bit(RXRPC_CALL_PINGING, &call->flags);
234 235 236
			rxrpc_propose_ACK(call, pkt->ack.reason,
					  ntohs(pkt->ack.maxSkew),
					  ntohl(pkt->ack.serial),
237
					  false, true,
238
					  rxrpc_propose_ack_retry_tx);
239 240 241 242 243 244 245
		} else {
			spin_lock_bh(&call->lock);
			if (after(hard_ack, call->ackr_consumed))
				call->ackr_consumed = hard_ack;
			if (after(top, call->ackr_seen))
				call->ackr_seen = top;
			spin_unlock_bh(&call->lock);
246
		}
D
David Howells 已提交
247 248

		rxrpc_set_keepalive(call);
249 250
	}

251 252 253 254 255 256
out:
	rxrpc_put_connection(conn);
	kfree(pkt);
	return ret;
}

257 258 259 260 261 262 263 264 265 266 267 268
/*
 * Send an ABORT call packet.
 */
int rxrpc_send_abort_packet(struct rxrpc_call *call)
{
	struct rxrpc_connection *conn = NULL;
	struct rxrpc_abort_buffer pkt;
	struct msghdr msg;
	struct kvec iov[1];
	rxrpc_serial_t serial;
	int ret;

D
David Howells 已提交
269 270 271 272 273 274 275 276 277 278
	/* Don't bother sending aborts for a client call once the server has
	 * hard-ACK'd all of its request data.  After that point, we're not
	 * going to stop the operation proceeding, and whilst we might limit
	 * the reply, it's not worth it if we can send a new call on the same
	 * channel instead, thereby closing off this call.
	 */
	if (rxrpc_is_client_call(call) &&
	    test_bit(RXRPC_CALL_TX_LAST, &call->flags))
		return 0;

279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
	spin_lock_bh(&call->lock);
	if (call->conn)
		conn = rxrpc_get_connection_maybe(call->conn);
	spin_unlock_bh(&call->lock);
	if (!conn)
		return -ECONNRESET;

	msg.msg_name	= &call->peer->srx.transport;
	msg.msg_namelen	= call->peer->srx.transport_len;
	msg.msg_control	= NULL;
	msg.msg_controllen = 0;
	msg.msg_flags	= 0;

	pkt.whdr.epoch		= htonl(conn->proto.epoch);
	pkt.whdr.cid		= htonl(call->cid);
	pkt.whdr.callNumber	= htonl(call->call_id);
	pkt.whdr.seq		= 0;
	pkt.whdr.type		= RXRPC_PACKET_TYPE_ABORT;
	pkt.whdr.flags		= conn->out_clientflag;
	pkt.whdr.userStatus	= 0;
	pkt.whdr.securityIndex	= call->security_ix;
	pkt.whdr._rsvd		= 0;
	pkt.whdr.serviceId	= htons(call->service_id);
	pkt.abort_code		= htonl(call->abort_code);

	iov[0].iov_base	= &pkt;
	iov[0].iov_len	= sizeof(pkt);

	serial = atomic_inc_return(&conn->serial);
	pkt.whdr.serial = htonl(serial);

	ret = kernel_sendmsg(conn->params.local->socket,
			     &msg, iov, 1, sizeof(pkt));
312
	conn->params.peer->last_tx_at = ktime_get_seconds();
313 314
	if (ret < 0)
		trace_rxrpc_tx_fail(call->debug_id, serial, ret,
D
David Howells 已提交
315 316 317 318
				    rxrpc_tx_point_call_abort);
	else
		trace_rxrpc_tx_packet(call->debug_id, &pkt.whdr,
				      rxrpc_tx_point_call_abort);
319
	rxrpc_tx_backoff(call, ret);
320 321 322 323 324

	rxrpc_put_connection(conn);
	return ret;
}

325 326 327
/*
 * send a packet through the transport endpoint
 */
328 329
int rxrpc_send_data_packet(struct rxrpc_call *call, struct sk_buff *skb,
			   bool retrans)
330
{
331 332 333
	struct rxrpc_connection *conn = call->conn;
	struct rxrpc_wire_header whdr;
	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
334
	struct msghdr msg;
335 336 337
	struct kvec iov[2];
	rxrpc_serial_t serial;
	size_t len;
338
	bool lost = false;
339 340 341 342
	int ret, opt;

	_enter(",{%d}", skb->len);

343 344
	/* Each transmission of a Tx packet needs a new serial number */
	serial = atomic_inc_return(&conn->serial);
345

346 347 348 349 350 351 352 353 354 355 356 357
	whdr.epoch	= htonl(conn->proto.epoch);
	whdr.cid	= htonl(call->cid);
	whdr.callNumber	= htonl(call->call_id);
	whdr.seq	= htonl(sp->hdr.seq);
	whdr.serial	= htonl(serial);
	whdr.type	= RXRPC_PACKET_TYPE_DATA;
	whdr.flags	= sp->hdr.flags;
	whdr.userStatus	= 0;
	whdr.securityIndex = call->security_ix;
	whdr._rsvd	= htons(sp->hdr._rsvd);
	whdr.serviceId	= htons(call->service_id);

358 359 360 361
	if (test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags) &&
	    sp->hdr.seq == 1)
		whdr.userStatus	= RXRPC_USERSTATUS_SERVICE_UPGRADE;

362 363 364 365 366 367 368 369
	iov[0].iov_base = &whdr;
	iov[0].iov_len = sizeof(whdr);
	iov[1].iov_base = skb->head;
	iov[1].iov_len = skb->len;
	len = iov[0].iov_len + iov[1].iov_len;

	msg.msg_name = &call->peer->srx.transport;
	msg.msg_namelen = call->peer->srx.transport_len;
370 371 372 373
	msg.msg_control = NULL;
	msg.msg_controllen = 0;
	msg.msg_flags = 0;

D
David Howells 已提交
374 375
	/* If our RTT cache needs working on, request an ACK.  Also request
	 * ACKs if a DATA packet appears to have been lost.
D
David Howells 已提交
376 377 378 379
	 *
	 * However, we mustn't request an ACK on the last reply packet of a
	 * service call, lest OpenAFS incorrectly send us an ACK with some
	 * soft-ACKs in it and then never follow up with a proper hard ACK.
D
David Howells 已提交
380
	 */
D
David Howells 已提交
381 382 383
	if ((!(sp->hdr.flags & RXRPC_LAST_PACKET) ||
	     rxrpc_to_server(sp)
	     ) &&
384 385
	    (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events) ||
	     retrans ||
386 387 388 389
	     call->cong_mode == RXRPC_CALL_SLOW_START ||
	     (call->peer->rtt_usage < 3 && sp->hdr.seq & 1) ||
	     ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000),
			  ktime_get_real())))
390 391
		whdr.flags |= RXRPC_REQUEST_ACK;

392 393 394
	if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS)) {
		static int lose;
		if ((lose++ & 7) == 7) {
395 396 397
			ret = 0;
			lost = true;
			goto done;
398 399 400
		}
	}

401 402
	_proto("Tx DATA %%%u { #%u }", serial, sp->hdr.seq);

403 404
	/* send the packet with the don't fragment bit set if we currently
	 * think it's small enough */
405 406 407 408
	if (iov[1].iov_len >= call->peer->maxdata)
		goto send_fragmentable;

	down_read(&conn->params.local->defrag_sem);
D
David Howells 已提交
409 410 411 412 413

	sp->hdr.serial = serial;
	smp_wmb(); /* Set serial before timestamp */
	skb->tstamp = ktime_get_real();

414 415 416 417 418 419 420
	/* send the packet by UDP
	 * - returns -EMSGSIZE if UDP would have to fragment the packet
	 *   to go out of the interface
	 *   - in which case, we'll have processed the ICMP error
	 *     message and update the peer record
	 */
	ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len);
421
	conn->params.peer->last_tx_at = ktime_get_seconds();
422 423

	up_read(&conn->params.local->defrag_sem);
424 425
	if (ret < 0)
		trace_rxrpc_tx_fail(call->debug_id, serial, ret,
D
David Howells 已提交
426 427 428 429
				    rxrpc_tx_point_call_data_nofrag);
	else
		trace_rxrpc_tx_packet(call->debug_id, &whdr,
				      rxrpc_tx_point_call_data_nofrag);
430
	rxrpc_tx_backoff(call, ret);
431 432 433 434
	if (ret == -EMSGSIZE)
		goto send_fragmentable;

done:
435 436
	trace_rxrpc_tx_data(call, sp->hdr.seq, serial, whdr.flags,
			    retrans, lost);
437
	if (ret >= 0) {
438
		if (whdr.flags & RXRPC_REQUEST_ACK) {
D
David Howells 已提交
439
			call->peer->rtt_last_req = skb->tstamp;
440
			trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_data, serial);
441 442 443 444 445 446 447 448 449 450 451 452
			if (call->peer->rtt_usage > 1) {
				unsigned long nowj = jiffies, ack_lost_at;

				ack_lost_at = nsecs_to_jiffies(2 * call->peer->rtt);
				if (ack_lost_at < 1)
					ack_lost_at = 1;

				ack_lost_at += nowj;
				WRITE_ONCE(call->ack_lost_at, ack_lost_at);
				rxrpc_reduce_call_timer(call, ack_lost_at, nowj,
							rxrpc_timer_set_for_lost_ack);
			}
453
		}
454 455 456 457 458 459 460 461 462 463 464

		if (sp->hdr.seq == 1 &&
		    !test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER,
				      &call->flags)) {
			unsigned long nowj = jiffies, expect_rx_by;

			expect_rx_by = nowj + call->next_rx_timo;
			WRITE_ONCE(call->expect_rx_by, expect_rx_by);
			rxrpc_reduce_call_timer(call, expect_rx_by, nowj,
						rxrpc_timer_set_for_normal);
		}
D
David Howells 已提交
465

466 467 468 469 470 471 472 473 474 475 476
		rxrpc_set_keepalive(call);
	} else {
		/* Cancel the call if the initial transmission fails,
		 * particularly if that's due to network routing issues that
		 * aren't going away anytime soon.  The layer above can arrange
		 * the retransmission.
		 */
		if (!test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER, &call->flags))
			rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR,
						  RX_USER_ABORT, ret);
	}
D
David Howells 已提交
477

478 479
	_leave(" = %d [%u]", ret, call->peer->maxdata);
	return ret;
480 481 482 483 484

send_fragmentable:
	/* attempt to send this message with fragmentation enabled */
	_debug("send fragment");

485 486
	down_write(&conn->params.local->defrag_sem);

D
David Howells 已提交
487 488 489 490
	sp->hdr.serial = serial;
	smp_wmb(); /* Set serial before timestamp */
	skb->tstamp = ktime_get_real();

491 492 493 494 495 496 497
	switch (conn->params.local->srx.transport.family) {
	case AF_INET:
		opt = IP_PMTUDISC_DONT;
		ret = kernel_setsockopt(conn->params.local->socket,
					SOL_IP, IP_MTU_DISCOVER,
					(char *)&opt, sizeof(opt));
		if (ret == 0) {
498 499
			ret = kernel_sendmsg(conn->params.local->socket, &msg,
					     iov, 2, len);
500
			conn->params.peer->last_tx_at = ktime_get_seconds();
501 502 503 504 505 506 507

			opt = IP_PMTUDISC_DO;
			kernel_setsockopt(conn->params.local->socket, SOL_IP,
					  IP_MTU_DISCOVER,
					  (char *)&opt, sizeof(opt));
		}
		break;
D
David Howells 已提交
508

509
#ifdef CONFIG_AF_RXRPC_IPV6
D
David Howells 已提交
510 511 512 513 514 515 516
	case AF_INET6:
		opt = IPV6_PMTUDISC_DONT;
		ret = kernel_setsockopt(conn->params.local->socket,
					SOL_IPV6, IPV6_MTU_DISCOVER,
					(char *)&opt, sizeof(opt));
		if (ret == 0) {
			ret = kernel_sendmsg(conn->params.local->socket, &msg,
517
					     iov, 2, len);
518
			conn->params.peer->last_tx_at = ktime_get_seconds();
D
David Howells 已提交
519 520 521 522 523 524 525

			opt = IPV6_PMTUDISC_DO;
			kernel_setsockopt(conn->params.local->socket,
					  SOL_IPV6, IPV6_MTU_DISCOVER,
					  (char *)&opt, sizeof(opt));
		}
		break;
526
#endif
527 528
	}

529 530
	if (ret < 0)
		trace_rxrpc_tx_fail(call->debug_id, serial, ret,
D
David Howells 已提交
531 532 533 534
				    rxrpc_tx_point_call_data_frag);
	else
		trace_rxrpc_tx_packet(call->debug_id, &whdr,
				      rxrpc_tx_point_call_data_frag);
535
	rxrpc_tx_backoff(call, ret);
536

537
	up_write(&conn->params.local->defrag_sem);
538
	goto done;
539
}
540 541 542 543 544 545

/*
 * reject packets through the local endpoint
 */
void rxrpc_reject_packets(struct rxrpc_local *local)
{
546
	struct sockaddr_rxrpc srx;
547 548 549 550 551 552 553
	struct rxrpc_skb_priv *sp;
	struct rxrpc_wire_header whdr;
	struct sk_buff *skb;
	struct msghdr msg;
	struct kvec iov[2];
	size_t size;
	__be32 code;
554
	int ret, ioc;
555 556 557 558 559 560 561 562

	_enter("%d", local->debug_id);

	iov[0].iov_base = &whdr;
	iov[0].iov_len = sizeof(whdr);
	iov[1].iov_base = &code;
	iov[1].iov_len = sizeof(code);

563
	msg.msg_name = &srx.transport;
564 565 566 567 568 569 570
	msg.msg_control = NULL;
	msg.msg_controllen = 0;
	msg.msg_flags = 0;

	memset(&whdr, 0, sizeof(whdr));

	while ((skb = skb_dequeue(&local->reject_queue))) {
D
David Howells 已提交
571
		rxrpc_see_skb(skb, rxrpc_skb_rx_seen);
572
		sp = rxrpc_skb(skb);
573

574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
		switch (skb->mark) {
		case RXRPC_SKB_MARK_REJECT_BUSY:
			whdr.type = RXRPC_PACKET_TYPE_BUSY;
			size = sizeof(whdr);
			ioc = 1;
			break;
		case RXRPC_SKB_MARK_REJECT_ABORT:
			whdr.type = RXRPC_PACKET_TYPE_ABORT;
			code = htonl(skb->priority);
			size = sizeof(whdr) + sizeof(code);
			ioc = 2;
			break;
		default:
			rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
			continue;
		}

D
David Howells 已提交
591
		if (rxrpc_extract_addr_from_skb(local, &srx, skb) == 0) {
592 593
			msg.msg_namelen = srx.transport_len;

594 595 596 597 598 599 600 601
			whdr.epoch	= htonl(sp->hdr.epoch);
			whdr.cid	= htonl(sp->hdr.cid);
			whdr.callNumber	= htonl(sp->hdr.callNumber);
			whdr.serviceId	= htons(sp->hdr.serviceId);
			whdr.flags	= sp->hdr.flags;
			whdr.flags	^= RXRPC_CLIENT_INITIATED;
			whdr.flags	&= RXRPC_CLIENT_INITIATED;

602 603
			ret = kernel_sendmsg(local->socket, &msg,
					     iov, ioc, size);
604 605
			if (ret < 0)
				trace_rxrpc_tx_fail(local->debug_id, 0, ret,
D
David Howells 已提交
606 607 608 609
						    rxrpc_tx_point_reject);
			else
				trace_rxrpc_tx_packet(local->debug_id, &whdr,
						      rxrpc_tx_point_reject);
610 611
		}

D
David Howells 已提交
612
		rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
613 614 615 616
	}

	_leave("");
}
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659

/*
 * Send a VERSION reply to a peer as a keepalive.
 */
void rxrpc_send_keepalive(struct rxrpc_peer *peer)
{
	struct rxrpc_wire_header whdr;
	struct msghdr msg;
	struct kvec iov[2];
	size_t len;
	int ret;

	_enter("");

	msg.msg_name	= &peer->srx.transport;
	msg.msg_namelen	= peer->srx.transport_len;
	msg.msg_control	= NULL;
	msg.msg_controllen = 0;
	msg.msg_flags	= 0;

	whdr.epoch	= htonl(peer->local->rxnet->epoch);
	whdr.cid	= 0;
	whdr.callNumber	= 0;
	whdr.seq	= 0;
	whdr.serial	= 0;
	whdr.type	= RXRPC_PACKET_TYPE_VERSION; /* Not client-initiated */
	whdr.flags	= RXRPC_LAST_PACKET;
	whdr.userStatus	= 0;
	whdr.securityIndex = 0;
	whdr._rsvd	= 0;
	whdr.serviceId	= 0;

	iov[0].iov_base	= &whdr;
	iov[0].iov_len	= sizeof(whdr);
	iov[1].iov_base	= (char *)rxrpc_keepalive_string;
	iov[1].iov_len	= sizeof(rxrpc_keepalive_string);

	len = iov[0].iov_len + iov[1].iov_len;

	_proto("Tx VERSION (keepalive)");

	ret = kernel_sendmsg(peer->local->socket, &msg, iov, 2, len);
	if (ret < 0)
660
		trace_rxrpc_tx_fail(peer->debug_id, 0, ret,
D
David Howells 已提交
661 662 663 664
				    rxrpc_tx_point_version_keepalive);
	else
		trace_rxrpc_tx_packet(peer->debug_id, &whdr,
				      rxrpc_tx_point_version_keepalive);
665

666
	peer->last_tx_at = ktime_get_seconds();
667 668
	_leave("");
}