net/rxrpc/call_event.c

   1 /* Management of Tx window, Tx resend, ACKs and out-of-sequence reception
   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/module.h>
  15 #include <linux/circ_buf.h>
  16 #include <linux/net.h>
  17 #include <linux/skbuff.h>
  18 #include <linux/slab.h>
  19 #include <linux/udp.h>
  20 #include <net/sock.h>
  21 #include <net/af_rxrpc.h>
  22 #include "ar-internal.h"
  23
  24 /*
  25  * Propose a PING ACK be sent.
  26  */
  27 static void rxrpc_propose_ping(struct rxrpc_call *call,
  28                                bool immediate, bool background)
  29 {
  30         if (immediate) {
  31                 if (background &&
  32                     !test_and_set_bit(RXRPC_CALL_EV_PING, &call->events))
  33                         rxrpc_queue_call(call);
  34         } else {
  35                 unsigned long now = jiffies;
  36                 unsigned long ping_at = now + rxrpc_idle_ack_delay;
  37
  38                 if (time_before(ping_at, call->ping_at)) {
  39                         WRITE_ONCE(call->ping_at, ping_at);
  40                         rxrpc_reduce_call_timer(call, ping_at, now,
  41                                                 rxrpc_timer_set_for_ping);
  42                 }
  43         }
  44 }
  45
  46 /*
  47  * propose an ACK be sent
  48  */
  49 static void __rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason,
  50                                 u16 skew, u32 serial, bool immediate,
  51                                 bool background,
  52                                 enum rxrpc_propose_ack_trace why)
  53 {
  54         enum rxrpc_propose_ack_outcome outcome = rxrpc_propose_ack_use;
  55         unsigned long expiry = rxrpc_soft_ack_delay;
  56         s8 prior = rxrpc_ack_priority[ack_reason];
  57
  58         /* Pings are handled specially because we don't want to accidentally
  59          * lose a ping response by subsuming it into a ping.
  60          */
  61         if (ack_reason == RXRPC_ACK_PING) {
  62                 rxrpc_propose_ping(call, immediate, background);
  63                 goto trace;
  64         }
  65
  66         /* Update DELAY, IDLE, REQUESTED and PING_RESPONSE ACK serial
  67          * numbers, but we don't alter the timeout.
  68          */
  69         _debug("prior %u %u vs %u %u",
  70                ack_reason, prior,
  71                call->ackr_reason, rxrpc_ack_priority[call->ackr_reason]);
  72         if (ack_reason == call->ackr_reason) {
  73                 if (RXRPC_ACK_UPDATEABLE & (1 << ack_reason)) {
  74                         outcome = rxrpc_propose_ack_update;
  75                         call->ackr_serial = serial;
  76                         call->ackr_skew = skew;
  77                 }
  78                 if (!immediate)
  79                         goto trace;
  80         } else if (prior > rxrpc_ack_priority[call->ackr_reason]) {
  81                 call->ackr_reason = ack_reason;
  82                 call->ackr_serial = serial;
  83                 call->ackr_skew = skew;
  84         } else {
  85                 outcome = rxrpc_propose_ack_subsume;
  86         }
  87
  88         switch (ack_reason) {
  89         case RXRPC_ACK_REQUESTED:
  90                 if (rxrpc_requested_ack_delay < expiry)
  91                         expiry = rxrpc_requested_ack_delay;
  92                 if (serial == 1)
  93                         immediate = false;
  94                 break;
  95
  96         case RXRPC_ACK_DELAY:
  97                 if (rxrpc_soft_ack_delay < expiry)
  98                         expiry = rxrpc_soft_ack_delay;
  99                 break;
 100
 101         case RXRPC_ACK_IDLE:
 102                 if (rxrpc_idle_ack_delay < expiry)
 103                         expiry = rxrpc_idle_ack_delay;
 104                 break;
 105
 106         default:
 107                 immediate = true;
 108                 break;
 109         }
 110
 111         if (test_bit(RXRPC_CALL_EV_ACK, &call->events)) {
 112                 _debug("already scheduled");
 113         } else if (immediate || expiry == 0) {
 114                 _debug("immediate ACK %lx", call->events);
 115                 if (!test_and_set_bit(RXRPC_CALL_EV_ACK, &call->events) &&
 116                     background)
 117                         rxrpc_queue_call(call);
 118         } else {
 119                 unsigned long now = jiffies, ack_at;
 120
 121                 if (call->peer->rtt_usage > 0)
 122                         ack_at = nsecs_to_jiffies(call->peer->rtt);
 123                 else
 124                         ack_at = expiry;
 125
 126                 ack_at += READ_ONCE(call->tx_backoff);
 127                 ack_at += now;
 128                 if (time_before(ack_at, call->ack_at)) {
 129                         WRITE_ONCE(call->ack_at, ack_at);
 130                         rxrpc_reduce_call_timer(call, ack_at, now,
 131                                                 rxrpc_timer_set_for_ack);
 132                 }
 133         }
 134
 135 trace:
 136         trace_rxrpc_propose_ack(call, why, ack_reason, serial, immediate,
 137                                 background, outcome);
 138 }
 139
 140 /*
 141  * propose an ACK be sent, locking the call structure
 142  */
 143 void rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason,
 144                        u16 skew, u32 serial, bool immediate, bool background,
 145                        enum rxrpc_propose_ack_trace why)
 146 {
 147         spin_lock_bh(&call->lock);
 148         __rxrpc_propose_ACK(call, ack_reason, skew, serial,
 149                             immediate, background, why);
 150         spin_unlock_bh(&call->lock);
 151 }
 152
 153 /*
 154  * Handle congestion being detected by the retransmit timeout.
 155  */
 156 static void rxrpc_congestion_timeout(struct rxrpc_call *call)
 157 {
 158         set_bit(RXRPC_CALL_RETRANS_TIMEOUT, &call->flags);
 159 }
 160
 161 /*
 162  * Perform retransmission of NAK'd and unack'd packets.
 163  */
 164 static void rxrpc_resend(struct rxrpc_call *call, unsigned long now_j)
 165 {
 166         struct sk_buff *skb;
 167         unsigned long resend_at;
 168         rxrpc_seq_t cursor, seq, top;
 169         ktime_t now, max_age, oldest, ack_ts, timeout, min_timeo;
 170         int ix;
 171         u8 annotation, anno_type, retrans = 0, unacked = 0;
 172
 173         _enter("{%d,%d}", call->tx_hard_ack, call->tx_top);
 174
 175         if (call->peer->rtt_usage > 1)
 176                 timeout = ns_to_ktime(call->peer->rtt * 3 / 2);
 177         else
 178                 timeout = ms_to_ktime(rxrpc_resend_timeout);
 179         min_timeo = ns_to_ktime((1000000000 / HZ) * 4);
 180         if (ktime_before(timeout, min_timeo))
 181                 timeout = min_timeo;
 182
 183         now = ktime_get_real();
 184         max_age = ktime_sub(now, timeout);
 185
 186         spin_lock_bh(&call->lock);
 187
 188         cursor = call->tx_hard_ack;
 189         top = call->tx_top;
 190         ASSERT(before_eq(cursor, top));
 191         if (cursor == top)
 192                 goto out_unlock;
 193
 194         /* Scan the packet list without dropping the lock and decide which of
 195          * the packets in the Tx buffer we're going to resend and what the new
 196          * resend timeout will be.
 197          */
 198         trace_rxrpc_resend(call, (cursor + 1) & RXRPC_RXTX_BUFF_MASK);
 199         oldest = now;
 200         for (seq = cursor + 1; before_eq(seq, top); seq++) {
 201                 ix = seq & RXRPC_RXTX_BUFF_MASK;
 202                 annotation = call->rxtx_annotations[ix];
 203                 anno_type = annotation & RXRPC_TX_ANNO_MASK;
 204                 annotation &= ~RXRPC_TX_ANNO_MASK;
 205                 if (anno_type == RXRPC_TX_ANNO_ACK)
 206                         continue;
 207
 208                 skb = call->rxtx_buffer[ix];
 209                 rxrpc_see_skb(skb, rxrpc_skb_tx_seen);
 210
 211                 if (anno_type == RXRPC_TX_ANNO_UNACK) {
 212                         if (ktime_after(skb->tstamp, max_age)) {
 213                                 if (ktime_before(skb->tstamp, oldest))
 214                                         oldest = skb->tstamp;
 215                                 continue;
 216                         }
 217                         if (!(annotation & RXRPC_TX_ANNO_RESENT))
 218                                 unacked++;
 219                 }
 220
 221                 /* Okay, we need to retransmit a packet. */
 222                 call->rxtx_annotations[ix] = RXRPC_TX_ANNO_RETRANS | annotation;
 223                 retrans++;
 224                 trace_rxrpc_retransmit(call, seq, annotation | anno_type,
 225                                        ktime_to_ns(ktime_sub(skb->tstamp, max_age)));
 226         }
 227
 228         resend_at = nsecs_to_jiffies(ktime_to_ns(ktime_sub(now, oldest)));
 229         resend_at += jiffies + rxrpc_resend_timeout;
 230         WRITE_ONCE(call->resend_at, resend_at);
 231
 232         if (unacked)
 233                 rxrpc_congestion_timeout(call);
 234
 235         /* If there was nothing that needed retransmission then it's likely
 236          * that an ACK got lost somewhere.  Send a ping to find out instead of
 237          * retransmitting data.
 238          */
 239         if (!retrans) {
 240                 rxrpc_reduce_call_timer(call, resend_at, now_j,
 241                                         rxrpc_timer_set_for_resend);
 242                 spin_unlock_bh(&call->lock);
 243                 ack_ts = ktime_sub(now, call->acks_latest_ts);
 244                 if (ktime_to_ns(ack_ts) < call->peer->rtt)
 245                         goto out;
 246                 rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, false,
 247                                   rxrpc_propose_ack_ping_for_lost_ack);
 248                 rxrpc_send_ack_packet(call, true, NULL);
 249                 goto out;
 250         }
 251
 252         /* Now go through the Tx window and perform the retransmissions.  We
 253          * have to drop the lock for each send.  If an ACK comes in whilst the
 254          * lock is dropped, it may clear some of the retransmission markers for
 255          * packets that it soft-ACKs.
 256          */
 257         for (seq = cursor + 1; before_eq(seq, top); seq++) {
 258                 ix = seq & RXRPC_RXTX_BUFF_MASK;
 259                 annotation = call->rxtx_annotations[ix];
 260                 anno_type = annotation & RXRPC_TX_ANNO_MASK;
 261                 if (anno_type != RXRPC_TX_ANNO_RETRANS)
 262                         continue;
 263
 264                 skb = call->rxtx_buffer[ix];
 265                 rxrpc_get_skb(skb, rxrpc_skb_tx_got);
 266                 spin_unlock_bh(&call->lock);
 267
 268                 if (rxrpc_send_data_packet(call, skb, true) < 0) {
 269                         rxrpc_free_skb(skb, rxrpc_skb_tx_freed);
 270                         return;
 271                 }
 272
 273                 if (rxrpc_is_client_call(call))
 274                         rxrpc_expose_client_call(call);
 275
 276                 rxrpc_free_skb(skb, rxrpc_skb_tx_freed);
 277                 spin_lock_bh(&call->lock);
 278
 279                 /* We need to clear the retransmit state, but there are two
 280                  * things we need to be aware of: A new ACK/NAK might have been
 281                  * received and the packet might have been hard-ACK'd (in which
 282                  * case it will no longer be in the buffer).
 283                  */
 284                 if (after(seq, call->tx_hard_ack)) {
 285                         annotation = call->rxtx_annotations[ix];
 286                         anno_type = annotation & RXRPC_TX_ANNO_MASK;
 287                         if (anno_type == RXRPC_TX_ANNO_RETRANS ||
 288                             anno_type == RXRPC_TX_ANNO_NAK) {
 289                                 annotation &= ~RXRPC_TX_ANNO_MASK;
 290                                 annotation |= RXRPC_TX_ANNO_UNACK;
 291                         }
 292                         annotation |= RXRPC_TX_ANNO_RESENT;
 293                         call->rxtx_annotations[ix] = annotation;
 294                 }
 295
 296                 if (after(call->tx_hard_ack, seq))
 297                         seq = call->tx_hard_ack;
 298         }
 299
 300 out_unlock:
 301         spin_unlock_bh(&call->lock);
 302 out:
 303         _leave("");
 304 }
 305
 306 /*
 307  * Handle retransmission and deferred ACK/abort generation.
 308  */
 309 void rxrpc_process_call(struct work_struct *work)
 310 {
 311         struct rxrpc_call *call =
 312                 container_of(work, struct rxrpc_call, processor);
 313         rxrpc_serial_t *send_ack;
 314         unsigned long now, next, t;
 315         unsigned int iterations = 0;
 316
 317         rxrpc_see_call(call);
 318
 319         //printk("\n--------------------\n");
 320         _enter("{%d,%s,%lx}",
 321                call->debug_id, rxrpc_call_states[call->state], call->events);
 322
 323 recheck_state:
 324         /* Limit the number of times we do this before returning to the manager */
 325         iterations++;
 326         if (iterations > 5)
 327                 goto requeue;
 328
 329         if (test_and_clear_bit(RXRPC_CALL_EV_ABORT, &call->events)) {
 330                 rxrpc_send_abort_packet(call);
 331                 goto recheck_state;
 332         }
 333
 334         if (call->state == RXRPC_CALL_COMPLETE) {
 335                 del_timer_sync(&call->timer);
 336                 rxrpc_notify_socket(call);
 337                 goto out_put;
 338         }
 339
 340         /* Work out if any timeouts tripped */
 341         now = jiffies;
 342         t = READ_ONCE(call->expect_rx_by);
 343         if (time_after_eq(now, t)) {
 344                 trace_rxrpc_timer(call, rxrpc_timer_exp_normal, now);
 345                 set_bit(RXRPC_CALL_EV_EXPIRED, &call->events);
 346         }
 347
 348         t = READ_ONCE(call->expect_req_by);
 349         if (call->state == RXRPC_CALL_SERVER_RECV_REQUEST &&
 350             time_after_eq(now, t)) {
 351                 trace_rxrpc_timer(call, rxrpc_timer_exp_idle, now);
 352                 set_bit(RXRPC_CALL_EV_EXPIRED, &call->events);
 353         }
 354
 355         t = READ_ONCE(call->expect_term_by);
 356         if (time_after_eq(now, t)) {
 357                 trace_rxrpc_timer(call, rxrpc_timer_exp_hard, now);
 358                 set_bit(RXRPC_CALL_EV_EXPIRED, &call->events);
 359         }
 360
 361         t = READ_ONCE(call->ack_at);
 362         if (time_after_eq(now, t)) {
 363                 trace_rxrpc_timer(call, rxrpc_timer_exp_ack, now);
 364                 cmpxchg(&call->ack_at, t, now + MAX_JIFFY_OFFSET);
 365                 set_bit(RXRPC_CALL_EV_ACK, &call->events);
 366         }
 367
 368         t = READ_ONCE(call->ack_lost_at);
 369         if (time_after_eq(now, t)) {
 370                 trace_rxrpc_timer(call, rxrpc_timer_exp_lost_ack, now);
 371                 cmpxchg(&call->ack_lost_at, t, now + MAX_JIFFY_OFFSET);
 372                 set_bit(RXRPC_CALL_EV_ACK_LOST, &call->events);
 373         }
 374
 375         t = READ_ONCE(call->keepalive_at);
 376         if (time_after_eq(now, t)) {
 377                 trace_rxrpc_timer(call, rxrpc_timer_exp_keepalive, now);
 378                 cmpxchg(&call->keepalive_at, t, now + MAX_JIFFY_OFFSET);
 379                 rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, true,
 380                                   rxrpc_propose_ack_ping_for_keepalive);
 381                 set_bit(RXRPC_CALL_EV_PING, &call->events);
 382         }
 383
 384         t = READ_ONCE(call->ping_at);
 385         if (time_after_eq(now, t)) {
 386                 trace_rxrpc_timer(call, rxrpc_timer_exp_ping, now);
 387                 cmpxchg(&call->ping_at, t, now + MAX_JIFFY_OFFSET);
 388                 set_bit(RXRPC_CALL_EV_PING, &call->events);
 389         }
 390
 391         t = READ_ONCE(call->resend_at);
 392         if (time_after_eq(now, t)) {
 393                 trace_rxrpc_timer(call, rxrpc_timer_exp_resend, now);
 394                 cmpxchg(&call->resend_at, t, now + MAX_JIFFY_OFFSET);
 395                 set_bit(RXRPC_CALL_EV_RESEND, &call->events);
 396         }
 397
 398         /* Process events */
 399         if (test_and_clear_bit(RXRPC_CALL_EV_EXPIRED, &call->events)) {
 400                 if (test_bit(RXRPC_CALL_RX_HEARD, &call->flags) &&
 401                     (int)call->conn->hi_serial - (int)call->rx_serial > 0) {
 402                         trace_rxrpc_call_reset(call);
 403                         rxrpc_abort_call("EXP", call, 0, RX_USER_ABORT, -ECONNRESET);
 404                 } else {
 405                         rxrpc_abort_call("EXP", call, 0, RX_USER_ABORT, -ETIME);
 406                 }
 407                 set_bit(RXRPC_CALL_EV_ABORT, &call->events);
 408                 goto recheck_state;
 409         }
 410
 411         send_ack = NULL;
 412         if (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events)) {
 413                 call->acks_lost_top = call->tx_top;
 414                 rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, false,
 415                                   rxrpc_propose_ack_ping_for_lost_ack);
 416                 send_ack = &call->acks_lost_ping;
 417         }
 418
 419         if (test_and_clear_bit(RXRPC_CALL_EV_ACK, &call->events) ||
 420             send_ack) {
 421                 if (call->ackr_reason) {
 422                         rxrpc_send_ack_packet(call, false, send_ack);
 423                         goto recheck_state;
 424                 }
 425         }
 426
 427         if (test_and_clear_bit(RXRPC_CALL_EV_PING, &call->events)) {
 428                 rxrpc_send_ack_packet(call, true, NULL);
 429                 goto recheck_state;
 430         }
 431
 432         if (test_and_clear_bit(RXRPC_CALL_EV_RESEND, &call->events)) {
 433                 rxrpc_resend(call, now);
 434                 goto recheck_state;
 435         }
 436
 437         /* Make sure the timer is restarted */
 438         next = call->expect_rx_by;
 439
 440 #define set(T) { t = READ_ONCE(T); if (time_before(t, next)) next = t; }
 441
 442         set(call->expect_req_by);
 443         set(call->expect_term_by);
 444         set(call->ack_at);
 445         set(call->ack_lost_at);
 446         set(call->resend_at);
 447         set(call->keepalive_at);
 448         set(call->ping_at);
 449
 450         now = jiffies;
 451         if (time_after_eq(now, next))
 452                 goto recheck_state;
 453
 454         rxrpc_reduce_call_timer(call, next, now, rxrpc_timer_restart);
 455
 456         /* other events may have been raised since we started checking */
 457         if (call->events && call->state < RXRPC_CALL_COMPLETE)
 458                 goto requeue;
 459
 460 out_put:
 461         rxrpc_put_call(call, rxrpc_call_put);
 462 out:
 463         _leave("");
 464         return;
 465
 466 requeue:
 467         __rxrpc_queue_call(call);
 468         goto out;
 469 }