static inline void
 lnet_peer_set_alive(lnet_peer_t *lp)
 {
-       lp->lp_last_alive = lp->lp_last_query = jiffies;
+       lp->lp_last_query = jiffies;
+       lp->lp_last_alive = jiffies;
        if (!lp->lp_alive)
                lnet_notify_locked(lp, 0, 1, lp->lp_last_alive);
 }
 
 {
        msg->ksm_csum = 0;
        msg->ksm_type = type;
-       msg->ksm_zc_cookies[0] = msg->ksm_zc_cookies[1]  = 0;
+       msg->ksm_zc_cookies[0] = 0;
+       msg->ksm_zc_cookies[1] = 0;
 }
 
 #define KSOCK_MSG_NOOP 0xC0    /* ksm_u empty */
 
        write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
 
        if (nid != LNET_NID_ANY) {
-               lo = hi = kiblnd_nid2peerlist(nid) - kiblnd_data.kib_peers;
+               lo = kiblnd_nid2peerlist(nid) - kiblnd_data.kib_peers;
+               hi = kiblnd_nid2peerlist(nid) - kiblnd_data.kib_peers;
        } else {
                lo = 0;
                hi = kiblnd_data.kib_peer_hash_size - 1;
 
        write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
 
-       if (nid != LNET_NID_ANY)
-               lo = hi = kiblnd_nid2peerlist(nid) - kiblnd_data.kib_peers;
-       else {
+       if (nid != LNET_NID_ANY) {
+               lo = kiblnd_nid2peerlist(nid) - kiblnd_data.kib_peers;
+               hi = kiblnd_nid2peerlist(nid) - kiblnd_data.kib_peers;
+       } else {
                lo = 0;
                hi = kiblnd_data.kib_peer_hash_size - 1;
        }
 
        struct ib_sge *sge = &tx->tx_sge[0];
        struct ib_rdma_wr *wrq = &tx->tx_wrq[0], *next;
        int rc  = resid;
-       int srcidx;
-       int dstidx;
+       int srcidx = 0;
+       int dstidx = 0;
        int wrknob;
 
        LASSERT(!in_interrupt());
        LASSERT(type == IBLND_MSG_GET_DONE ||
                type == IBLND_MSG_PUT_DONE);
 
-       srcidx = dstidx = 0;
-
        while (resid > 0) {
                if (srcidx >= srcrd->rd_nfrags) {
                        CERROR("Src buffer exhausted: %d frags\n", srcidx);
 
 
        write_lock_bh(&ksocknal_data.ksnd_global_lock);
 
-       if (id.nid != LNET_NID_ANY)
-               lo = hi = (int)(ksocknal_nid2peerlist(id.nid) - ksocknal_data.ksnd_peers);
-       else {
+       if (id.nid != LNET_NID_ANY) {
+               lo = (int)(ksocknal_nid2peerlist(id.nid) - ksocknal_data.ksnd_peers);
+               hi = (int)(ksocknal_nid2peerlist(id.nid) - ksocknal_data.ksnd_peers);
+       } else {
                lo = 0;
                hi = ksocknal_data.ksnd_peer_hash_size - 1;
        }
 
        write_lock_bh(&ksocknal_data.ksnd_global_lock);
 
-       if (id.nid != LNET_NID_ANY)
-               lo = hi = (int)(ksocknal_nid2peerlist(id.nid) - ksocknal_data.ksnd_peers);
-       else {
+       if (id.nid != LNET_NID_ANY) {
+               lo = (int)(ksocknal_nid2peerlist(id.nid) - ksocknal_data.ksnd_peers);
+               hi = (int)(ksocknal_nid2peerlist(id.nid) - ksocknal_data.ksnd_peers);
+       } else {
                lo = 0;
                hi = ksocknal_data.ksnd_peer_hash_size - 1;
        }
                start = &ksocknal_data.ksnd_peers[0];
                end = &ksocknal_data.ksnd_peers[hsize - 1];
        } else {
-               start = end = ksocknal_nid2peerlist(id.nid);
+               start = ksocknal_nid2peerlist(id.nid);
+               end = ksocknal_nid2peerlist(id.nid);
        }
 
        for (tmp = start; tmp <= end; tmp++) {
 
        tx->tx_iov[0].iov_base = &tx->tx_lnetmsg->msg_hdr;
        tx->tx_iov[0].iov_len  = sizeof(lnet_hdr_t);
 
-       tx->tx_resid = tx->tx_nob = tx->tx_lnetmsg->msg_len + sizeof(lnet_hdr_t);
+       tx->tx_nob = tx->tx_lnetmsg->msg_len + sizeof(lnet_hdr_t);
+       tx->tx_resid = tx->tx_lnetmsg->msg_len + sizeof(lnet_hdr_t);
 }
 
 static void
 
                tx->tx_msg.ksm_u.lnetmsg.ksnm_hdr = tx->tx_lnetmsg->msg_hdr;
                tx->tx_iov[0].iov_len = sizeof(ksock_msg_t);
-               tx->tx_resid = tx->tx_nob = sizeof(ksock_msg_t) + tx->tx_lnetmsg->msg_len;
+               tx->tx_nob = sizeof(ksock_msg_t) + tx->tx_lnetmsg->msg_len;
+               tx->tx_resid = sizeof(ksock_msg_t) + tx->tx_lnetmsg->msg_len;
        } else {
                LASSERT(tx->tx_msg.ksm_type == KSOCK_MSG_NOOP);
 
                tx->tx_iov[0].iov_len = offsetof(ksock_msg_t, ksm_u.lnetmsg.ksnm_hdr);
-               tx->tx_resid = tx->tx_nob = offsetof(ksock_msg_t,  ksm_u.lnetmsg.ksnm_hdr);
+               tx->tx_nob = offsetof(ksock_msg_t,  ksm_u.lnetmsg.ksnm_hdr);
+               tx->tx_resid = offsetof(ksock_msg_t,  ksm_u.lnetmsg.ksnm_hdr);
        }
        /* Don't checksum before start sending, because packet can be piggybacked with ACK */
 }
 {
        msg->ksm_csum = 0;
        msg->ksm_type = KSOCK_MSG_LNET;
-       msg->ksm_zc_cookies[0] = msg->ksm_zc_cookies[1]  = 0;
+       msg->ksm_zc_cookies[0] = 0;
+       msg->ksm_zc_cookies[1] = 0;
 }
 
 static void
 
        the_lnet.ln_network_tokens = tokens;
        the_lnet.ln_network_tokens_nob = tokensize;
        memcpy(tokens, networks, tokensize);
-       str = tmp = tokens;
+       tmp = tokens;
+       str = tokens;
 
        /* Add in the loopback network */
        ni = lnet_ni_alloc(LNET_MKNET(LOLND, 0), NULL, nilist);
 
                if ((umd->options & LNET_MD_KIOV) != 0) /* Can't specify both */
                        return -EINVAL;
 
-               lmd->md_niov = niov = umd->length;
+               niov = umd->length;
+               lmd->md_niov = umd->length;
                memcpy(lmd->md_iov.iov, umd->start,
                       niov * sizeof(lmd->md_iov.iov[0]));
 
                        return -EINVAL;
 
        } else if ((umd->options & LNET_MD_KIOV) != 0) {
-               lmd->md_niov = niov = umd->length;
+               niov = umd->length;
+               lmd->md_niov = umd->length;
                memcpy(lmd->md_iov.kiov, umd->start,
                       niov * sizeof(lmd->md_iov.kiov[0]));
 
                        return -EINVAL;
        } else {   /* contiguous */
                lmd->md_length = umd->length;
-               lmd->md_niov = niov = 1;
+               niov = 1;
+               lmd->md_niov = 1;
                lmd->md_iov.iov[0].iov_base = umd->start;
                lmd->md_iov.iov[0].iov_len = umd->length;
 
 
                return NULL;
 
        lp_best = NULL;
-       rtr_best = rtr_last = NULL;
+       rtr_best = NULL;
+       rtr_last = NULL;
        list_for_each_entry(rtr, &rnet->lrn_routes, lr_list) {
                lp = rtr->lr_gateway;
 
                        return lp;
 
                if (lp_best == NULL) {
-                       rtr_best = rtr_last = rtr;
+                       rtr_best = rtr;
+                       rtr_last = rtr;
                        lp_best = lp;
                        continue;
                }
        msg->msg_type = type;
        msg->msg_private = private;
        msg->msg_receiving = 1;
-       msg->msg_len = msg->msg_wanted = payload_length;
+       msg->msg_wanted = payload_length;
+       msg->msg_len = payload_length;
        msg->msg_offset = 0;
        msg->msg_hdr = *hdr;
        /* for building message event */
 
                goto out;
        }
 
-       lp->lp_txcredits     =
-       lp->lp_mintxcredits  = lp->lp_ni->ni_peertxcredits;
-       lp->lp_rtrcredits    =
+       lp->lp_txcredits = lp->lp_ni->ni_peertxcredits;
+       lp->lp_mintxcredits = lp->lp_ni->ni_peertxcredits;
+       lp->lp_rtrcredits = lnet_peer_buffer_credits(lp->lp_ni);
        lp->lp_minrtrcredits = lnet_peer_buffer_credits(lp->lp_ni);
 
        list_add_tail(&lp->lp_hashlist,
 
        LASSERT(rbp->rbp_nbuffers == nbuffers);
        LASSERT(rbp->rbp_credits == nbuffers);
 
-       rbp->rbp_nbuffers = rbp->rbp_credits = 0;
+       rbp->rbp_nbuffers = 0;
+       rbp->rbp_credits = 0;
 }
 
 static int
 
                CNETERR("Framework features %x from %s is different with features on this transaction: %x\n",
                        reply->msg_ses_feats, libcfs_nid2str(nd->nd_id.nid),
                        trans->tas_features);
-               status = mksn_rep->mksn_status = EPROTO;
+               mksn_rep->mksn_status = EPROTO;
+               status = EPROTO;
        }
 
        if (status == 0) {
 
        LNetInvalidateHandle(&rpc->crpc_bulk.bk_mdh);
 
        /* no event is expected at this point */
-       rpc->crpc_bulkev.ev_fired  =
-       rpc->crpc_reqstev.ev_fired =
+       rpc->crpc_bulkev.ev_fired = 1;
+       rpc->crpc_reqstev.ev_fired = 1;
        rpc->crpc_replyev.ev_fired = 1;
 
        rpc->crpc_reqstmsg.msg_magic   = SRPC_MSG_MAGIC;