rxrpc: Drop rxrpc_conn_parameters from rxrpc_connection and rxrpc_bundle

Remove the rxrpc_conn_parameters struct from the rxrpc_connection and
rxrpc_bundle structs and emplace the members directly.  These are going to
get filled in from the rxrpc_call struct in future.

Signed-off-by: David Howells <dhowells@redhat.com>
cc: Marc Dionne <marc.dionne@auristor.com>
cc: linux-afs@lists.infradead.org

diff --git a/net/rxrpc/ar-internal.h b/net/rxrpc/ar-internal.h
index 36ece1e..7c48b01 100644 (file)
--- a/net/rxrpc/ar-internal.h
+++ b/net/rxrpc/ar-internal.h
@@ -403,12 +403,18 @@ enum rxrpc_conn_proto_state {
  * RxRPC client connection bundle.
  */
 struct rxrpc_bundle {
-       struct rxrpc_conn_parameters params;
+       struct rxrpc_local      *local;         /* Representation of local endpoint */
+       struct rxrpc_peer       *peer;          /* Remote endpoint */
+       struct key              *key;           /* Security details */
        refcount_t              ref;
        atomic_t                active;         /* Number of active users */
        unsigned int            debug_id;
+       u32                     security_level; /* Security level selected */
+       u16                     service_id;     /* Service ID for this connection */
        bool                    try_upgrade;    /* True if the bundle is attempting upgrade */
        bool                    alloc_conn;     /* True if someone's getting a conn */
+       bool                    exclusive;      /* T if conn is exclusive */
+       bool                    upgrade;        /* T if service ID can be upgraded */
        short                   alloc_error;    /* Error from last conn allocation */
        spinlock_t              channel_lock;
        struct rb_node          local_node;     /* Node in local->client_conns */
@@ -424,7 +430,9 @@ struct rxrpc_bundle {
  */
 struct rxrpc_connection {
        struct rxrpc_conn_proto proto;
-       struct rxrpc_conn_parameters params;
+       struct rxrpc_local      *local;         /* Representation of local endpoint */
+       struct rxrpc_peer       *peer;          /* Remote endpoint */
+       struct key              *key;           /* Security details */
 
        refcount_t              ref;
        struct rcu_head         rcu;
@@ -471,9 +479,13 @@ struct rxrpc_connection {
        atomic_t                serial;         /* packet serial number counter */
        unsigned int            hi_serial;      /* highest serial number received */
        u32                     service_id;     /* Service ID, possibly upgraded */
+       u32                     security_level; /* Security level selected */
        u8                      security_ix;    /* security type */
        u8                      out_clientflag; /* RXRPC_CLIENT_INITIATED if we are client */
        u8                      bundle_shift;   /* Index into bundle->avail_chans */
+       bool                    exclusive;      /* T if conn is exclusive */
+       bool                    upgrade;        /* T if service ID can be upgraded */
+       u16                     orig_service_id; /* Originally requested service ID */
        short                   error;          /* Local error code */
 };
 

diff --git a/net/rxrpc/call_accept.c b/net/rxrpc/call_accept.c
index 48790ee..4888959 100644 (file)
--- a/net/rxrpc/call_accept.c
+++ b/net/rxrpc/call_accept.c
@@ -305,8 +305,8 @@ static struct rxrpc_call *rxrpc_alloc_incoming_call(struct rxrpc_sock *rx,
                b->conn_backlog[conn_tail] = NULL;
                smp_store_release(&b->conn_backlog_tail,
                                  (conn_tail + 1) & (RXRPC_BACKLOG_MAX - 1));
-               conn->params.local = rxrpc_get_local(local);
-               conn->params.peer = peer;
+               conn->local = rxrpc_get_local(local);
+               conn->peer = peer;
                rxrpc_see_connection(conn);
                rxrpc_new_incoming_connection(rx, conn, sec, skb);
        } else {
@@ -323,7 +323,7 @@ static struct rxrpc_call *rxrpc_alloc_incoming_call(struct rxrpc_sock *rx,
        call->conn = conn;
        call->security = conn->security;
        call->security_ix = conn->security_ix;
-       call->peer = rxrpc_get_peer(conn->params.peer);
+       call->peer = rxrpc_get_peer(conn->peer);
        call->cong_ssthresh = call->peer->cong_ssthresh;
        call->tx_last_sent = ktime_get_real();
        return call;

diff --git a/net/rxrpc/call_event.c b/net/rxrpc/call_event.c
index 349f3df..b17ed37 100644 (file)
--- a/net/rxrpc/call_event.c
+++ b/net/rxrpc/call_event.c
@@ -69,7 +69,7 @@ void rxrpc_propose_delay_ACK(struct rxrpc_call *call, rxrpc_serial_t serial,
 void rxrpc_send_ACK(struct rxrpc_call *call, u8 ack_reason,
                    rxrpc_serial_t serial, enum rxrpc_propose_ack_trace why)
 {
-       struct rxrpc_local *local = call->conn->params.local;
+       struct rxrpc_local *local = call->conn->local;
        struct rxrpc_txbuf *txb;
 
        if (test_bit(RXRPC_CALL_DISCONNECTED, &call->flags))

diff --git a/net/rxrpc/call_object.c b/net/rxrpc/call_object.c
index e36a317..59928f0 100644 (file)
--- a/net/rxrpc/call_object.c
+++ b/net/rxrpc/call_object.c
@@ -417,9 +417,9 @@ void rxrpc_incoming_call(struct rxrpc_sock *rx,
        conn->channels[chan].call_id = call->call_id;
        rcu_assign_pointer(conn->channels[chan].call, call);
 
-       spin_lock(&conn->params.peer->lock);
-       hlist_add_head_rcu(&call->error_link, &conn->params.peer->error_targets);
-       spin_unlock(&conn->params.peer->lock);
+       spin_lock(&conn->peer->lock);
+       hlist_add_head_rcu(&call->error_link, &conn->peer->error_targets);
+       spin_unlock(&conn->peer->lock);
 
        rxrpc_start_call_timer(call);
        _leave("");

diff --git a/net/rxrpc/conn_client.c b/net/rxrpc/conn_client.c
index 2b76fbf..71404b3 100644 (file)
--- a/net/rxrpc/conn_client.c
+++ b/net/rxrpc/conn_client.c
@@ -51,7 +51,7 @@ static void rxrpc_deactivate_bundle(struct rxrpc_bundle *bundle);
 static int rxrpc_get_client_connection_id(struct rxrpc_connection *conn,
                                          gfp_t gfp)
 {
-       struct rxrpc_net *rxnet = conn->params.local->rxnet;
+       struct rxrpc_net *rxnet = conn->local->rxnet;
        int id;
 
        _enter("");
@@ -122,8 +122,13 @@ static struct rxrpc_bundle *rxrpc_alloc_bundle(struct rxrpc_conn_parameters *cp,
 
        bundle = kzalloc(sizeof(*bundle), gfp);
        if (bundle) {
-               bundle->params = *cp;
-               rxrpc_get_peer(bundle->params.peer);
+               bundle->local           = cp->local;
+               bundle->peer            = rxrpc_get_peer(cp->peer);
+               bundle->key             = cp->key;
+               bundle->exclusive       = cp->exclusive;
+               bundle->upgrade         = cp->upgrade;
+               bundle->service_id      = cp->service_id;
+               bundle->security_level  = cp->security_level;
                refcount_set(&bundle->ref, 1);
                atomic_set(&bundle->active, 1);
                spin_lock_init(&bundle->channel_lock);
@@ -140,7 +145,7 @@ struct rxrpc_bundle *rxrpc_get_bundle(struct rxrpc_bundle *bundle)
 
 static void rxrpc_free_bundle(struct rxrpc_bundle *bundle)
 {
-       rxrpc_put_peer(bundle->params.peer);
+       rxrpc_put_peer(bundle->peer);
        kfree(bundle);
 }
 
@@ -164,7 +169,7 @@ static struct rxrpc_connection *
 rxrpc_alloc_client_connection(struct rxrpc_bundle *bundle, gfp_t gfp)
 {
        struct rxrpc_connection *conn;
-       struct rxrpc_net *rxnet = bundle->params.local->rxnet;
+       struct rxrpc_net *rxnet = bundle->local->rxnet;
        int ret;
 
        _enter("");
@@ -177,10 +182,16 @@ rxrpc_alloc_client_connection(struct rxrpc_bundle *bundle, gfp_t gfp)
 
        refcount_set(&conn->ref, 1);
        conn->bundle            = bundle;
-       conn->params            = bundle->params;
+       conn->local             = bundle->local;
+       conn->peer              = bundle->peer;
+       conn->key               = bundle->key;
+       conn->exclusive         = bundle->exclusive;
+       conn->upgrade           = bundle->upgrade;
+       conn->orig_service_id   = bundle->service_id;
+       conn->security_level    = bundle->security_level;
        conn->out_clientflag    = RXRPC_CLIENT_INITIATED;
        conn->state             = RXRPC_CONN_CLIENT;
-       conn->service_id        = conn->params.service_id;
+       conn->service_id        = conn->orig_service_id;
 
        ret = rxrpc_get_client_connection_id(conn, gfp);
        if (ret < 0)
@@ -196,9 +207,9 @@ rxrpc_alloc_client_connection(struct rxrpc_bundle *bundle, gfp_t gfp)
        write_unlock(&rxnet->conn_lock);
 
        rxrpc_get_bundle(bundle);
-       rxrpc_get_peer(conn->params.peer);
-       rxrpc_get_local(conn->params.local);
-       key_get(conn->params.key);
+       rxrpc_get_peer(conn->peer);
+       rxrpc_get_local(conn->local);
+       key_get(conn->key);
 
        trace_rxrpc_conn(conn->debug_id, rxrpc_conn_new_client,
                         refcount_read(&conn->ref),
@@ -228,7 +239,7 @@ static bool rxrpc_may_reuse_conn(struct rxrpc_connection *conn)
        if (!conn)
                goto dont_reuse;
 
-       rxnet = conn->params.local->rxnet;
+       rxnet = conn->local->rxnet;
        if (test_bit(RXRPC_CONN_DONT_REUSE, &conn->flags))
                goto dont_reuse;
 
@@ -285,7 +296,7 @@ static struct rxrpc_bundle *rxrpc_look_up_bundle(struct rxrpc_conn_parameters *c
        while (p) {
                bundle = rb_entry(p, struct rxrpc_bundle, local_node);
 
-#define cmp(X) ((long)bundle->params.X - (long)cp->X)
+#define cmp(X) ((long)bundle->X - (long)cp->X)
                diff = (cmp(peer) ?:
                        cmp(key) ?:
                        cmp(security_level) ?:
@@ -314,7 +325,7 @@ static struct rxrpc_bundle *rxrpc_look_up_bundle(struct rxrpc_conn_parameters *c
                parent = *pp;
                bundle = rb_entry(parent, struct rxrpc_bundle, local_node);
 
-#define cmp(X) ((long)bundle->params.X - (long)cp->X)
+#define cmp(X) ((long)bundle->X - (long)cp->X)
                diff = (cmp(peer) ?:
                        cmp(key) ?:
                        cmp(security_level) ?:
@@ -532,7 +543,7 @@ static void rxrpc_activate_one_channel(struct rxrpc_connection *conn,
 
        rxrpc_see_call(call);
        list_del_init(&call->chan_wait_link);
-       call->peer      = rxrpc_get_peer(conn->params.peer);
+       call->peer      = rxrpc_get_peer(conn->peer);
        call->conn      = rxrpc_get_connection(conn);
        call->cid       = conn->proto.cid | channel;
        call->call_id   = call_id;
@@ -569,7 +580,7 @@ static void rxrpc_activate_one_channel(struct rxrpc_connection *conn,
  */
 static void rxrpc_unidle_conn(struct rxrpc_bundle *bundle, struct rxrpc_connection *conn)
 {
-       struct rxrpc_net *rxnet = bundle->params.local->rxnet;
+       struct rxrpc_net *rxnet = bundle->local->rxnet;
        bool drop_ref;
 
        if (!list_empty(&conn->cache_link)) {
@@ -795,7 +806,7 @@ void rxrpc_disconnect_client_call(struct rxrpc_bundle *bundle, struct rxrpc_call
 {
        struct rxrpc_connection *conn;
        struct rxrpc_channel *chan = NULL;
-       struct rxrpc_net *rxnet = bundle->params.local->rxnet;
+       struct rxrpc_net *rxnet = bundle->local->rxnet;
        unsigned int channel;
        bool may_reuse;
        u32 cid;
@@ -936,11 +947,11 @@ static void rxrpc_unbundle_conn(struct rxrpc_connection *conn)
  */
 static void rxrpc_deactivate_bundle(struct rxrpc_bundle *bundle)
 {
-       struct rxrpc_local *local = bundle->params.local;
+       struct rxrpc_local *local = bundle->local;
        bool need_put = false;
 
        if (atomic_dec_and_lock(&bundle->active, &local->client_bundles_lock)) {
-               if (!bundle->params.exclusive) {
+               if (!bundle->exclusive) {
                        _debug("erase bundle");
                        rb_erase(&bundle->local_node, &local->client_bundles);
                        need_put = true;
@@ -957,7 +968,7 @@ static void rxrpc_deactivate_bundle(struct rxrpc_bundle *bundle)
  */
 static void rxrpc_kill_client_conn(struct rxrpc_connection *conn)
 {
-       struct rxrpc_local *local = conn->params.local;
+       struct rxrpc_local *local = conn->local;
        struct rxrpc_net *rxnet = local->rxnet;
 
        _enter("C=%x", conn->debug_id);
@@ -1036,7 +1047,7 @@ next:
                expiry = rxrpc_conn_idle_client_expiry;
                if (nr_conns > rxrpc_reap_client_connections)
                        expiry = rxrpc_conn_idle_client_fast_expiry;
-               if (conn->params.local->service_closed)
+               if (conn->local->service_closed)
                        expiry = rxrpc_closed_conn_expiry * HZ;
 
                conn_expires_at = conn->idle_timestamp + expiry;
@@ -1110,7 +1121,7 @@ void rxrpc_clean_up_local_conns(struct rxrpc_local *local)
 
        list_for_each_entry_safe(conn, tmp, &rxnet->idle_client_conns,
                                 cache_link) {
-               if (conn->params.local == local) {
+               if (conn->local == local) {
                        trace_rxrpc_client(conn, -1, rxrpc_client_discard);
                        list_move(&conn->cache_link, &graveyard);
                }

diff --git a/net/rxrpc/conn_event.c b/net/rxrpc/conn_event.c
index d5549cb..71ed6b9 100644 (file)
--- a/net/rxrpc/conn_event.c
+++ b/net/rxrpc/conn_event.c
@@ -52,8 +52,8 @@ static void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn,
        if (skb && call_id != sp->hdr.callNumber)
                return;
 
-       msg.msg_name    = &conn->params.peer->srx.transport;
-       msg.msg_namelen = conn->params.peer->srx.transport_len;
+       msg.msg_name    = &conn->peer->srx.transport;
+       msg.msg_namelen = conn->peer->srx.transport_len;
        msg.msg_control = NULL;
        msg.msg_controllen = 0;
        msg.msg_flags   = 0;
@@ -86,8 +86,8 @@ static void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn,
                break;
 
        case RXRPC_PACKET_TYPE_ACK:
-               mtu = conn->params.peer->if_mtu;
-               mtu -= conn->params.peer->hdrsize;
+               mtu = conn->peer->if_mtu;
+               mtu -= conn->peer->hdrsize;
                pkt.ack.bufferSpace     = 0;
                pkt.ack.maxSkew         = htons(skb ? skb->priority : 0);
                pkt.ack.firstPacket     = htonl(chan->last_seq + 1);
@@ -131,8 +131,8 @@ static void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn,
                break;
        }
 
-       ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, ioc, len);
-       conn->params.peer->last_tx_at = ktime_get_seconds();
+       ret = kernel_sendmsg(conn->local->socket, &msg, iov, ioc, len);
+       conn->peer->last_tx_at = ktime_get_seconds();
        if (ret < 0)
                trace_rxrpc_tx_fail(chan->call_debug_id, serial, ret,
                                    rxrpc_tx_point_call_final_resend);
@@ -211,8 +211,8 @@ static int rxrpc_abort_connection(struct rxrpc_connection *conn,
        set_bit(RXRPC_CONN_DONT_REUSE, &conn->flags);
        spin_unlock_bh(&conn->state_lock);
 
-       msg.msg_name    = &conn->params.peer->srx.transport;
-       msg.msg_namelen = conn->params.peer->srx.transport_len;
+       msg.msg_name    = &conn->peer->srx.transport;
+       msg.msg_namelen = conn->peer->srx.transport_len;
        msg.msg_control = NULL;
        msg.msg_controllen = 0;
        msg.msg_flags   = 0;
@@ -241,7 +241,7 @@ static int rxrpc_abort_connection(struct rxrpc_connection *conn,
        rxrpc_abort_calls(conn, RXRPC_CALL_LOCALLY_ABORTED, serial);
        whdr.serial = htonl(serial);
 
-       ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len);
+       ret = kernel_sendmsg(conn->local->socket, &msg, iov, 2, len);
        if (ret < 0) {
                trace_rxrpc_tx_fail(conn->debug_id, serial, ret,
                                    rxrpc_tx_point_conn_abort);
@@ -251,7 +251,7 @@ static int rxrpc_abort_connection(struct rxrpc_connection *conn,
 
        trace_rxrpc_tx_packet(conn->debug_id, &whdr, rxrpc_tx_point_conn_abort);
 
-       conn->params.peer->last_tx_at = ktime_get_seconds();
+       conn->peer->last_tx_at = ktime_get_seconds();
 
        _leave(" = 0");
        return 0;
@@ -330,7 +330,7 @@ static int rxrpc_process_event(struct rxrpc_connection *conn,
                        return ret;
 
                ret = conn->security->init_connection_security(
-                       conn, conn->params.key->payload.data[0]);
+                       conn, conn->key->payload.data[0]);
                if (ret < 0)
                        return ret;
 
@@ -484,9 +484,9 @@ void rxrpc_process_connection(struct work_struct *work)
 
        rxrpc_see_connection(conn);
 
-       if (__rxrpc_use_local(conn->params.local)) {
+       if (__rxrpc_use_local(conn->local)) {
                rxrpc_do_process_connection(conn);
-               rxrpc_unuse_local(conn->params.local);
+               rxrpc_unuse_local(conn->local);
        }
 
        rxrpc_put_connection(conn);

diff --git a/net/rxrpc/conn_object.c b/net/rxrpc/conn_object.c
index d5d1538..ad6e5ee 100644 (file)
--- a/net/rxrpc/conn_object.c
+++ b/net/rxrpc/conn_object.c
@@ -120,10 +120,10 @@ struct rxrpc_connection *rxrpc_find_connection_rcu(struct rxrpc_local *local,
                }
 
                if (conn->proto.epoch != k.epoch ||
-                   conn->params.local != local)
+                   conn->local != local)
                        goto not_found;
 
-               peer = conn->params.peer;
+               peer = conn->peer;
                switch (srx.transport.family) {
                case AF_INET:
                        if (peer->srx.transport.sin.sin_port !=
@@ -231,7 +231,7 @@ void rxrpc_disconnect_call(struct rxrpc_call *call)
  */
 void rxrpc_kill_connection(struct rxrpc_connection *conn)
 {
-       struct rxrpc_net *rxnet = conn->params.local->rxnet;
+       struct rxrpc_net *rxnet = conn->local->rxnet;
 
        ASSERT(!rcu_access_pointer(conn->channels[0].call) &&
               !rcu_access_pointer(conn->channels[1].call) &&
@@ -340,7 +340,7 @@ void rxrpc_put_service_conn(struct rxrpc_connection *conn)
        __refcount_dec(&conn->ref, &r);
        trace_rxrpc_conn(debug_id, rxrpc_conn_put_service, r - 1, here);
        if (r - 1 == 1)
-               rxrpc_set_service_reap_timer(conn->params.local->rxnet,
+               rxrpc_set_service_reap_timer(conn->local->rxnet,
                                             jiffies + rxrpc_connection_expiry);
 }
 
@@ -360,13 +360,13 @@ static void rxrpc_destroy_connection(struct rcu_head *rcu)
        rxrpc_purge_queue(&conn->rx_queue);
 
        conn->security->clear(conn);
-       key_put(conn->params.key);
+       key_put(conn->key);
        rxrpc_put_bundle(conn->bundle);
-       rxrpc_put_peer(conn->params.peer);
+       rxrpc_put_peer(conn->peer);
 
-       if (atomic_dec_and_test(&conn->params.local->rxnet->nr_conns))
-               wake_up_var(&conn->params.local->rxnet->nr_conns);
-       rxrpc_put_local(conn->params.local);
+       if (atomic_dec_and_test(&conn->local->rxnet->nr_conns))
+               wake_up_var(&conn->local->rxnet->nr_conns);
+       rxrpc_put_local(conn->local);
 
        kfree(conn);
        _leave("");
@@ -397,10 +397,10 @@ void rxrpc_service_connection_reaper(struct work_struct *work)
                if (conn->state == RXRPC_CONN_SERVICE_PREALLOC)
                        continue;
 
-               if (rxnet->live && !conn->params.local->dead) {
+               if (rxnet->live && !conn->local->dead) {
                        idle_timestamp = READ_ONCE(conn->idle_timestamp);
                        expire_at = idle_timestamp + rxrpc_connection_expiry * HZ;
-                       if (conn->params.local->service_closed)
+                       if (conn->local->service_closed)
                                expire_at = idle_timestamp + rxrpc_closed_conn_expiry * HZ;
 
                        _debug("reap CONN %d { u=%d,t=%ld }",

diff --git a/net/rxrpc/conn_service.c b/net/rxrpc/conn_service.c
index 75f9030..a3b9186 100644 (file)
--- a/net/rxrpc/conn_service.c
+++ b/net/rxrpc/conn_service.c
@@ -164,7 +164,7 @@ void rxrpc_new_incoming_connection(struct rxrpc_sock *rx,
 
        conn->proto.epoch       = sp->hdr.epoch;
        conn->proto.cid         = sp->hdr.cid & RXRPC_CIDMASK;
-       conn->params.service_id = sp->hdr.serviceId;
+       conn->orig_service_id   = sp->hdr.serviceId;
        conn->service_id        = sp->hdr.serviceId;
        conn->security_ix       = sp->hdr.securityIndex;
        conn->out_clientflag    = 0;
@@ -183,7 +183,7 @@ void rxrpc_new_incoming_connection(struct rxrpc_sock *rx,
                conn->service_id = rx->service_upgrade.to;
 
        /* Make the connection a target for incoming packets. */
-       rxrpc_publish_service_conn(conn->params.peer, conn);
+       rxrpc_publish_service_conn(conn->peer, conn);
 }
 
 /*
@@ -192,7 +192,7 @@ void rxrpc_new_incoming_connection(struct rxrpc_sock *rx,
  */
 void rxrpc_unpublish_service_conn(struct rxrpc_connection *conn)
 {
-       struct rxrpc_peer *peer = conn->params.peer;
+       struct rxrpc_peer *peer = conn->peer;
 
        write_seqlock_bh(&peer->service_conn_lock);
        if (test_and_clear_bit(RXRPC_CONN_IN_SERVICE_CONNS, &conn->flags))

diff --git a/net/rxrpc/input.c b/net/rxrpc/input.c
index e2461f2..44caf88 100644 (file)
--- a/net/rxrpc/input.c
+++ b/net/rxrpc/input.c
@@ -1339,10 +1339,10 @@ int rxrpc_input_packet(struct sock *udp_sk, struct sk_buff *skb)
 
                        if (!test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags))
                                goto reupgrade;
-                       old_id = cmpxchg(&conn->service_id, conn->params.service_id,
+                       old_id = cmpxchg(&conn->service_id, conn->orig_service_id,
                                         sp->hdr.serviceId);
 
-                       if (old_id != conn->params.service_id &&
+                       if (old_id != conn->orig_service_id &&
                            old_id != sp->hdr.serviceId)
                                goto reupgrade;
                }

diff --git a/net/rxrpc/key.c b/net/rxrpc/key.c
index 830eeff..8d53ade 100644 (file)
--- a/net/rxrpc/key.c
+++ b/net/rxrpc/key.c
@@ -513,7 +513,7 @@ int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
        if (ret < 0)
                goto error;
 
-       conn->params.key = key;
+       conn->key = key;
        _leave(" = 0 [%d]", key_serial(key));
        return 0;
 

diff --git a/net/rxrpc/output.c b/net/rxrpc/output.c
index 635acf3..b5d8eac 100644 (file)
--- a/net/rxrpc/output.c
+++ b/net/rxrpc/output.c
@@ -142,8 +142,8 @@ retry:
                txb->ack.reason = RXRPC_ACK_IDLE;
        }
 
-       mtu = conn->params.peer->if_mtu;
-       mtu -= conn->params.peer->hdrsize;
+       mtu = conn->peer->if_mtu;
+       mtu -= conn->peer->hdrsize;
        jmax = rxrpc_rx_jumbo_max;
        qsize = (window - 1) - call->rx_consumed;
        rsize = max_t(int, call->rx_winsize - qsize, 0);
@@ -259,7 +259,7 @@ static int rxrpc_send_ack_packet(struct rxrpc_local *local, struct rxrpc_txbuf *
        txb->ack.previousPacket = htonl(call->rx_highest_seq);
 
        iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, len);
-       ret = do_udp_sendmsg(conn->params.local->socket, &msg, len);
+       ret = do_udp_sendmsg(conn->local->socket, &msg, len);
        call->peer->last_tx_at = ktime_get_seconds();
        if (ret < 0)
                trace_rxrpc_tx_fail(call->debug_id, serial, ret,
@@ -368,8 +368,8 @@ int rxrpc_send_abort_packet(struct rxrpc_call *call)
        pkt.whdr.serial = htonl(serial);
 
        iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, sizeof(pkt));
-       ret = do_udp_sendmsg(conn->params.local->socket, &msg, sizeof(pkt));
-       conn->params.peer->last_tx_at = ktime_get_seconds();
+       ret = do_udp_sendmsg(conn->local->socket, &msg, sizeof(pkt));
+       conn->peer->last_tx_at = ktime_get_seconds();
        if (ret < 0)
                trace_rxrpc_tx_fail(call->debug_id, serial, ret,
                                    rxrpc_tx_point_call_abort);
@@ -473,7 +473,7 @@ dont_set_request_ack:
        if (txb->len >= call->peer->maxdata)
                goto send_fragmentable;
 
-       down_read(&conn->params.local->defrag_sem);
+       down_read(&conn->local->defrag_sem);
 
        txb->last_sent = ktime_get_real();
        if (txb->wire.flags & RXRPC_REQUEST_ACK)
@@ -486,10 +486,10 @@ dont_set_request_ack:
         *     message and update the peer record
         */
        rxrpc_inc_stat(call->rxnet, stat_tx_data_send);
-       ret = do_udp_sendmsg(conn->params.local->socket, &msg, len);
-       conn->params.peer->last_tx_at = ktime_get_seconds();
+       ret = do_udp_sendmsg(conn->local->socket, &msg, len);
+       conn->peer->last_tx_at = ktime_get_seconds();
 
-       up_read(&conn->params.local->defrag_sem);
+       up_read(&conn->local->defrag_sem);
        if (ret < 0) {
                rxrpc_cancel_rtt_probe(call, serial, rtt_slot);
                trace_rxrpc_tx_fail(call->debug_id, serial, ret,
@@ -549,22 +549,22 @@ send_fragmentable:
        /* attempt to send this message with fragmentation enabled */
        _debug("send fragment");
 
-       down_write(&conn->params.local->defrag_sem);
+       down_write(&conn->local->defrag_sem);
 
        txb->last_sent = ktime_get_real();
        if (txb->wire.flags & RXRPC_REQUEST_ACK)
                rtt_slot = rxrpc_begin_rtt_probe(call, serial, rxrpc_rtt_tx_data);
 
-       switch (conn->params.local->srx.transport.family) {
+       switch (conn->local->srx.transport.family) {
        case AF_INET6:
        case AF_INET:
-               ip_sock_set_mtu_discover(conn->params.local->socket->sk,
+               ip_sock_set_mtu_discover(conn->local->socket->sk,
                                         IP_PMTUDISC_DONT);
                rxrpc_inc_stat(call->rxnet, stat_tx_data_send_frag);
-               ret = do_udp_sendmsg(conn->params.local->socket, &msg, len);
-               conn->params.peer->last_tx_at = ktime_get_seconds();
+               ret = do_udp_sendmsg(conn->local->socket, &msg, len);
+               conn->peer->last_tx_at = ktime_get_seconds();
 
-               ip_sock_set_mtu_discover(conn->params.local->socket->sk,
+               ip_sock_set_mtu_discover(conn->local->socket->sk,
                                         IP_PMTUDISC_DO);
                break;
 
@@ -582,7 +582,7 @@ send_fragmentable:
        }
        rxrpc_tx_backoff(call, ret);
 
-       up_write(&conn->params.local->defrag_sem);
+       up_write(&conn->local->defrag_sem);
        goto done;
 }
 

diff --git a/net/rxrpc/proc.c b/net/rxrpc/proc.c
index fae22a8..bb2edf6 100644 (file)
--- a/net/rxrpc/proc.c
+++ b/net/rxrpc/proc.c
@@ -172,9 +172,9 @@ static int rxrpc_connection_seq_show(struct seq_file *seq, void *v)
                goto print;
        }
 
-       sprintf(lbuff, "%pISpc", &conn->params.local->srx.transport);
+       sprintf(lbuff, "%pISpc", &conn->local->srx.transport);
 
-       sprintf(rbuff, "%pISpc", &conn->params.peer->srx.transport);
+       sprintf(rbuff, "%pISpc", &conn->peer->srx.transport);
 print:
        seq_printf(seq,
                   "UDP   %-47.47s %-47.47s %4x %08x %s %3u"
@@ -186,7 +186,7 @@ print:
                   rxrpc_conn_is_service(conn) ? "Svc" : "Clt",
                   refcount_read(&conn->ref),
                   rxrpc_conn_states[conn->state],
-                  key_serial(conn->params.key),
+                  key_serial(conn->key),
                   atomic_read(&conn->serial),
                   conn->hi_serial,
                   conn->channels[0].call_id,

diff --git a/net/rxrpc/rxkad.c b/net/rxrpc/rxkad.c
index 36cf404..d123372 100644 (file)
--- a/net/rxrpc/rxkad.c
+++ b/net/rxrpc/rxkad.c
@@ -103,7 +103,7 @@ static int rxkad_init_connection_security(struct rxrpc_connection *conn,
        struct crypto_sync_skcipher *ci;
        int ret;
 
-       _enter("{%d},{%x}", conn->debug_id, key_serial(conn->params.key));
+       _enter("{%d},{%x}", conn->debug_id, key_serial(conn->key));
 
        conn->security_ix = token->security_index;
 
@@ -118,7 +118,7 @@ static int rxkad_init_connection_security(struct rxrpc_connection *conn,
                                   sizeof(token->kad->session_key)) < 0)
                BUG();
 
-       switch (conn->params.security_level) {
+       switch (conn->security_level) {
        case RXRPC_SECURITY_PLAIN:
        case RXRPC_SECURITY_AUTH:
        case RXRPC_SECURITY_ENCRYPT:
@@ -150,7 +150,7 @@ static int rxkad_how_much_data(struct rxrpc_call *call, size_t remain,
 {
        size_t shdr, buf_size, chunk;
 
-       switch (call->conn->params.security_level) {
+       switch (call->conn->security_level) {
        default:
                buf_size = chunk = min_t(size_t, remain, RXRPC_JUMBO_DATALEN);
                shdr = 0;
@@ -192,7 +192,7 @@ static int rxkad_prime_packet_security(struct rxrpc_connection *conn,
 
        _enter("");
 
-       if (!conn->params.key)
+       if (!conn->key)
                return 0;
 
        tmpbuf = kmalloc(tmpsize, GFP_KERNEL);
@@ -205,7 +205,7 @@ static int rxkad_prime_packet_security(struct rxrpc_connection *conn,
                return -ENOMEM;
        }
 
-       token = conn->params.key->payload.data[0];
+       token = conn->key->payload.data[0];
        memcpy(&iv, token->kad->session_key, sizeof(iv));
 
        tmpbuf[0] = htonl(conn->proto.epoch);
@@ -317,7 +317,7 @@ static int rxkad_secure_packet_encrypt(const struct rxrpc_call *call,
        }
 
        /* encrypt from the session key */
-       token = call->conn->params.key->payload.data[0];
+       token = call->conn->key->payload.data[0];
        memcpy(&iv, token->kad->session_key, sizeof(iv));
 
        sg_init_one(&sg, txb->data, txb->len);
@@ -344,13 +344,13 @@ static int rxkad_secure_packet(struct rxrpc_call *call, struct rxrpc_txbuf *txb)
        int ret;
 
        _enter("{%d{%x}},{#%u},%u,",
-              call->debug_id, key_serial(call->conn->params.key),
+              call->debug_id, key_serial(call->conn->key),
               txb->seq, txb->len);
 
        if (!call->conn->rxkad.cipher)
                return 0;
 
-       ret = key_validate(call->conn->params.key);
+       ret = key_validate(call->conn->key);
        if (ret < 0)
                return ret;
 
@@ -380,7 +380,7 @@ static int rxkad_secure_packet(struct rxrpc_call *call, struct rxrpc_txbuf *txb)
                y = 1; /* zero checksums are not permitted */
        txb->wire.cksum = htons(y);
 
-       switch (call->conn->params.security_level) {
+       switch (call->conn->security_level) {
        case RXRPC_SECURITY_PLAIN:
                ret = 0;
                break;
@@ -525,7 +525,7 @@ static int rxkad_verify_packet_2(struct rxrpc_call *call, struct sk_buff *skb,
        }
 
        /* decrypt from the session key */
-       token = call->conn->params.key->payload.data[0];
+       token = call->conn->key->payload.data[0];
        memcpy(&iv, token->kad->session_key, sizeof(iv));
 
        skcipher_request_set_sync_tfm(req, call->conn->rxkad.cipher);
@@ -596,7 +596,7 @@ static int rxkad_verify_packet(struct rxrpc_call *call, struct sk_buff *skb)
        u32 x, y;
 
        _enter("{%d{%x}},{#%u}",
-              call->debug_id, key_serial(call->conn->params.key), seq);
+              call->debug_id, key_serial(call->conn->key), seq);
 
        if (!call->conn->rxkad.cipher)
                return 0;
@@ -632,7 +632,7 @@ static int rxkad_verify_packet(struct rxrpc_call *call, struct sk_buff *skb)
                goto protocol_error;
        }
 
-       switch (call->conn->params.security_level) {
+       switch (call->conn->security_level) {
        case RXRPC_SECURITY_PLAIN:
                ret = 0;
                break;
@@ -678,8 +678,8 @@ static int rxkad_issue_challenge(struct rxrpc_connection *conn)
        challenge.min_level     = htonl(0);
        challenge.__padding     = 0;
 
-       msg.msg_name    = &conn->params.peer->srx.transport;
-       msg.msg_namelen = conn->params.peer->srx.transport_len;
+       msg.msg_name    = &conn->peer->srx.transport;
+       msg.msg_namelen = conn->peer->srx.transport_len;
        msg.msg_control = NULL;
        msg.msg_controllen = 0;
        msg.msg_flags   = 0;
@@ -705,14 +705,14 @@ static int rxkad_issue_challenge(struct rxrpc_connection *conn)
        serial = atomic_inc_return(&conn->serial);
        whdr.serial = htonl(serial);
 
-       ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len);
+       ret = kernel_sendmsg(conn->local->socket, &msg, iov, 2, len);
        if (ret < 0) {
                trace_rxrpc_tx_fail(conn->debug_id, serial, ret,
                                    rxrpc_tx_point_rxkad_challenge);
                return -EAGAIN;
        }
 
-       conn->params.peer->last_tx_at = ktime_get_seconds();
+       conn->peer->last_tx_at = ktime_get_seconds();
        trace_rxrpc_tx_packet(conn->debug_id, &whdr,
                              rxrpc_tx_point_rxkad_challenge);
        _leave(" = 0");
@@ -736,8 +736,8 @@ static int rxkad_send_response(struct rxrpc_connection *conn,
 
        _enter("");
 
-       msg.msg_name    = &conn->params.peer->srx.transport;
-       msg.msg_namelen = conn->params.peer->srx.transport_len;
+       msg.msg_name    = &conn->peer->srx.transport;
+       msg.msg_namelen = conn->peer->srx.transport_len;
        msg.msg_control = NULL;
        msg.msg_controllen = 0;
        msg.msg_flags   = 0;
@@ -762,14 +762,14 @@ static int rxkad_send_response(struct rxrpc_connection *conn,
        serial = atomic_inc_return(&conn->serial);
        whdr.serial = htonl(serial);
 
-       ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 3, len);
+       ret = kernel_sendmsg(conn->local->socket, &msg, iov, 3, len);
        if (ret < 0) {
                trace_rxrpc_tx_fail(conn->debug_id, serial, ret,
                                    rxrpc_tx_point_rxkad_response);
                return -EAGAIN;
        }
 
-       conn->params.peer->last_tx_at = ktime_get_seconds();
+       conn->peer->last_tx_at = ktime_get_seconds();
        _leave(" = 0");
        return 0;
 }
@@ -832,15 +832,15 @@ static int rxkad_respond_to_challenge(struct rxrpc_connection *conn,
        u32 version, nonce, min_level, abort_code;
        int ret;
 
-       _enter("{%d,%x}", conn->debug_id, key_serial(conn->params.key));
+       _enter("{%d,%x}", conn->debug_id, key_serial(conn->key));
 
        eproto = tracepoint_string("chall_no_key");
        abort_code = RX_PROTOCOL_ERROR;
-       if (!conn->params.key)
+       if (!conn->key)
                goto protocol_error;
 
        abort_code = RXKADEXPIRED;
-       ret = key_validate(conn->params.key);
+       ret = key_validate(conn->key);
        if (ret < 0)
                goto other_error;
 
@@ -863,10 +863,10 @@ static int rxkad_respond_to_challenge(struct rxrpc_connection *conn,
 
        abort_code = RXKADLEVELFAIL;
        ret = -EACCES;
-       if (conn->params.security_level < min_level)
+       if (conn->security_level < min_level)
                goto other_error;
 
-       token = conn->params.key->payload.data[0];
+       token = conn->key->payload.data[0];
 
        /* build the response packet */
        resp = kzalloc(sizeof(struct rxkad_response), GFP_NOFS);
@@ -878,7 +878,7 @@ static int rxkad_respond_to_challenge(struct rxrpc_connection *conn,
        resp->encrypted.cid             = htonl(conn->proto.cid);
        resp->encrypted.securityIndex   = htonl(conn->security_ix);
        resp->encrypted.inc_nonce       = htonl(nonce + 1);
-       resp->encrypted.level           = htonl(conn->params.security_level);
+       resp->encrypted.level           = htonl(conn->security_level);
        resp->kvno                      = htonl(token->kad->kvno);
        resp->ticket_len                = htonl(token->kad->ticket_len);
        resp->encrypted.call_id[0]      = htonl(conn->channels[0].call_counter);
@@ -1226,7 +1226,7 @@ static int rxkad_verify_response(struct rxrpc_connection *conn,
        level = ntohl(response->encrypted.level);
        if (level > RXRPC_SECURITY_ENCRYPT)
                goto protocol_error_free;
-       conn->params.security_level = level;
+       conn->security_level = level;
 
        /* create a key to hold the security data and expiration time - after
         * this the connection security can be handled in exactly the same way

diff --git a/net/rxrpc/security.c b/net/rxrpc/security.c
index 50cb5f1..e6ddac9 100644 (file)
--- a/net/rxrpc/security.c
+++ b/net/rxrpc/security.c
@@ -69,7 +69,7 @@ int rxrpc_init_client_conn_security(struct rxrpc_connection *conn)
 {
        const struct rxrpc_security *sec;
        struct rxrpc_key_token *token;
-       struct key *key = conn->params.key;
+       struct key *key = conn->key;
        int ret;
 
        _enter("{%d},{%x}", conn->debug_id, key_serial(key));
@@ -163,7 +163,7 @@ struct key *rxrpc_look_up_server_security(struct rxrpc_connection *conn,
 
        rcu_read_lock();
 
-       rx = rcu_dereference(conn->params.local->service);
+       rx = rcu_dereference(conn->local->service);
        if (!rx)
                goto out;