net: Move && and || to end of previous line

Not including net/atm/

Compiled tested x86 allyesconfig only
Added a > 80 column line or two, which I ignored.
Existing checkpatch plaints willfully, cheerfully ignored.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

14 files changed, 56 insertions, 62 deletions

diff --git a/net/rds/af_rds.c b/net/rds/af_rds.c
index e25d8d5ce8df..853c52be781f 100644
--- a/net/rds/af_rds.c
+++ b/net/rds/af_rds.c
@@ -174,8 +174,8 @@ static unsigned int rds_poll(struct file *file, struct socket *sock,
                         mask |= (POLLIN | POLLRDNORM);
                 spin_unlock(&rs->rs_lock);
         }
-        if (!list_empty(&rs->rs_recv_queue)
-         || !list_empty(&rs->rs_notify_queue))
+        if (!list_empty(&rs->rs_recv_queue) ||
+            !list_empty(&rs->rs_notify_queue))
                 mask |= (POLLIN | POLLRDNORM);
         if (rs->rs_snd_bytes < rds_sk_sndbuf(rs))
                 mask |= (POLLOUT | POLLWRNORM);
@@ -308,8 +308,8 @@ static int rds_getsockopt(struct socket *sock, int level, int optname,
                 if (len < sizeof(int))
                         ret = -EINVAL;
                 else
-                if (put_user(rs->rs_recverr, (int __user *) optval)
-                 || put_user(sizeof(int), optlen))
+                if (put_user(rs->rs_recverr, (int __user *) optval) ||
+                    put_user(sizeof(int), optlen))
                         ret = -EFAULT;
                 else
                         ret = 0;
diff --git a/net/rds/connection.c b/net/rds/connection.c
index cc8b568c0c84..278f607ab603 100644
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -133,10 +133,8 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr,
 
         spin_lock_irqsave(&rds_conn_lock, flags);
         conn = rds_conn_lookup(head, laddr, faddr, trans);
-        if (conn
-         && conn->c_loopback
-         && conn->c_trans != &rds_loop_transport
-         && !is_outgoing) {
+        if (conn && conn->c_loopback && conn->c_trans != &rds_loop_transport &&
+            !is_outgoing) {
                 /* This is a looped back IB connection, and we're
                  * called by the code handling the incoming connect.
                  * We need a second connection object into which we
diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c
index 9d320692a4fc..647cb8ffc39b 100644
--- a/net/rds/ib_cm.c
+++ b/net/rds/ib_cm.c
@@ -377,8 +377,8 @@ static u32 rds_ib_protocol_compatible(struct rdma_cm_event *event)
         }
 
         /* Even if len is crap *now* I still want to check it. -ASG */
-        if (event->param.conn.private_data_len < sizeof (*dp)
-            || dp->dp_protocol_major == 0)
+        if (event->param.conn.private_data_len < sizeof (*dp) ||
+            dp->dp_protocol_major == 0)
                 return RDS_PROTOCOL_3_0;
 
         common = be16_to_cpu(dp->dp_protocol_minor_mask) & RDS_IB_SUPPORTED_PROTOCOLS;
diff --git a/net/rds/ib_rdma.c b/net/rds/ib_rdma.c
index c5e916598c14..4b0da865a72c 100644
--- a/net/rds/ib_rdma.c
+++ b/net/rds/ib_rdma.c
@@ -570,8 +570,8 @@ void rds_ib_free_mr(void *trans_private, int invalidate)
         spin_unlock_irqrestore(&pool->list_lock, flags);
 
         /* If we've pinned too many pages, request a flush */
-        if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned
-         || atomic_read(&pool->dirty_count) >= pool->max_items / 10)
+        if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned ||
+            atomic_read(&pool->dirty_count) >= pool->max_items / 10)
                 queue_work(rds_wq, &pool->flush_worker);
 
         if (invalidate) {
diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index fe5ab8c6b964..04dc0d3f3c95 100644
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -230,8 +230,8 @@ int rds_ib_recv_refill(struct rds_connection *conn, gfp_t kptr_gfp,
         int ret = 0;
         u32 pos;
 
-        while ((prefill || rds_conn_up(conn))
-                        && rds_ib_ring_alloc(&ic->i_recv_ring, 1, &pos)) {
+        while ((prefill || rds_conn_up(conn)) &&
+               rds_ib_ring_alloc(&ic->i_recv_ring, 1, &pos)) {
                 if (pos >= ic->i_recv_ring.w_nr) {
                         printk(KERN_NOTICE "Argh - ring alloc returned pos=%u\n",
                                         pos);
@@ -771,10 +771,10 @@ static void rds_ib_process_recv(struct rds_connection *conn,
                 hdr = &ibinc->ii_inc.i_hdr;
                 /* We can't just use memcmp here; fragments of a
                  * single message may carry different ACKs */
-                if (hdr->h_sequence != ihdr->h_sequence
-                 || hdr->h_len != ihdr->h_len
-                 || hdr->h_sport != ihdr->h_sport
-                 || hdr->h_dport != ihdr->h_dport) {
+                if (hdr->h_sequence != ihdr->h_sequence ||
+                    hdr->h_len != ihdr->h_len ||
+                    hdr->h_sport != ihdr->h_sport ||
+                    hdr->h_dport != ihdr->h_dport) {
                         rds_ib_conn_error(conn,
                                 "fragment header mismatch; forcing reconnect\n");
                         return;
diff --git a/net/rds/ib_send.c b/net/rds/ib_send.c
index 23bf830db2d5..a10fab6886d1 100644
--- a/net/rds/ib_send.c
+++ b/net/rds/ib_send.c
@@ -252,8 +252,8 @@ void rds_ib_send_cq_comp_handler(struct ib_cq *cq, void *context)
 
                 rds_ib_ring_free(&ic->i_send_ring, completed);
 
-                if (test_and_clear_bit(RDS_LL_SEND_FULL, &conn->c_flags)
-                 || test_bit(0, &conn->c_map_queued))
+                if (test_and_clear_bit(RDS_LL_SEND_FULL, &conn->c_flags) ||
+                    test_bit(0, &conn->c_map_queued))
                         queue_delayed_work(rds_wq, &conn->c_send_w, 0);
 
                 /* We expect errors as the qp is drained during shutdown */
diff --git a/net/rds/iw_rdma.c b/net/rds/iw_rdma.c
index b25d785e49fc..9eda11cca956 100644
--- a/net/rds/iw_rdma.c
+++ b/net/rds/iw_rdma.c
@@ -573,8 +573,8 @@ void rds_iw_free_mr(void *trans_private, int invalidate)
         rds_iw_free_fastreg(pool, ibmr);
 
         /* If we've pinned too many pages, request a flush */
-        if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned
-         || atomic_read(&pool->dirty_count) >= pool->max_items / 10)
+        if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned ||
+            atomic_read(&pool->dirty_count) >= pool->max_items / 10)
                 queue_work(rds_wq, &pool->flush_worker);
 
         if (invalidate) {
diff --git a/net/rds/iw_recv.c b/net/rds/iw_recv.c
index 24fc53f03833..54af7d6b92da 100644
--- a/net/rds/iw_recv.c
+++ b/net/rds/iw_recv.c
@@ -230,8 +230,8 @@ int rds_iw_recv_refill(struct rds_connection *conn, gfp_t kptr_gfp,
         int ret = 0;
         u32 pos;
 
-        while ((prefill || rds_conn_up(conn))
-                        && rds_iw_ring_alloc(&ic->i_recv_ring, 1, &pos)) {
+        while ((prefill || rds_conn_up(conn)) &&
+               rds_iw_ring_alloc(&ic->i_recv_ring, 1, &pos)) {
                 if (pos >= ic->i_recv_ring.w_nr) {
                         printk(KERN_NOTICE "Argh - ring alloc returned pos=%u\n",
                                         pos);
@@ -730,10 +730,10 @@ static void rds_iw_process_recv(struct rds_connection *conn,
                 hdr = &iwinc->ii_inc.i_hdr;
                 /* We can't just use memcmp here; fragments of a
                  * single message may carry different ACKs */
-                if (hdr->h_sequence != ihdr->h_sequence
-                 || hdr->h_len != ihdr->h_len
-                 || hdr->h_sport != ihdr->h_sport
-                 || hdr->h_dport != ihdr->h_dport) {
+                if (hdr->h_sequence != ihdr->h_sequence ||
+                    hdr->h_len != ihdr->h_len ||
+                    hdr->h_sport != ihdr->h_sport ||
+                    hdr->h_dport != ihdr->h_dport) {
                         rds_iw_conn_error(conn,
                                 "fragment header mismatch; forcing reconnect\n");
                         return;
diff --git a/net/rds/iw_send.c b/net/rds/iw_send.c
index 1f5abe3cf2b4..1379e9d66a78 100644
--- a/net/rds/iw_send.c
+++ b/net/rds/iw_send.c
@@ -288,8 +288,8 @@ void rds_iw_send_cq_comp_handler(struct ib_cq *cq, void *context)
 
                 rds_iw_ring_free(&ic->i_send_ring, completed);
 
-                if (test_and_clear_bit(RDS_LL_SEND_FULL, &conn->c_flags)
-                 || test_bit(0, &conn->c_map_queued))
+                if (test_and_clear_bit(RDS_LL_SEND_FULL, &conn->c_flags) ||
+                    test_bit(0, &conn->c_map_queued))
                         queue_delayed_work(rds_wq, &conn->c_send_w, 0);
 
                 /* We expect errors as the qp is drained during shutdown */
@@ -519,8 +519,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
         BUG_ON(hdr_off != 0 && hdr_off != sizeof(struct rds_header));
 
         /* Fastreg support */
-        if (rds_rdma_cookie_key(rm->m_rdma_cookie)
-         && !ic->i_fastreg_posted) {
+        if (rds_rdma_cookie_key(rm->m_rdma_cookie) && !ic->i_fastreg_posted) {
                 ret = -EAGAIN;
                 goto out;
         }
diff --git a/net/rds/message.c b/net/rds/message.c
index ca50a8ec9742..73e600ffd87f 100644
--- a/net/rds/message.c
+++ b/net/rds/message.c
@@ -122,8 +122,7 @@ int rds_message_add_extension(struct rds_header *hdr,
         if (hdr->h_exthdr[0] != RDS_EXTHDR_NONE)
                 return 0;
 
-        if (type >= __RDS_EXTHDR_MAX
-         || len != rds_exthdr_size[type])
+        if (type >= __RDS_EXTHDR_MAX || len != rds_exthdr_size[type])
                 return 0;
 
         if (ext_len >= RDS_HEADER_EXT_SPACE)
diff --git a/net/rds/rdma.c b/net/rds/rdma.c
index 971b5a668458..4c64daa1f5d5 100644
--- a/net/rds/rdma.c
+++ b/net/rds/rdma.c
@@ -631,8 +631,8 @@ int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
 {
         struct rds_rdma_op *op;
 
-        if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct rds_rdma_args))
-         || rm->m_rdma_op != NULL)
+        if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct rds_rdma_args)) ||
+            rm->m_rdma_op != NULL)
                 return -EINVAL;
 
         op = rds_rdma_prepare(rs, CMSG_DATA(cmsg));
@@ -655,8 +655,8 @@ int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
         u32 r_key;
         int err = 0;
 
-        if (cmsg->cmsg_len < CMSG_LEN(sizeof(rds_rdma_cookie_t))
-         || rm->m_rdma_cookie != 0)
+        if (cmsg->cmsg_len < CMSG_LEN(sizeof(rds_rdma_cookie_t)) ||
+            rm->m_rdma_cookie != 0)
                 return -EINVAL;
 
         memcpy(&rm->m_rdma_cookie, CMSG_DATA(cmsg), sizeof(rm->m_rdma_cookie));
@@ -692,8 +692,8 @@ int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
 int rds_cmsg_rdma_map(struct rds_sock *rs, struct rds_message *rm,
                           struct cmsghdr *cmsg)
 {
-        if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct rds_get_mr_args))
-         || rm->m_rdma_cookie != 0)
+        if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct rds_get_mr_args)) ||
+            rm->m_rdma_cookie != 0)
                 return -EINVAL;
 
         return __rds_rdma_map(rs, CMSG_DATA(cmsg), &rm->m_rdma_cookie, &rm->m_rdma_mr);
diff --git a/net/rds/recv.c b/net/rds/recv.c
index fdff33c7b432..b426d67f760c 100644
--- a/net/rds/recv.c
+++ b/net/rds/recv.c
@@ -195,8 +195,8 @@ void rds_recv_incoming(struct rds_connection *conn, __be32 saddr, __be32 daddr,
          * XXX we could spend more on the wire to get more robust failure
          * detection, arguably worth it to avoid data corruption.
          */
-        if (be64_to_cpu(inc->i_hdr.h_sequence) < conn->c_next_rx_seq
-         && (inc->i_hdr.h_flags & RDS_FLAG_RETRANSMITTED)) {
+        if (be64_to_cpu(inc->i_hdr.h_sequence) < conn->c_next_rx_seq &&
+            (inc->i_hdr.h_flags & RDS_FLAG_RETRANSMITTED)) {
                 rds_stats_inc(s_recv_drop_old_seq);
                 goto out;
         }
@@ -432,10 +432,9 @@ int rds_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                         }
 
                         timeo = wait_event_interruptible_timeout(*sk->sk_sleep,
-                                                (!list_empty(&rs->rs_notify_queue)
-                                                || rs->rs_cong_notify
-                                                || rds_next_incoming(rs, &inc)),
-                                                timeo);
+                                        (!list_empty(&rs->rs_notify_queue) ||
+                                         rs->rs_cong_notify ||
+                                         rds_next_incoming(rs, &inc)), timeo);
                         rdsdebug("recvmsg woke inc %p timeo %ld\n", inc,
                                  timeo);
                         if (timeo > 0 || timeo == MAX_SCHEDULE_TIMEOUT)
diff --git a/net/rds/send.c b/net/rds/send.c
index 28c88ff3d038..b2fccfc20769 100644
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -235,8 +235,8 @@ int rds_send_xmit(struct rds_connection *conn)
                          * connection.
                          * Therefore, we never retransmit messages with RDMA ops.
                          */
-                        if (rm->m_rdma_op
-                         && test_bit(RDS_MSG_RETRANSMITTED, &rm->m_flags)) {
+                        if (rm->m_rdma_op &&
+                            test_bit(RDS_MSG_RETRANSMITTED, &rm->m_flags)) {
                                 spin_lock_irqsave(&conn->c_lock, flags);
                                 if (test_and_clear_bit(RDS_MSG_ON_CONN, &rm->m_flags))
                                         list_move(&rm->m_conn_item, &to_be_dropped);
@@ -247,8 +247,8 @@ int rds_send_xmit(struct rds_connection *conn)
 
                         /* Require an ACK every once in a while */
                         len = ntohl(rm->m_inc.i_hdr.h_len);
-                        if (conn->c_unacked_packets == 0
-                         || conn->c_unacked_bytes < len) {
+                        if (conn->c_unacked_packets == 0 ||
+                            conn->c_unacked_bytes < len) {
                                 __set_bit(RDS_MSG_ACK_REQUIRED, &rm->m_flags);
 
                                 conn->c_unacked_packets = rds_sysctl_max_unacked_packets;
@@ -418,8 +418,8 @@ void rds_rdma_send_complete(struct rds_message *rm, int status)
         spin_lock(&rm->m_rs_lock);
 
         ro = rm->m_rdma_op;
-        if (test_bit(RDS_MSG_ON_SOCK, &rm->m_flags)
-         && ro && ro->r_notify && ro->r_notifier) {
+        if (test_bit(RDS_MSG_ON_SOCK, &rm->m_flags) &&
+            ro && ro->r_notify && ro->r_notifier) {
                 notifier = ro->r_notifier;
                 rs = rm->m_rs;
                 sock_hold(rds_rs_to_sk(rs));
@@ -549,8 +549,7 @@ void rds_send_remove_from_sock(struct list_head *messages, int status)
                         list_del_init(&rm->m_sock_item);
                         rds_send_sndbuf_remove(rs, rm);
 
-                        if (ro && ro->r_notifier
-                           && (status || ro->r_notify)) {
+                        if (ro && ro->r_notifier && (status || ro->r_notify)) {
                                 notifier = ro->r_notifier;
                                 list_add_tail(&notifier->n_list,
                                                 &rs->rs_notify_queue);
@@ -877,8 +876,8 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
         if (ret)
                 goto out;
 
-        if ((rm->m_rdma_cookie || rm->m_rdma_op)
-         && conn->c_trans->xmit_rdma == NULL) {
+        if ((rm->m_rdma_cookie || rm->m_rdma_op) &&
+            conn->c_trans->xmit_rdma == NULL) {
                 if (printk_ratelimit())
                         printk(KERN_NOTICE "rdma_op %p conn xmit_rdma %p\n",
                                 rm->m_rdma_op, conn->c_trans->xmit_rdma);
@@ -890,8 +889,8 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
          * have scheduled a delayed reconnect however - in this case
          * we should not interfere.
          */
-        if (rds_conn_state(conn) == RDS_CONN_DOWN
-         && !test_and_set_bit(RDS_RECONNECT_PENDING, &conn->c_flags))
+        if (rds_conn_state(conn) == RDS_CONN_DOWN &&
+            !test_and_set_bit(RDS_RECONNECT_PENDING, &conn->c_flags))
                 queue_delayed_work(rds_wq, &conn->c_conn_w, 0);
 
         ret = rds_cong_wait(conn->c_fcong, dport, nonblock, rs);
@@ -973,8 +972,8 @@ rds_send_pong(struct rds_connection *conn, __be16 dport)
          * have scheduled a delayed reconnect however - in this case
          * we should not interfere.
          */
-        if (rds_conn_state(conn) == RDS_CONN_DOWN
-         && !test_and_set_bit(RDS_RECONNECT_PENDING, &conn->c_flags))
+        if (rds_conn_state(conn) == RDS_CONN_DOWN &&
+            !test_and_set_bit(RDS_RECONNECT_PENDING, &conn->c_flags))
                 queue_delayed_work(rds_wq, &conn->c_conn_w, 0);
 
         ret = rds_cong_wait(conn->c_fcong, dport, 1, NULL);
diff --git a/net/rds/threads.c b/net/rds/threads.c
index dd7e0cad1e7c..00fa10e59af8 100644
--- a/net/rds/threads.c
+++ b/net/rds/threads.c
@@ -170,8 +170,8 @@ void rds_shutdown_worker(struct work_struct *work)
                  * handler is supposed to check for state DISCONNECTING
                  */
                 mutex_lock(&conn->c_cm_lock);
-                if (!rds_conn_transition(conn, RDS_CONN_UP, RDS_CONN_DISCONNECTING)
-                 && !rds_conn_transition(conn, RDS_CONN_ERROR, RDS_CONN_DISCONNECTING)) {
+                if (!rds_conn_transition(conn, RDS_CONN_UP, RDS_CONN_DISCONNECTING) &&
+                    !rds_conn_transition(conn, RDS_CONN_ERROR, RDS_CONN_DISCONNECTING)) {
                         rds_conn_error(conn, "shutdown called in state %d\n",
                                         atomic_read(&conn->c_state));
                         mutex_unlock(&conn->c_cm_lock);