Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

[uclinux-h8/linux.git] / net / rxrpc / ar-connevent.c

diff --git a/net/rxrpc/ar-connevent.c b/net/rxrpc/ar-connevent.c
index e7ed43a..1bdaaed 100644 (file)
--- a/net/rxrpc/ar-connevent.c
+++ b/net/rxrpc/ar-connevent.c
@@ -42,9 +42,9 @@ static void rxrpc_abort_calls(struct rxrpc_connection *conn, int state,
                        call->state = state;
                        call->abort_code = abort_code;
                        if (state == RXRPC_CALL_LOCALLY_ABORTED)
-                               set_bit(RXRPC_CALL_CONN_ABORT, &call->events);
+                               set_bit(RXRPC_CALL_EV_CONN_ABORT, &call->events);
                        else
-                               set_bit(RXRPC_CALL_RCVD_ABORT, &call->events);
+                               set_bit(RXRPC_CALL_EV_RCVD_ABORT, &call->events);
                        rxrpc_queue_call(call);
                }
                write_unlock(&call->state_lock);
@@ -60,11 +60,12 @@ static void rxrpc_abort_calls(struct rxrpc_connection *conn, int state,
 static int rxrpc_abort_connection(struct rxrpc_connection *conn,
                                  u32 error, u32 abort_code)
 {
-       struct rxrpc_header hdr;
+       struct rxrpc_wire_header whdr;
        struct msghdr msg;
        struct kvec iov[2];
        __be32 word;
        size_t len;
+       u32 serial;
        int ret;
 
        _enter("%d,,%u,%u", conn->debug_id, error, abort_code);
@@ -89,28 +90,29 @@ static int rxrpc_abort_connection(struct rxrpc_connection *conn,
        msg.msg_controllen = 0;
        msg.msg_flags   = 0;
 
-       hdr.epoch       = conn->epoch;
-       hdr.cid         = conn->cid;
-       hdr.callNumber  = 0;
-       hdr.seq         = 0;
-       hdr.type        = RXRPC_PACKET_TYPE_ABORT;
-       hdr.flags       = conn->out_clientflag;
-       hdr.userStatus  = 0;
-       hdr.securityIndex = conn->security_ix;
-       hdr._rsvd       = 0;
-       hdr.serviceId   = conn->service_id;
+       whdr.epoch      = htonl(conn->epoch);
+       whdr.cid        = htonl(conn->cid);
+       whdr.callNumber = 0;
+       whdr.seq        = 0;
+       whdr.type       = RXRPC_PACKET_TYPE_ABORT;
+       whdr.flags      = conn->out_clientflag;
+       whdr.userStatus = 0;
+       whdr.securityIndex = conn->security_ix;
+       whdr._rsvd      = 0;
+       whdr.serviceId  = htons(conn->service_id);
 
        word = htonl(abort_code);
 
-       iov[0].iov_base = &hdr;
-       iov[0].iov_len  = sizeof(hdr);
+       iov[0].iov_base = &whdr;
+       iov[0].iov_len  = sizeof(whdr);
        iov[1].iov_base = &word;
        iov[1].iov_len  = sizeof(word);
 
        len = iov[0].iov_len + iov[1].iov_len;
 
-       hdr.serial = htonl(atomic_inc_return(&conn->serial));
-       _proto("Tx CONN ABORT %%%u { %d }", ntohl(hdr.serial), abort_code);
+       serial = atomic_inc_return(&conn->serial);
+       whdr.serial = htonl(serial);
+       _proto("Tx CONN ABORT %%%u { %d }", serial, abort_code);
 
        ret = kernel_sendmsg(conn->trans->local->socket, &msg, iov, 2, len);
        if (ret < 0) {
@@ -132,7 +134,7 @@ static void rxrpc_call_is_secure(struct rxrpc_call *call)
        if (call) {
                read_lock(&call->state_lock);
                if (call->state < RXRPC_CALL_COMPLETE &&
-                   !test_and_set_bit(RXRPC_CALL_SECURED, &call->events))
+                   !test_and_set_bit(RXRPC_CALL_EV_SECURED, &call->events))
                        rxrpc_queue_call(call);
                read_unlock(&call->state_lock);
        }
@@ -146,8 +148,8 @@ static int rxrpc_process_event(struct rxrpc_connection *conn,
                               u32 *_abort_code)
 {
        struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
-       __be32 tmp;
-       u32 serial;
+       __be32 wtmp;
+       u32 abort_code;
        int loop, ret;
 
        if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
@@ -155,19 +157,18 @@ static int rxrpc_process_event(struct rxrpc_connection *conn,
                return -ECONNABORTED;
        }
 
-       serial = ntohl(sp->hdr.serial);
-
-       _enter("{%d},{%u,%%%u},", conn->debug_id, sp->hdr.type, serial);
+       _enter("{%d},{%u,%%%u},", conn->debug_id, sp->hdr.type, sp->hdr.serial);
 
        switch (sp->hdr.type) {
        case RXRPC_PACKET_TYPE_ABORT:
-               if (skb_copy_bits(skb, 0, &tmp, sizeof(tmp)) < 0)
+               if (skb_copy_bits(skb, 0, &wtmp, sizeof(wtmp)) < 0)
                        return -EPROTO;
-               _proto("Rx ABORT %%%u { ac=%d }", serial, ntohl(tmp));
+               abort_code = ntohl(wtmp);
+               _proto("Rx ABORT %%%u { ac=%d }", sp->hdr.serial, abort_code);
 
                conn->state = RXRPC_CONN_REMOTELY_ABORTED;
                rxrpc_abort_calls(conn, RXRPC_CALL_REMOTELY_ABORTED,
-                                 ntohl(tmp));
+                                 abort_code);
                return -ECONNABORTED;
 
        case RXRPC_PACKET_TYPE_CHALLENGE:
@@ -335,7 +336,7 @@ void rxrpc_reject_packets(struct work_struct *work)
                struct sockaddr_in sin;
        } sa;
        struct rxrpc_skb_priv *sp;
-       struct rxrpc_header hdr;
+       struct rxrpc_wire_header whdr;
        struct rxrpc_local *local;
        struct sk_buff *skb;
        struct msghdr msg;
@@ -348,11 +349,11 @@ void rxrpc_reject_packets(struct work_struct *work)
 
        _enter("%d", local->debug_id);
 
-       iov[0].iov_base = &hdr;
-       iov[0].iov_len = sizeof(hdr);
+       iov[0].iov_base = &whdr;
+       iov[0].iov_len = sizeof(whdr);
        iov[1].iov_base = &code;
        iov[1].iov_len = sizeof(code);
-       size = sizeof(hdr) + sizeof(code);
+       size = sizeof(whdr) + sizeof(code);
 
        msg.msg_name = &sa;
        msg.msg_control = NULL;
@@ -370,8 +371,8 @@ void rxrpc_reject_packets(struct work_struct *work)
                break;
        }
 
-       memset(&hdr, 0, sizeof(hdr));
-       hdr.type = RXRPC_PACKET_TYPE_ABORT;
+       memset(&whdr, 0, sizeof(whdr));
+       whdr.type = RXRPC_PACKET_TYPE_ABORT;
 
        while ((skb = skb_dequeue(&local->reject_queue))) {
                sp = rxrpc_skb(skb);
@@ -381,13 +382,13 @@ void rxrpc_reject_packets(struct work_struct *work)
                        sa.sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
                        code = htonl(skb->priority);
 
-                       hdr.epoch = sp->hdr.epoch;
-                       hdr.cid = sp->hdr.cid;
-                       hdr.callNumber = sp->hdr.callNumber;
-                       hdr.serviceId = sp->hdr.serviceId;
-                       hdr.flags = sp->hdr.flags;
-                       hdr.flags ^= RXRPC_CLIENT_INITIATED;
-                       hdr.flags &= RXRPC_CLIENT_INITIATED;
+                       whdr.epoch      = htonl(sp->hdr.epoch);
+                       whdr.cid        = htonl(sp->hdr.cid);
+                       whdr.callNumber = htonl(sp->hdr.callNumber);
+                       whdr.serviceId  = htons(sp->hdr.serviceId);
+                       whdr.flags      = sp->hdr.flags;
+                       whdr.flags      ^= RXRPC_CLIENT_INITIATED;
+                       whdr.flags      &= RXRPC_CLIENT_INITIATED;
 
                        kernel_sendmsg(local->socket, &msg, iov, 2, size);
                        break;