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