return libcfs_lnd2str_r(lnd, libcfs_next_nidstring(),
                                LNET_NIDSTR_SIZE);
 }
+
 int libcfs_str2lnd(const char *str);
 char *libcfs_net2str_r(__u32 net, char *buf, size_t buf_size);
 static inline char *libcfs_net2str(__u32 net)
        return libcfs_net2str_r(net, libcfs_next_nidstring(),
                                LNET_NIDSTR_SIZE);
 }
+
 char *libcfs_nid2str_r(lnet_nid_t nid, char *buf, size_t buf_size);
 static inline char *libcfs_nid2str(lnet_nid_t nid)
 {
        return libcfs_nid2str_r(nid, libcfs_next_nidstring(),
                                LNET_NIDSTR_SIZE);
 }
+
 __u32 libcfs_str2net(const char *str);
 lnet_nid_t libcfs_str2nid(const char *str);
 int libcfs_str2anynid(lnet_nid_t *nid, const char *str);
 
        kib_peer_t *peer;
 
        list_for_each(tmp, peer_list) {
-
                peer = list_entry(tmp, kib_peer_t, ibp_list);
 
                LASSERT(peer->ibp_connecting > 0 || /* creating conns */
        read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
 
        for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++) {
-
                list_for_each(ptmp, &kiblnd_data.kib_peers[i]) {
-
                        peer = list_entry(ptmp, kib_peer_t, ibp_list);
                        LASSERT(peer->ibp_connecting > 0 ||
                                peer->ibp_accepting > 0 ||
 
        for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++) {
                list_for_each(ptmp, &kiblnd_data.kib_peers[i]) {
-
                        peer = list_entry(ptmp, kib_peer_t, ibp_list);
                        LASSERT(peer->ibp_connecting > 0 ||
                                peer->ibp_accepting > 0 ||
 
        for (i = lo; i <= hi; i++) {
                list_for_each_safe(ptmp, pnxt, &kiblnd_data.kib_peers[i]) {
-
                        peer = list_entry(ptmp, kib_peer_t, ibp_list);
                        LASSERT(peer->ibp_connecting > 0 ||
                                peer->ibp_accepting > 0 ||
                CDEBUG(D_NET, "Another thread is allocating new FMR pool, waiting for her to complete\n");
                schedule();
                goto again;
-
        }
 
        if (time_before(cfs_time_current(), fps->fps_next_retry)) {
 
                        rej.ibr_why = IBLND_REJECT_RDMA_FRAGS;
 
                goto failed;
-
        }
 
        if (reqmsg->ibm_u.connparams.ibcp_max_msg_size > IBLND_MSG_SIZE) {
        spin_lock_irqsave(&kiblnd_data.kib_connd_lock, flags);
 
        while (!kiblnd_data.kib_shutdown) {
-
                dropped_lock = 0;
 
                if (!list_empty(&kiblnd_data.kib_connd_zombies)) {
 
        ksock_peer_t *peer;
 
        list_for_each(tmp, peer_list) {
-
                peer = list_entry(tmp, ksock_peer_t, ksnp_list);
 
                LASSERT(!peer->ksnp_closing);
        read_lock(&ksocknal_data.ksnd_global_lock);
 
        for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) {
-
                list_for_each(ptmp, &ksocknal_data.ksnd_peers[i]) {
                        peer = list_entry(ptmp, ksock_peer_t, ksnp_list);
 
        ksock_route_t *route;
 
        list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) {
-
                if (route->ksnr_ipaddr == ipaddr)
                        return route->ksnr_connecting;
        }
        for (i = lo; i <= hi; i++) {
                list_for_each_safe(ptmp, pnxt,
                                   &ksocknal_data.ksnd_peers[i]) {
-
                        peer = list_entry(ptmp, ksock_peer_t, ksnp_list);
 
                        if (!((id.nid == LNET_NID_ANY || id.nid == peer->ksnp_id.nid) &&
                                        continue;
 
                                for (j = 0; j < info->ksi_nthreads_max; j++) {
-
                                        sched = &info->ksi_scheds[j];
                                        LASSERT(list_empty(
                                                &sched->kss_tx_conns));
 static __u64
 ksocknal_new_incarnation(void)
 {
-
        /* The incarnation number is the time this module loaded and it
         * identifies this particular instance of the socknal.
         */
 
 static void
 ksocknal_launch_connection_locked (ksock_route_t *route)
 {
-
        /* called holding write lock on ksnd_global_lock */
 
        LASSERT(!route->ksnr_scheduled);
        /* connd_routes can contain both pending and ordinary routes */
        list_for_each_entry(route, &ksocknal_data.ksnd_connd_routes,
                            ksnr_connd_list) {
-
                if (route->ksnr_retry_interval == 0 ||
                    cfs_time_aftereq(now, route->ksnr_timeout))
                        return route;
 
                        if (cfs_time_aftereq(cfs_time_current(),
                                             tx->tx_deadline)) {
-
                                ksocknal_peer_addref(peer);
                                read_unlock(&ksocknal_data.ksnd_global_lock);
 
        spin_lock_bh(&ksocknal_data.ksnd_reaper_lock);
 
        while (!ksocknal_data.ksnd_shuttingdown) {
-
                if (!list_empty (&ksocknal_data.ksnd_deathrow_conns)) {
                        conn = list_entry (ksocknal_data. \
                                               ksnd_deathrow_conns.next,
 
        LASSERT(rc == 0);                     /* we succeeded before */
 
        if (!lnet_accept_magic(magic, LNET_PROTO_ACCEPTOR_MAGIC)) {
-
                if (lnet_accept_magic(magic, LNET_PROTO_MAGIC)) {
                        /*
                         * future version compatibility!
                return rc;
 
        while (!lnet_acceptor_state.pta_shutdown) {
-
                rc = lnet_sock_accept(&newsock, lnet_acceptor_state.pta_sock);
                if (rc != 0) {
                        if (rc != -EAGAIN) {
 
                counters->recv_length  += ctr->recv_length;
                counters->route_length += ctr->route_length;
                counters->drop_length  += ctr->drop_length;
-
        }
        lnet_net_unlock(LNET_LOCK_EX);
 }
 
                 * NB we don't check interface conflicts here; it's the LNDs
                 * responsibility (if it cares at all)
                 */
-
                if (square != NULL && (comma == NULL || square < comma)) {
                        /*
                         * i.e: o2ib0(ib0)[1,2], number between square
 
                if (bracket == NULL ||
                    (comma != NULL && comma < bracket)) {
-
                        /* no interface list specified */
 
                        if (comma != NULL)
                goto failed;
 
        for (parsed = sep; parsed < sep2; parsed = enditem) {
-
                enditem = ++parsed;
                while (enditem < sep2 && *enditem != ',')
                        enditem++;
 
                if (sscanf(parsed, "%d-%d/%d%n", &lo, &hi,
                           &stride, &scanned) < 3) {
-
                        if (sscanf(parsed, "%d-%d%n", &lo, &hi, &scanned) < 2) {
-
                                /* simple string enumeration */
                                if (lnet_expand1tb(&pending, str, sep, sep2,
                                                   parsed,
                        goto failed;
 
                for (i = lo; i <= hi; i += stride) {
-
                        snprintf(num, sizeof(num), "%d", i);
                        nob = strlen(num);
                        if (nob + 1 == sizeof(num))
 
        lmd->md_flags = (unlink == LNET_UNLINK) ? LNET_MD_FLAG_AUTO_UNLINK : 0;
 
        if ((umd->options & LNET_MD_IOVEC) != 0) {
-
                if ((umd->options & LNET_MD_KIOV) != 0) /* Can't specify both */
                        return -EINVAL;
 
 
                      hdr->msg.reply.dst_wmd.wh_object_cookie,
                      hdr->payload_length);
        }
-
 }
 
 int
        /* msg zeroed in lnet_msg_alloc;
         * i.e. flags all clear, pointers NULL etc
         */
-
        msg->msg_type = type;
        msg->msg_private = private;
        msg->msg_receiving = 1;
 
                ev->initiator.nid = LNET_NID_ANY;
                ev->initiator.pid = the_lnet.ln_pid;
                ev->sender        = LNET_NID_ANY;
-
        } else {
                /* event for passive message */
                ev->target.pid    = hdr->dest_pid;
 
                CERROR("Error %d creating route %s %d %s\n", rc,
                       libcfs_net2str(net), hops,
                       libcfs_nid2str(gateway));
-
                return rc;
        }
 
 
 srpc_service_t brw_test_service;
 void brw_init_test_service(void)
 {
-
        brw_test_service.sv_id         = SRPC_SERVICE_BRW;
        brw_test_service.sv_name       = "brw_test";
        brw_test_service.sv_handler    = brw_server_handle;
 
                entp->u.tbe_batch.bae_state = bat->bat_state;
 
        } else {
-
                entp->u.tbe_test.tse_type   = test->tes_type;
                entp->u.tbe_test.tse_loop   = test->tes_loop;
                entp->u.tbe_test.tse_concur = test->tes_concur;