1 /* RxRPC packet transmission 2 * 3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/net.h> 15 #include <linux/gfp.h> 16 #include <linux/skbuff.h> 17 #include <linux/export.h> 18 #include <net/sock.h> 19 #include <net/af_rxrpc.h> 20 #include "ar-internal.h" 21 22 struct rxrpc_ack_buffer { 23 struct rxrpc_wire_header whdr; 24 struct rxrpc_ackpacket ack; 25 u8 acks[255]; 26 u8 pad[3]; 27 struct rxrpc_ackinfo ackinfo; 28 }; 29 30 struct rxrpc_abort_buffer { 31 struct rxrpc_wire_header whdr; 32 __be32 abort_code; 33 }; 34 35 static const char rxrpc_keepalive_string[] = ""; 36 37 /* 38 * Increase Tx backoff on transmission failure and clear it on success. 39 */ 40 static void rxrpc_tx_backoff(struct rxrpc_call *call, int ret) 41 { 42 if (ret < 0) { 43 u16 tx_backoff = READ_ONCE(call->tx_backoff); 44 45 if (tx_backoff < HZ) 46 WRITE_ONCE(call->tx_backoff, tx_backoff + 1); 47 } else { 48 WRITE_ONCE(call->tx_backoff, 0); 49 } 50 } 51 52 /* 53 * Arrange for a keepalive ping a certain time after we last transmitted. This 54 * lets the far side know we're still interested in this call and helps keep 55 * the route through any intervening firewall open. 56 * 57 * Receiving a response to the ping will prevent the ->expect_rx_by timer from 58 * expiring. 59 */ 60 static void rxrpc_set_keepalive(struct rxrpc_call *call) 61 { 62 unsigned long now = jiffies, keepalive_at = call->next_rx_timo / 6; 63 64 keepalive_at += now; 65 WRITE_ONCE(call->keepalive_at, keepalive_at); 66 rxrpc_reduce_call_timer(call, keepalive_at, now, 67 rxrpc_timer_set_for_keepalive); 68 } 69 70 /* 71 * Fill out an ACK packet. 72 */ 73 static size_t rxrpc_fill_out_ack(struct rxrpc_connection *conn, 74 struct rxrpc_call *call, 75 struct rxrpc_ack_buffer *pkt, 76 rxrpc_seq_t *_hard_ack, 77 rxrpc_seq_t *_top, 78 u8 reason) 79 { 80 rxrpc_serial_t serial; 81 rxrpc_seq_t hard_ack, top, seq; 82 int ix; 83 u32 mtu, jmax; 84 u8 *ackp = pkt->acks; 85 86 /* Barrier against rxrpc_input_data(). */ 87 serial = call->ackr_serial; 88 hard_ack = READ_ONCE(call->rx_hard_ack); 89 top = smp_load_acquire(&call->rx_top); 90 *_hard_ack = hard_ack; 91 *_top = top; 92 93 pkt->ack.bufferSpace = htons(8); 94 pkt->ack.maxSkew = htons(call->ackr_skew); 95 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 pkt->ack.nAcks = top - hard_ack; 100 101 if (reason == RXRPC_ACK_PING) 102 pkt->whdr.flags |= RXRPC_REQUEST_ACK; 103 104 if (after(top, hard_ack)) { 105 seq = hard_ack + 1; 106 do { 107 ix = seq & RXRPC_RXTX_BUFF_MASK; 108 if (call->rxtx_buffer[ix]) 109 *ackp++ = RXRPC_ACK_TYPE_ACK; 110 else 111 *ackp++ = RXRPC_ACK_TYPE_NACK; 112 seq++; 113 } while (before_eq(seq, top)); 114 } 115 116 mtu = conn->params.peer->if_mtu; 117 mtu -= conn->params.peer->hdrsize; 118 jmax = (call->nr_jumbo_bad > 3) ? 1 : rxrpc_rx_jumbo_max; 119 pkt->ackinfo.rxMTU = htonl(rxrpc_rx_mtu); 120 pkt->ackinfo.maxMTU = htonl(mtu); 121 pkt->ackinfo.rwind = htonl(call->rx_winsize); 122 pkt->ackinfo.jumbo_max = htonl(jmax); 123 124 *ackp++ = 0; 125 *ackp++ = 0; 126 *ackp++ = 0; 127 return top - hard_ack + 3; 128 } 129 130 /* 131 * Send an ACK call packet. 132 */ 133 int rxrpc_send_ack_packet(struct rxrpc_call *call, bool ping, 134 rxrpc_serial_t *_serial) 135 { 136 struct rxrpc_connection *conn = NULL; 137 struct rxrpc_ack_buffer *pkt; 138 struct msghdr msg; 139 struct kvec iov[2]; 140 rxrpc_serial_t serial; 141 rxrpc_seq_t hard_ack, top; 142 size_t len, n; 143 int ret; 144 u8 reason; 145 146 spin_lock_bh(&call->lock); 147 if (call->conn) 148 conn = rxrpc_get_connection_maybe(call->conn); 149 spin_unlock_bh(&call->lock); 150 if (!conn) 151 return -ECONNRESET; 152 153 pkt = kzalloc(sizeof(*pkt), GFP_KERNEL); 154 if (!pkt) { 155 rxrpc_put_connection(conn); 156 return -ENOMEM; 157 } 158 159 msg.msg_name = &call->peer->srx.transport; 160 msg.msg_namelen = call->peer->srx.transport_len; 161 msg.msg_control = NULL; 162 msg.msg_controllen = 0; 163 msg.msg_flags = 0; 164 165 pkt->whdr.epoch = htonl(conn->proto.epoch); 166 pkt->whdr.cid = htonl(call->cid); 167 pkt->whdr.callNumber = htonl(call->call_id); 168 pkt->whdr.seq = 0; 169 pkt->whdr.type = RXRPC_PACKET_TYPE_ACK; 170 pkt->whdr.flags = RXRPC_SLOW_START_OK | conn->out_clientflag; 171 pkt->whdr.userStatus = 0; 172 pkt->whdr.securityIndex = call->security_ix; 173 pkt->whdr._rsvd = 0; 174 pkt->whdr.serviceId = htons(call->service_id); 175 176 spin_lock_bh(&call->lock); 177 if (ping) { 178 reason = RXRPC_ACK_PING; 179 } else { 180 reason = call->ackr_reason; 181 if (!call->ackr_reason) { 182 spin_unlock_bh(&call->lock); 183 ret = 0; 184 goto out; 185 } 186 call->ackr_reason = 0; 187 } 188 n = rxrpc_fill_out_ack(conn, call, pkt, &hard_ack, &top, reason); 189 190 spin_unlock_bh(&call->lock); 191 192 iov[0].iov_base = pkt; 193 iov[0].iov_len = sizeof(pkt->whdr) + sizeof(pkt->ack) + n; 194 iov[1].iov_base = &pkt->ackinfo; 195 iov[1].iov_len = sizeof(pkt->ackinfo); 196 len = iov[0].iov_len + iov[1].iov_len; 197 198 serial = atomic_inc_return(&conn->serial); 199 pkt->whdr.serial = htonl(serial); 200 trace_rxrpc_tx_ack(call->debug_id, serial, 201 ntohl(pkt->ack.firstPacket), 202 ntohl(pkt->ack.serial), 203 pkt->ack.reason, pkt->ack.nAcks); 204 if (_serial) 205 *_serial = serial; 206 207 if (ping) { 208 call->ping_serial = serial; 209 smp_wmb(); 210 /* We need to stick a time in before we send the packet in case 211 * the reply gets back before kernel_sendmsg() completes - but 212 * asking UDP to send the packet can take a relatively long 213 * time. 214 */ 215 call->ping_time = ktime_get_real(); 216 set_bit(RXRPC_CALL_PINGING, &call->flags); 217 trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_ping, serial); 218 } 219 220 ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len); 221 conn->params.peer->last_tx_at = ktime_get_seconds(); 222 if (ret < 0) 223 trace_rxrpc_tx_fail(call->debug_id, serial, ret, 224 rxrpc_tx_point_call_ack); 225 else 226 trace_rxrpc_tx_packet(call->debug_id, &pkt->whdr, 227 rxrpc_tx_point_call_ack); 228 rxrpc_tx_backoff(call, ret); 229 230 if (call->state < RXRPC_CALL_COMPLETE) { 231 if (ret < 0) { 232 if (ping) 233 clear_bit(RXRPC_CALL_PINGING, &call->flags); 234 rxrpc_propose_ACK(call, pkt->ack.reason, 235 ntohs(pkt->ack.maxSkew), 236 ntohl(pkt->ack.serial), 237 false, true, 238 rxrpc_propose_ack_retry_tx); 239 } else { 240 spin_lock_bh(&call->lock); 241 if (after(hard_ack, call->ackr_consumed)) 242 call->ackr_consumed = hard_ack; 243 if (after(top, call->ackr_seen)) 244 call->ackr_seen = top; 245 spin_unlock_bh(&call->lock); 246 } 247 248 rxrpc_set_keepalive(call); 249 } 250 251 out: 252 rxrpc_put_connection(conn); 253 kfree(pkt); 254 return ret; 255 } 256 257 /* 258 * Send an ABORT call packet. 259 */ 260 int rxrpc_send_abort_packet(struct rxrpc_call *call) 261 { 262 struct rxrpc_connection *conn = NULL; 263 struct rxrpc_abort_buffer pkt; 264 struct msghdr msg; 265 struct kvec iov[1]; 266 rxrpc_serial_t serial; 267 int ret; 268 269 /* Don't bother sending aborts for a client call once the server has 270 * hard-ACK'd all of its request data. After that point, we're not 271 * going to stop the operation proceeding, and whilst we might limit 272 * the reply, it's not worth it if we can send a new call on the same 273 * channel instead, thereby closing off this call. 274 */ 275 if (rxrpc_is_client_call(call) && 276 test_bit(RXRPC_CALL_TX_LAST, &call->flags)) 277 return 0; 278 279 spin_lock_bh(&call->lock); 280 if (call->conn) 281 conn = rxrpc_get_connection_maybe(call->conn); 282 spin_unlock_bh(&call->lock); 283 if (!conn) 284 return -ECONNRESET; 285 286 msg.msg_name = &call->peer->srx.transport; 287 msg.msg_namelen = call->peer->srx.transport_len; 288 msg.msg_control = NULL; 289 msg.msg_controllen = 0; 290 msg.msg_flags = 0; 291 292 pkt.whdr.epoch = htonl(conn->proto.epoch); 293 pkt.whdr.cid = htonl(call->cid); 294 pkt.whdr.callNumber = htonl(call->call_id); 295 pkt.whdr.seq = 0; 296 pkt.whdr.type = RXRPC_PACKET_TYPE_ABORT; 297 pkt.whdr.flags = conn->out_clientflag; 298 pkt.whdr.userStatus = 0; 299 pkt.whdr.securityIndex = call->security_ix; 300 pkt.whdr._rsvd = 0; 301 pkt.whdr.serviceId = htons(call->service_id); 302 pkt.abort_code = htonl(call->abort_code); 303 304 iov[0].iov_base = &pkt; 305 iov[0].iov_len = sizeof(pkt); 306 307 serial = atomic_inc_return(&conn->serial); 308 pkt.whdr.serial = htonl(serial); 309 310 ret = kernel_sendmsg(conn->params.local->socket, 311 &msg, iov, 1, sizeof(pkt)); 312 conn->params.peer->last_tx_at = ktime_get_seconds(); 313 if (ret < 0) 314 trace_rxrpc_tx_fail(call->debug_id, serial, ret, 315 rxrpc_tx_point_call_abort); 316 else 317 trace_rxrpc_tx_packet(call->debug_id, &pkt.whdr, 318 rxrpc_tx_point_call_abort); 319 rxrpc_tx_backoff(call, ret); 320 321 rxrpc_put_connection(conn); 322 return ret; 323 } 324 325 /* 326 * send a packet through the transport endpoint 327 */ 328 int rxrpc_send_data_packet(struct rxrpc_call *call, struct sk_buff *skb, 329 bool retrans) 330 { 331 struct rxrpc_connection *conn = call->conn; 332 struct rxrpc_wire_header whdr; 333 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 334 struct msghdr msg; 335 struct kvec iov[2]; 336 rxrpc_serial_t serial; 337 size_t len; 338 bool lost = false; 339 int ret, opt; 340 341 _enter(",{%d}", skb->len); 342 343 /* Each transmission of a Tx packet needs a new serial number */ 344 serial = atomic_inc_return(&conn->serial); 345 346 whdr.epoch = htonl(conn->proto.epoch); 347 whdr.cid = htonl(call->cid); 348 whdr.callNumber = htonl(call->call_id); 349 whdr.seq = htonl(sp->hdr.seq); 350 whdr.serial = htonl(serial); 351 whdr.type = RXRPC_PACKET_TYPE_DATA; 352 whdr.flags = sp->hdr.flags; 353 whdr.userStatus = 0; 354 whdr.securityIndex = call->security_ix; 355 whdr._rsvd = htons(sp->hdr._rsvd); 356 whdr.serviceId = htons(call->service_id); 357 358 if (test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags) && 359 sp->hdr.seq == 1) 360 whdr.userStatus = RXRPC_USERSTATUS_SERVICE_UPGRADE; 361 362 iov[0].iov_base = &whdr; 363 iov[0].iov_len = sizeof(whdr); 364 iov[1].iov_base = skb->head; 365 iov[1].iov_len = skb->len; 366 len = iov[0].iov_len + iov[1].iov_len; 367 368 msg.msg_name = &call->peer->srx.transport; 369 msg.msg_namelen = call->peer->srx.transport_len; 370 msg.msg_control = NULL; 371 msg.msg_controllen = 0; 372 msg.msg_flags = 0; 373 374 /* If our RTT cache needs working on, request an ACK. Also request 375 * ACKs if a DATA packet appears to have been lost. 376 * 377 * However, we mustn't request an ACK on the last reply packet of a 378 * service call, lest OpenAFS incorrectly send us an ACK with some 379 * soft-ACKs in it and then never follow up with a proper hard ACK. 380 */ 381 if ((!(sp->hdr.flags & RXRPC_LAST_PACKET) || 382 rxrpc_to_server(sp) 383 ) && 384 (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events) || 385 retrans || 386 call->cong_mode == RXRPC_CALL_SLOW_START || 387 (call->peer->rtt_usage < 3 && sp->hdr.seq & 1) || 388 ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), 389 ktime_get_real()))) 390 whdr.flags |= RXRPC_REQUEST_ACK; 391 392 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS)) { 393 static int lose; 394 if ((lose++ & 7) == 7) { 395 ret = 0; 396 lost = true; 397 } 398 } 399 400 trace_rxrpc_tx_data(call, sp->hdr.seq, serial, whdr.flags, 401 retrans, lost); 402 if (lost) 403 goto done; 404 405 /* send the packet with the don't fragment bit set if we currently 406 * think it's small enough */ 407 if (iov[1].iov_len >= call->peer->maxdata) 408 goto send_fragmentable; 409 410 down_read(&conn->params.local->defrag_sem); 411 412 sp->hdr.serial = serial; 413 smp_wmb(); /* Set serial before timestamp */ 414 skb->tstamp = ktime_get_real(); 415 416 /* send the packet by UDP 417 * - returns -EMSGSIZE if UDP would have to fragment the packet 418 * to go out of the interface 419 * - in which case, we'll have processed the ICMP error 420 * message and update the peer record 421 */ 422 ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len); 423 conn->params.peer->last_tx_at = ktime_get_seconds(); 424 425 up_read(&conn->params.local->defrag_sem); 426 if (ret < 0) 427 trace_rxrpc_tx_fail(call->debug_id, serial, ret, 428 rxrpc_tx_point_call_data_nofrag); 429 else 430 trace_rxrpc_tx_packet(call->debug_id, &whdr, 431 rxrpc_tx_point_call_data_nofrag); 432 rxrpc_tx_backoff(call, ret); 433 if (ret == -EMSGSIZE) 434 goto send_fragmentable; 435 436 done: 437 if (ret >= 0) { 438 if (whdr.flags & RXRPC_REQUEST_ACK) { 439 call->peer->rtt_last_req = skb->tstamp; 440 trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_data, serial); 441 if (call->peer->rtt_usage > 1) { 442 unsigned long nowj = jiffies, ack_lost_at; 443 444 ack_lost_at = nsecs_to_jiffies(2 * call->peer->rtt); 445 if (ack_lost_at < 1) 446 ack_lost_at = 1; 447 448 ack_lost_at += nowj; 449 WRITE_ONCE(call->ack_lost_at, ack_lost_at); 450 rxrpc_reduce_call_timer(call, ack_lost_at, nowj, 451 rxrpc_timer_set_for_lost_ack); 452 } 453 } 454 455 if (sp->hdr.seq == 1 && 456 !test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER, 457 &call->flags)) { 458 unsigned long nowj = jiffies, expect_rx_by; 459 460 expect_rx_by = nowj + call->next_rx_timo; 461 WRITE_ONCE(call->expect_rx_by, expect_rx_by); 462 rxrpc_reduce_call_timer(call, expect_rx_by, nowj, 463 rxrpc_timer_set_for_normal); 464 } 465 466 rxrpc_set_keepalive(call); 467 } else { 468 /* Cancel the call if the initial transmission fails, 469 * particularly if that's due to network routing issues that 470 * aren't going away anytime soon. The layer above can arrange 471 * the retransmission. 472 */ 473 if (!test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER, &call->flags)) 474 rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR, 475 RX_USER_ABORT, ret); 476 } 477 478 _leave(" = %d [%u]", ret, call->peer->maxdata); 479 return ret; 480 481 send_fragmentable: 482 /* attempt to send this message with fragmentation enabled */ 483 _debug("send fragment"); 484 485 down_write(&conn->params.local->defrag_sem); 486 487 sp->hdr.serial = serial; 488 smp_wmb(); /* Set serial before timestamp */ 489 skb->tstamp = ktime_get_real(); 490 491 switch (conn->params.local->srx.transport.family) { 492 case AF_INET: 493 opt = IP_PMTUDISC_DONT; 494 ret = kernel_setsockopt(conn->params.local->socket, 495 SOL_IP, IP_MTU_DISCOVER, 496 (char *)&opt, sizeof(opt)); 497 if (ret == 0) { 498 ret = kernel_sendmsg(conn->params.local->socket, &msg, 499 iov, 2, len); 500 conn->params.peer->last_tx_at = ktime_get_seconds(); 501 502 opt = IP_PMTUDISC_DO; 503 kernel_setsockopt(conn->params.local->socket, SOL_IP, 504 IP_MTU_DISCOVER, 505 (char *)&opt, sizeof(opt)); 506 } 507 break; 508 509 #ifdef CONFIG_AF_RXRPC_IPV6 510 case AF_INET6: 511 opt = IPV6_PMTUDISC_DONT; 512 ret = kernel_setsockopt(conn->params.local->socket, 513 SOL_IPV6, IPV6_MTU_DISCOVER, 514 (char *)&opt, sizeof(opt)); 515 if (ret == 0) { 516 ret = kernel_sendmsg(conn->params.local->socket, &msg, 517 iov, 2, len); 518 conn->params.peer->last_tx_at = ktime_get_seconds(); 519 520 opt = IPV6_PMTUDISC_DO; 521 kernel_setsockopt(conn->params.local->socket, 522 SOL_IPV6, IPV6_MTU_DISCOVER, 523 (char *)&opt, sizeof(opt)); 524 } 525 break; 526 #endif 527 } 528 529 if (ret < 0) 530 trace_rxrpc_tx_fail(call->debug_id, serial, ret, 531 rxrpc_tx_point_call_data_frag); 532 else 533 trace_rxrpc_tx_packet(call->debug_id, &whdr, 534 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 * reject packets through the local endpoint 543 */ 544 void rxrpc_reject_packets(struct rxrpc_local *local) 545 { 546 struct sockaddr_rxrpc srx; 547 struct rxrpc_skb_priv *sp; 548 struct rxrpc_wire_header whdr; 549 struct sk_buff *skb; 550 struct msghdr msg; 551 struct kvec iov[2]; 552 size_t size; 553 __be32 code; 554 int ret, ioc; 555 556 _enter("%d", local->debug_id); 557 558 iov[0].iov_base = &whdr; 559 iov[0].iov_len = sizeof(whdr); 560 iov[1].iov_base = &code; 561 iov[1].iov_len = sizeof(code); 562 563 msg.msg_name = &srx.transport; 564 msg.msg_control = NULL; 565 msg.msg_controllen = 0; 566 msg.msg_flags = 0; 567 568 memset(&whdr, 0, sizeof(whdr)); 569 570 while ((skb = skb_dequeue(&local->reject_queue))) { 571 rxrpc_see_skb(skb, rxrpc_skb_rx_seen); 572 sp = rxrpc_skb(skb); 573 574 switch (skb->mark) { 575 case RXRPC_SKB_MARK_REJECT_BUSY: 576 whdr.type = RXRPC_PACKET_TYPE_BUSY; 577 size = sizeof(whdr); 578 ioc = 1; 579 break; 580 case RXRPC_SKB_MARK_REJECT_ABORT: 581 whdr.type = RXRPC_PACKET_TYPE_ABORT; 582 code = htonl(skb->priority); 583 size = sizeof(whdr) + sizeof(code); 584 ioc = 2; 585 break; 586 default: 587 rxrpc_free_skb(skb, rxrpc_skb_rx_freed); 588 continue; 589 } 590 591 if (rxrpc_extract_addr_from_skb(&srx, skb) == 0) { 592 msg.msg_namelen = srx.transport_len; 593 594 whdr.epoch = htonl(sp->hdr.epoch); 595 whdr.cid = htonl(sp->hdr.cid); 596 whdr.callNumber = htonl(sp->hdr.callNumber); 597 whdr.serviceId = htons(sp->hdr.serviceId); 598 whdr.flags = sp->hdr.flags; 599 whdr.flags ^= RXRPC_CLIENT_INITIATED; 600 whdr.flags &= RXRPC_CLIENT_INITIATED; 601 602 ret = kernel_sendmsg(local->socket, &msg, 603 iov, ioc, size); 604 if (ret < 0) 605 trace_rxrpc_tx_fail(local->debug_id, 0, ret, 606 rxrpc_tx_point_reject); 607 else 608 trace_rxrpc_tx_packet(local->debug_id, &whdr, 609 rxrpc_tx_point_reject); 610 } 611 612 rxrpc_free_skb(skb, rxrpc_skb_rx_freed); 613 } 614 615 _leave(""); 616 } 617 618 /* 619 * Send a VERSION reply to a peer as a keepalive. 620 */ 621 void rxrpc_send_keepalive(struct rxrpc_peer *peer) 622 { 623 struct rxrpc_wire_header whdr; 624 struct msghdr msg; 625 struct kvec iov[2]; 626 size_t len; 627 int ret; 628 629 _enter(""); 630 631 msg.msg_name = &peer->srx.transport; 632 msg.msg_namelen = peer->srx.transport_len; 633 msg.msg_control = NULL; 634 msg.msg_controllen = 0; 635 msg.msg_flags = 0; 636 637 whdr.epoch = htonl(peer->local->rxnet->epoch); 638 whdr.cid = 0; 639 whdr.callNumber = 0; 640 whdr.seq = 0; 641 whdr.serial = 0; 642 whdr.type = RXRPC_PACKET_TYPE_VERSION; /* Not client-initiated */ 643 whdr.flags = RXRPC_LAST_PACKET; 644 whdr.userStatus = 0; 645 whdr.securityIndex = 0; 646 whdr._rsvd = 0; 647 whdr.serviceId = 0; 648 649 iov[0].iov_base = &whdr; 650 iov[0].iov_len = sizeof(whdr); 651 iov[1].iov_base = (char *)rxrpc_keepalive_string; 652 iov[1].iov_len = sizeof(rxrpc_keepalive_string); 653 654 len = iov[0].iov_len + iov[1].iov_len; 655 656 _proto("Tx VERSION (keepalive)"); 657 658 ret = kernel_sendmsg(peer->local->socket, &msg, iov, 2, len); 659 if (ret < 0) 660 trace_rxrpc_tx_fail(peer->debug_id, 0, ret, 661 rxrpc_tx_point_version_keepalive); 662 else 663 trace_rxrpc_tx_packet(peer->debug_id, &whdr, 664 rxrpc_tx_point_version_keepalive); 665 666 peer->last_tx_at = ktime_get_seconds(); 667 _leave(""); 668 } 669