rxrpc: Convert rxrpc_txbuf::flags into a mask and don't use atomics

Convert the transmission buffer flags into a mask and use | and & rather
than bitops functions (atomic ops are not required as only the I/O thread
can manipulate them once submitted for transmission).

The bottom byte can then correspond directly to the Rx protocol header
flags.

Signed-off-by: David Howells <dhowells@redhat.com>
cc: Marc Dionne <marc.dionne@auristor.com>
cc: "David S. Miller" <davem@davemloft.net>
cc: Eric Dumazet <edumazet@google.com>
cc: Jakub Kicinski <kuba@kernel.org>
cc: Paolo Abeni <pabeni@redhat.com>
cc: linux-afs@lists.infradead.org
cc: netdev@vger.kernel.org

diff --git a/include/trace/events/rxrpc.h b/include/trace/events/rxrpc.h
index 9add56980485eb4318e3e8b56d521aa0e8720f97..33888f688325b84e19da0a2ee6345d82b2c979a8 100644 (file)
--- a/include/trace/events/rxrpc.h
+++ b/include/trace/events/rxrpc.h
@@ -1084,9 +1084,9 @@ TRACE_EVENT(rxrpc_tx_packet,
 
 TRACE_EVENT(rxrpc_tx_data,
            TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,
-                    rxrpc_serial_t serial, u8 flags, bool retrans, bool lose),
+                    rxrpc_serial_t serial, unsigned int flags, bool lose),
 
-           TP_ARGS(call, seq, serial, flags, retrans, lose),
+           TP_ARGS(call, seq, serial, flags, lose),
 
            TP_STRUCT__entry(
                    __field(unsigned int,       call)
@@ -1094,8 +1094,7 @@ TRACE_EVENT(rxrpc_tx_data,
                    __field(rxrpc_serial_t,     serial)
                    __field(u32,                cid)
                    __field(u32,                call_id)
-                   __field(u8,                 flags)
-                   __field(bool,               retrans)
+                   __field(u16,                flags)
                    __field(bool,               lose)
                             ),
 
@@ -1106,7 +1105,6 @@ TRACE_EVENT(rxrpc_tx_data,
                    __entry->seq = seq;
                    __entry->serial = serial;
                    __entry->flags = flags;
-                   __entry->retrans = retrans;
                    __entry->lose = lose;
                           ),
 
@@ -1116,8 +1114,8 @@ TRACE_EVENT(rxrpc_tx_data,
                      __entry->call_id,
                      __entry->serial,
                      __entry->seq,
-                     __entry->flags,
-                     __entry->retrans ? " *RETRANS*" : "",
+                     __entry->flags & RXRPC_TXBUF_WIRE_FLAGS,
+                     __entry->flags & RXRPC_TXBUF_RESENT ? " *RETRANS*" : "",
                      __entry->lose ? " *LOSE*" : "")
            );
 

diff --git a/net/rxrpc/ar-internal.h b/net/rxrpc/ar-internal.h
index f761257558101b66e2fb2c2d9fe8d2268ad10825..54d1dc97cb0f7dd3e8adf828ddee73e90300faf0 100644 (file)
--- a/net/rxrpc/ar-internal.h
+++ b/net/rxrpc/ar-internal.h
@@ -800,9 +800,9 @@ struct rxrpc_txbuf {
        unsigned int            len;            /* Amount of data in buffer */
        unsigned int            space;          /* Remaining data space */
        unsigned int            offset;         /* Offset of fill point */
-       unsigned long           flags;
-#define RXRPC_TXBUF_LAST       0               /* Set if last packet in Tx phase */
-#define RXRPC_TXBUF_RESENT     1               /* Set if has been resent */
+       unsigned int            flags;
+#define RXRPC_TXBUF_WIRE_FLAGS 0xff            /* The wire protocol flags */
+#define RXRPC_TXBUF_RESENT     0x100           /* Set if has been resent */
        u8 /*enum rxrpc_propose_ack_trace*/ ack_why;    /* If ack, why */
        struct {
                /* The packet for encrypting and DMA'ing.  We align it such
@@ -822,7 +822,7 @@ struct rxrpc_txbuf {
 
 static inline bool rxrpc_sending_to_server(const struct rxrpc_txbuf *txb)
 {
-       return txb->wire.flags & RXRPC_CLIENT_INITIATED;
+       return txb->flags & RXRPC_CLIENT_INITIATED;
 }
 
 static inline bool rxrpc_sending_to_client(const struct rxrpc_txbuf *txb)

diff --git a/net/rxrpc/call_event.c b/net/rxrpc/call_event.c
index a4c3099767198e7812cbf60a1d1c975e9da86129..77eacbfc5d456bcd22b8524cd07eaad89bf8bb3b 100644 (file)
--- a/net/rxrpc/call_event.c
+++ b/net/rxrpc/call_event.c
@@ -84,7 +84,7 @@ void rxrpc_send_ACK(struct rxrpc_call *call, u8 ack_reason,
        txb->ack_why            = why;
        txb->wire.seq           = 0;
        txb->wire.type          = RXRPC_PACKET_TYPE_ACK;
-       txb->wire.flags         |= RXRPC_SLOW_START_OK;
+       txb->flags              |= RXRPC_SLOW_START_OK;
        txb->ack.bufferSpace    = 0;
        txb->ack.maxSkew        = 0;
        txb->ack.firstPacket    = 0;
@@ -167,7 +167,7 @@ void rxrpc_resend(struct rxrpc_call *call, struct sk_buff *ack_skb)
 
                        if (list_empty(&txb->tx_link)) {
                                list_add_tail(&txb->tx_link, &retrans_queue);
-                               set_bit(RXRPC_TXBUF_RESENT, &txb->flags);
+                               txb->flags |= RXRPC_TXBUF_RESENT;
                        }
 
                        trace_rxrpc_retransmit(call, txb->seq, txb->serial,
@@ -210,7 +210,7 @@ void rxrpc_resend(struct rxrpc_call *call, struct sk_buff *ack_skb)
                unacked = true;
                if (list_empty(&txb->tx_link)) {
                        list_add_tail(&txb->tx_link, &retrans_queue);
-                       set_bit(RXRPC_TXBUF_RESENT, &txb->flags);
+                       txb->flags |= RXRPC_TXBUF_RESENT;
                        rxrpc_inc_stat(call->rxnet, stat_tx_data_retrans);
                }
        }
@@ -320,7 +320,7 @@ static void rxrpc_decant_prepared_tx(struct rxrpc_call *call)
                call->tx_top = txb->seq;
                list_add_tail(&txb->call_link, &call->tx_buffer);
 
-               if (txb->wire.flags & RXRPC_LAST_PACKET)
+               if (txb->flags & RXRPC_LAST_PACKET)
                        rxrpc_close_tx_phase(call);
 
                rxrpc_transmit_one(call, txb);

diff --git a/net/rxrpc/input.c b/net/rxrpc/input.c
index 9691de00ade7522d36174bbe1ab9098c1b52b145..c435b50c33f4a58d31e2baba31b54e469712bb7f 100644 (file)
--- a/net/rxrpc/input.c
+++ b/net/rxrpc/input.c
@@ -212,7 +212,7 @@ static bool rxrpc_rotate_tx_window(struct rxrpc_call *call, rxrpc_seq_t to,
        list_for_each_entry_rcu(txb, &call->tx_buffer, call_link, false) {
                if (before_eq(txb->seq, call->acks_hard_ack))
                        continue;
-               if (test_bit(RXRPC_TXBUF_LAST, &txb->flags)) {
+               if (txb->flags & RXRPC_LAST_PACKET) {
                        set_bit(RXRPC_CALL_TX_LAST, &call->flags);
                        rot_last = true;
                }

diff --git a/net/rxrpc/output.c b/net/rxrpc/output.c
index bad96a983e12f8baa6e6f1b7e92ae081b2e93514..8344ece5358aebca81a1377da6f38a052e1e3e3c 100644 (file)
--- a/net/rxrpc/output.c
+++ b/net/rxrpc/output.c
@@ -205,7 +205,8 @@ int rxrpc_send_ack_packet(struct rxrpc_call *call, struct rxrpc_txbuf *txb)
        msg.msg_flags   = 0;
 
        if (txb->ack.reason == RXRPC_ACK_PING)
-               txb->wire.flags |= RXRPC_REQUEST_ACK;
+               txb->flags |= RXRPC_REQUEST_ACK;
+       txb->wire.flags = txb->flags & RXRPC_TXBUF_WIRE_FLAGS;
 
        n = rxrpc_fill_out_ack(conn, call, txb, &rwind);
        if (n == 0)
@@ -239,7 +240,7 @@ int rxrpc_send_ack_packet(struct rxrpc_call *call, struct rxrpc_txbuf *txb)
        } else {
                trace_rxrpc_tx_packet(call->debug_id, &txb->wire,
                                      rxrpc_tx_point_call_ack);
-               if (txb->wire.flags & RXRPC_REQUEST_ACK)
+               if (txb->flags & RXRPC_REQUEST_ACK)
                        call->peer->rtt_last_req = ktime_get_real();
        }
        rxrpc_tx_backoff(call, ret);
@@ -357,13 +358,13 @@ int rxrpc_send_data_packet(struct rxrpc_call *call, struct rxrpc_txbuf *txb)
         * 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.
         */
-       if (txb->wire.flags & RXRPC_REQUEST_ACK)
+       if (txb->flags & RXRPC_REQUEST_ACK)
                why = rxrpc_reqack_already_on;
-       else if (test_bit(RXRPC_TXBUF_LAST, &txb->flags) && rxrpc_sending_to_client(txb))
+       else if ((txb->flags & RXRPC_LAST_PACKET) && rxrpc_sending_to_client(txb))
                why = rxrpc_reqack_no_srv_last;
        else if (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events))
                why = rxrpc_reqack_ack_lost;
-       else if (test_bit(RXRPC_TXBUF_RESENT, &txb->flags))
+       else if (txb->flags & RXRPC_TXBUF_RESENT)
                why = rxrpc_reqack_retrans;
        else if (call->cong_mode == RXRPC_CALL_SLOW_START && call->cong_cwnd <= 2)
                why = rxrpc_reqack_slow_start;
@@ -379,7 +380,7 @@ int rxrpc_send_data_packet(struct rxrpc_call *call, struct rxrpc_txbuf *txb)
        rxrpc_inc_stat(call->rxnet, stat_why_req_ack[why]);
        trace_rxrpc_req_ack(call->debug_id, txb->seq, why);
        if (why != rxrpc_reqack_no_srv_last)
-               txb->wire.flags |= RXRPC_REQUEST_ACK;
+               txb->flags |= RXRPC_REQUEST_ACK;
 dont_set_request_ack:
 
        if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS)) {
@@ -387,15 +388,12 @@ dont_set_request_ack:
                if ((lose++ & 7) == 7) {
                        ret = 0;
                        trace_rxrpc_tx_data(call, txb->seq, txb->serial,
-                                           txb->wire.flags,
-                                           test_bit(RXRPC_TXBUF_RESENT, &txb->flags),
-                                           true);
+                                           txb->flags, true);
                        goto done;
                }
        }
 
-       trace_rxrpc_tx_data(call, txb->seq, txb->serial, txb->wire.flags,
-                           test_bit(RXRPC_TXBUF_RESENT, &txb->flags), false);
+       trace_rxrpc_tx_data(call, txb->seq, txb->serial, txb->flags, false);
 
        /* Track what we've attempted to transmit at least once so that the
         * retransmission algorithm doesn't try to resend what we haven't sent
@@ -411,8 +409,9 @@ dont_set_request_ack:
        if (txb->len >= call->peer->maxdata)
                goto send_fragmentable;
 
+       txb->wire.flags = txb->flags & RXRPC_TXBUF_WIRE_FLAGS;
        txb->last_sent = ktime_get_real();
-       if (txb->wire.flags & RXRPC_REQUEST_ACK)
+       if (txb->flags & RXRPC_REQUEST_ACK)
                rtt_slot = rxrpc_begin_rtt_probe(call, txb->serial, rxrpc_rtt_tx_data);
 
        /* send the packet by UDP
@@ -442,7 +441,7 @@ dont_set_request_ack:
 done:
        if (ret >= 0) {
                call->tx_last_sent = txb->last_sent;
-               if (txb->wire.flags & RXRPC_REQUEST_ACK) {
+               if (txb->flags & RXRPC_REQUEST_ACK) {
                        call->peer->rtt_last_req = txb->last_sent;
                        if (call->peer->rtt_count > 1) {
                                unsigned long nowj = jiffies, ack_lost_at;
@@ -486,7 +485,7 @@ send_fragmentable:
        _debug("send fragment");
 
        txb->last_sent = ktime_get_real();
-       if (txb->wire.flags & RXRPC_REQUEST_ACK)
+       if (txb->flags & RXRPC_REQUEST_ACK)
                rtt_slot = rxrpc_begin_rtt_probe(call, txb->serial, rxrpc_rtt_tx_data);
 
        switch (conn->local->srx.transport.family) {

diff --git a/net/rxrpc/sendmsg.c b/net/rxrpc/sendmsg.c
index 5677d5690a0223c168612c88fe817c736746ad28..25c7c1d4f4c6df4f96ab997ff2e0a6ce0fc2cab6 100644 (file)
--- a/net/rxrpc/sendmsg.c
+++ b/net/rxrpc/sendmsg.c
@@ -240,7 +240,7 @@ static void rxrpc_queue_packet(struct rxrpc_sock *rx, struct rxrpc_call *call,
                               rxrpc_notify_end_tx_t notify_end_tx)
 {
        rxrpc_seq_t seq = txb->seq;
-       bool last = test_bit(RXRPC_TXBUF_LAST, &txb->flags), poke;
+       bool poke, last = txb->flags & RXRPC_LAST_PACKET;
 
        rxrpc_inc_stat(call->rxnet, stat_tx_data);
 
@@ -394,13 +394,11 @@ reload:
                /* add the packet to the send queue if it's now full */
                if (!txb->space ||
                    (msg_data_left(msg) == 0 && !more)) {
-                       if (msg_data_left(msg) == 0 && !more) {
-                               txb->wire.flags |= RXRPC_LAST_PACKET;
-                               __set_bit(RXRPC_TXBUF_LAST, &txb->flags);
-                       }
+                       if (msg_data_left(msg) == 0 && !more)
+                               txb->flags |= RXRPC_LAST_PACKET;
                        else if (call->tx_top - call->acks_hard_ack <
                                 call->tx_winsize)
-                               txb->wire.flags |= RXRPC_MORE_PACKETS;
+                               txb->flags |= RXRPC_MORE_PACKETS;
 
                        ret = call->security->secure_packet(call, txb);
                        if (ret < 0)

diff --git a/net/rxrpc/txbuf.c b/net/rxrpc/txbuf.c
index f2903c81cf5b438e14ef7768a011198389fd66ae..48d5a8f644e5bbf0b9333718331fa63463f1b777 100644 (file)
--- a/net/rxrpc/txbuf.c
+++ b/net/rxrpc/txbuf.c
@@ -31,7 +31,7 @@ struct rxrpc_txbuf *rxrpc_alloc_txbuf(struct rxrpc_call *call, u8 packet_type,
                txb->space              = sizeof(txb->data);
                txb->len                = 0;
                txb->offset             = 0;
-               txb->flags              = 0;
+               txb->flags              = call->conn->out_clientflag;
                txb->ack_why            = 0;
                txb->seq                = call->tx_prepared + 1;
                txb->serial             = 0;
@@ -40,7 +40,7 @@ struct rxrpc_txbuf *rxrpc_alloc_txbuf(struct rxrpc_call *call, u8 packet_type,
                txb->wire.callNumber    = htonl(call->call_id);
                txb->wire.seq           = htonl(txb->seq);
                txb->wire.type          = packet_type;
-               txb->wire.flags         = call->conn->out_clientflag;
+               txb->wire.flags         = 0;
                txb->wire.userStatus    = 0;
                txb->wire.securityIndex = call->security_ix;
                txb->wire._rsvd         = 0;