output.c 18 KB

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