]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/staging/lustre/lnet/lnet/api-ni.c
b2b914a78c649024188f3da7f0e3c914b4bca13d
[karo-tx-linux.git] / drivers / staging / lustre / lnet / lnet / api-ni.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2015, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  */
36
37 #define DEBUG_SUBSYSTEM S_LNET
38 #include <linux/log2.h>
39 #include <linux/ktime.h>
40
41 #include "../../include/linux/lnet/lib-lnet.h"
42 #include "../../include/linux/lnet/lib-dlc.h"
43
44 #define D_LNI D_CONSOLE
45
46 lnet_t the_lnet;                           /* THE state of the network */
47 EXPORT_SYMBOL(the_lnet);
48
49 static char *ip2nets = "";
50 module_param(ip2nets, charp, 0444);
51 MODULE_PARM_DESC(ip2nets, "LNET network <- IP table");
52
53 static char *networks = "";
54 module_param(networks, charp, 0444);
55 MODULE_PARM_DESC(networks, "local networks");
56
57 static char *routes = "";
58 module_param(routes, charp, 0444);
59 MODULE_PARM_DESC(routes, "routes to non-local networks");
60
61 static int rnet_htable_size = LNET_REMOTE_NETS_HASH_DEFAULT;
62 module_param(rnet_htable_size, int, 0444);
63 MODULE_PARM_DESC(rnet_htable_size, "size of remote network hash table");
64
65 static int lnet_ping(lnet_process_id_t id, int timeout_ms,
66                      lnet_process_id_t __user *ids, int n_ids);
67
68 static char *
69 lnet_get_routes(void)
70 {
71         return routes;
72 }
73
74 static char *
75 lnet_get_networks(void)
76 {
77         char *nets;
78         int rc;
79
80         if (*networks && *ip2nets) {
81                 LCONSOLE_ERROR_MSG(0x101, "Please specify EITHER 'networks' or 'ip2nets' but not both at once\n");
82                 return NULL;
83         }
84
85         if (*ip2nets) {
86                 rc = lnet_parse_ip2nets(&nets, ip2nets);
87                 return !rc ? nets : NULL;
88         }
89
90         if (*networks)
91                 return networks;
92
93         return "tcp";
94 }
95
96 static void
97 lnet_init_locks(void)
98 {
99         spin_lock_init(&the_lnet.ln_eq_wait_lock);
100         init_waitqueue_head(&the_lnet.ln_eq_waitq);
101         mutex_init(&the_lnet.ln_lnd_mutex);
102         mutex_init(&the_lnet.ln_api_mutex);
103 }
104
105 static int
106 lnet_create_remote_nets_table(void)
107 {
108         int i;
109         struct list_head *hash;
110
111         LASSERT(!the_lnet.ln_remote_nets_hash);
112         LASSERT(the_lnet.ln_remote_nets_hbits > 0);
113         LIBCFS_ALLOC(hash, LNET_REMOTE_NETS_HASH_SIZE * sizeof(*hash));
114         if (!hash) {
115                 CERROR("Failed to create remote nets hash table\n");
116                 return -ENOMEM;
117         }
118
119         for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE; i++)
120                 INIT_LIST_HEAD(&hash[i]);
121         the_lnet.ln_remote_nets_hash = hash;
122         return 0;
123 }
124
125 static void
126 lnet_destroy_remote_nets_table(void)
127 {
128         int i;
129
130         if (!the_lnet.ln_remote_nets_hash)
131                 return;
132
133         for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE; i++)
134                 LASSERT(list_empty(&the_lnet.ln_remote_nets_hash[i]));
135
136         LIBCFS_FREE(the_lnet.ln_remote_nets_hash,
137                     LNET_REMOTE_NETS_HASH_SIZE *
138                     sizeof(the_lnet.ln_remote_nets_hash[0]));
139         the_lnet.ln_remote_nets_hash = NULL;
140 }
141
142 static void
143 lnet_destroy_locks(void)
144 {
145         if (the_lnet.ln_res_lock) {
146                 cfs_percpt_lock_free(the_lnet.ln_res_lock);
147                 the_lnet.ln_res_lock = NULL;
148         }
149
150         if (the_lnet.ln_net_lock) {
151                 cfs_percpt_lock_free(the_lnet.ln_net_lock);
152                 the_lnet.ln_net_lock = NULL;
153         }
154 }
155
156 static int
157 lnet_create_locks(void)
158 {
159         lnet_init_locks();
160
161         the_lnet.ln_res_lock = cfs_percpt_lock_alloc(lnet_cpt_table());
162         if (!the_lnet.ln_res_lock)
163                 goto failed;
164
165         the_lnet.ln_net_lock = cfs_percpt_lock_alloc(lnet_cpt_table());
166         if (!the_lnet.ln_net_lock)
167                 goto failed;
168
169         return 0;
170
171  failed:
172         lnet_destroy_locks();
173         return -ENOMEM;
174 }
175
176 static void lnet_assert_wire_constants(void)
177 {
178         /*
179          * Wire protocol assertions generated by 'wirecheck'
180          * running on Linux robert.bartonsoftware.com 2.6.8-1.521
181          * #1 Mon Aug 16 09:01:18 EDT 2004 i686 athlon i386 GNU/Linux
182          * with gcc version 3.3.3 20040412 (Red Hat Linux 3.3.3-7)
183          */
184
185         /* Constants... */
186         CLASSERT(LNET_PROTO_TCP_MAGIC == 0xeebc0ded);
187         CLASSERT(LNET_PROTO_TCP_VERSION_MAJOR == 1);
188         CLASSERT(LNET_PROTO_TCP_VERSION_MINOR == 0);
189         CLASSERT(LNET_MSG_ACK == 0);
190         CLASSERT(LNET_MSG_PUT == 1);
191         CLASSERT(LNET_MSG_GET == 2);
192         CLASSERT(LNET_MSG_REPLY == 3);
193         CLASSERT(LNET_MSG_HELLO == 4);
194
195         /* Checks for struct ptl_handle_wire_t */
196         CLASSERT((int)sizeof(lnet_handle_wire_t) == 16);
197         CLASSERT((int)offsetof(lnet_handle_wire_t, wh_interface_cookie) == 0);
198         CLASSERT((int)sizeof(((lnet_handle_wire_t *)0)->wh_interface_cookie) == 8);
199         CLASSERT((int)offsetof(lnet_handle_wire_t, wh_object_cookie) == 8);
200         CLASSERT((int)sizeof(((lnet_handle_wire_t *)0)->wh_object_cookie) == 8);
201
202         /* Checks for struct lnet_magicversion_t */
203         CLASSERT((int)sizeof(lnet_magicversion_t) == 8);
204         CLASSERT((int)offsetof(lnet_magicversion_t, magic) == 0);
205         CLASSERT((int)sizeof(((lnet_magicversion_t *)0)->magic) == 4);
206         CLASSERT((int)offsetof(lnet_magicversion_t, version_major) == 4);
207         CLASSERT((int)sizeof(((lnet_magicversion_t *)0)->version_major) == 2);
208         CLASSERT((int)offsetof(lnet_magicversion_t, version_minor) == 6);
209         CLASSERT((int)sizeof(((lnet_magicversion_t *)0)->version_minor) == 2);
210
211         /* Checks for struct lnet_hdr_t */
212         CLASSERT((int)sizeof(lnet_hdr_t) == 72);
213         CLASSERT((int)offsetof(lnet_hdr_t, dest_nid) == 0);
214         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->dest_nid) == 8);
215         CLASSERT((int)offsetof(lnet_hdr_t, src_nid) == 8);
216         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->src_nid) == 8);
217         CLASSERT((int)offsetof(lnet_hdr_t, dest_pid) == 16);
218         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->dest_pid) == 4);
219         CLASSERT((int)offsetof(lnet_hdr_t, src_pid) == 20);
220         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->src_pid) == 4);
221         CLASSERT((int)offsetof(lnet_hdr_t, type) == 24);
222         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->type) == 4);
223         CLASSERT((int)offsetof(lnet_hdr_t, payload_length) == 28);
224         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->payload_length) == 4);
225         CLASSERT((int)offsetof(lnet_hdr_t, msg) == 32);
226         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg) == 40);
227
228         /* Ack */
229         CLASSERT((int)offsetof(lnet_hdr_t, msg.ack.dst_wmd) == 32);
230         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.ack.dst_wmd) == 16);
231         CLASSERT((int)offsetof(lnet_hdr_t, msg.ack.match_bits) == 48);
232         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.ack.match_bits) == 8);
233         CLASSERT((int)offsetof(lnet_hdr_t, msg.ack.mlength) == 56);
234         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.ack.mlength) == 4);
235
236         /* Put */
237         CLASSERT((int)offsetof(lnet_hdr_t, msg.put.ack_wmd) == 32);
238         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.ack_wmd) == 16);
239         CLASSERT((int)offsetof(lnet_hdr_t, msg.put.match_bits) == 48);
240         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.match_bits) == 8);
241         CLASSERT((int)offsetof(lnet_hdr_t, msg.put.hdr_data) == 56);
242         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.hdr_data) == 8);
243         CLASSERT((int)offsetof(lnet_hdr_t, msg.put.ptl_index) == 64);
244         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.ptl_index) == 4);
245         CLASSERT((int)offsetof(lnet_hdr_t, msg.put.offset) == 68);
246         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.offset) == 4);
247
248         /* Get */
249         CLASSERT((int)offsetof(lnet_hdr_t, msg.get.return_wmd) == 32);
250         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.return_wmd) == 16);
251         CLASSERT((int)offsetof(lnet_hdr_t, msg.get.match_bits) == 48);
252         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.match_bits) == 8);
253         CLASSERT((int)offsetof(lnet_hdr_t, msg.get.ptl_index) == 56);
254         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.ptl_index) == 4);
255         CLASSERT((int)offsetof(lnet_hdr_t, msg.get.src_offset) == 60);
256         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.src_offset) == 4);
257         CLASSERT((int)offsetof(lnet_hdr_t, msg.get.sink_length) == 64);
258         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.sink_length) == 4);
259
260         /* Reply */
261         CLASSERT((int)offsetof(lnet_hdr_t, msg.reply.dst_wmd) == 32);
262         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.reply.dst_wmd) == 16);
263
264         /* Hello */
265         CLASSERT((int)offsetof(lnet_hdr_t, msg.hello.incarnation) == 32);
266         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.hello.incarnation) == 8);
267         CLASSERT((int)offsetof(lnet_hdr_t, msg.hello.type) == 40);
268         CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.hello.type) == 4);
269 }
270
271 static lnd_t *
272 lnet_find_lnd_by_type(__u32 type)
273 {
274         lnd_t *lnd;
275         struct list_head *tmp;
276
277         /* holding lnd mutex */
278         list_for_each(tmp, &the_lnet.ln_lnds) {
279                 lnd = list_entry(tmp, lnd_t, lnd_list);
280
281                 if (lnd->lnd_type == type)
282                         return lnd;
283         }
284
285         return NULL;
286 }
287
288 void
289 lnet_register_lnd(lnd_t *lnd)
290 {
291         mutex_lock(&the_lnet.ln_lnd_mutex);
292
293         LASSERT(the_lnet.ln_init);
294         LASSERT(libcfs_isknown_lnd(lnd->lnd_type));
295         LASSERT(!lnet_find_lnd_by_type(lnd->lnd_type));
296
297         list_add_tail(&lnd->lnd_list, &the_lnet.ln_lnds);
298         lnd->lnd_refcount = 0;
299
300         CDEBUG(D_NET, "%s LND registered\n", libcfs_lnd2str(lnd->lnd_type));
301
302         mutex_unlock(&the_lnet.ln_lnd_mutex);
303 }
304 EXPORT_SYMBOL(lnet_register_lnd);
305
306 void
307 lnet_unregister_lnd(lnd_t *lnd)
308 {
309         mutex_lock(&the_lnet.ln_lnd_mutex);
310
311         LASSERT(the_lnet.ln_init);
312         LASSERT(lnet_find_lnd_by_type(lnd->lnd_type) == lnd);
313         LASSERT(!lnd->lnd_refcount);
314
315         list_del(&lnd->lnd_list);
316         CDEBUG(D_NET, "%s LND unregistered\n", libcfs_lnd2str(lnd->lnd_type));
317
318         mutex_unlock(&the_lnet.ln_lnd_mutex);
319 }
320 EXPORT_SYMBOL(lnet_unregister_lnd);
321
322 void
323 lnet_counters_get(lnet_counters_t *counters)
324 {
325         lnet_counters_t *ctr;
326         int i;
327
328         memset(counters, 0, sizeof(*counters));
329
330         lnet_net_lock(LNET_LOCK_EX);
331
332         cfs_percpt_for_each(ctr, i, the_lnet.ln_counters) {
333                 counters->msgs_max     += ctr->msgs_max;
334                 counters->msgs_alloc   += ctr->msgs_alloc;
335                 counters->errors       += ctr->errors;
336                 counters->send_count   += ctr->send_count;
337                 counters->recv_count   += ctr->recv_count;
338                 counters->route_count  += ctr->route_count;
339                 counters->drop_count   += ctr->drop_count;
340                 counters->send_length  += ctr->send_length;
341                 counters->recv_length  += ctr->recv_length;
342                 counters->route_length += ctr->route_length;
343                 counters->drop_length  += ctr->drop_length;
344         }
345         lnet_net_unlock(LNET_LOCK_EX);
346 }
347 EXPORT_SYMBOL(lnet_counters_get);
348
349 void
350 lnet_counters_reset(void)
351 {
352         lnet_counters_t *counters;
353         int i;
354
355         lnet_net_lock(LNET_LOCK_EX);
356
357         cfs_percpt_for_each(counters, i, the_lnet.ln_counters)
358                 memset(counters, 0, sizeof(lnet_counters_t));
359
360         lnet_net_unlock(LNET_LOCK_EX);
361 }
362
363 static char *
364 lnet_res_type2str(int type)
365 {
366         switch (type) {
367         default:
368                 LBUG();
369         case LNET_COOKIE_TYPE_MD:
370                 return "MD";
371         case LNET_COOKIE_TYPE_ME:
372                 return "ME";
373         case LNET_COOKIE_TYPE_EQ:
374                 return "EQ";
375         }
376 }
377
378 static void
379 lnet_res_container_cleanup(struct lnet_res_container *rec)
380 {
381         int count = 0;
382
383         if (!rec->rec_type) /* not set yet, it's uninitialized */
384                 return;
385
386         while (!list_empty(&rec->rec_active)) {
387                 struct list_head *e = rec->rec_active.next;
388
389                 list_del_init(e);
390                 if (rec->rec_type == LNET_COOKIE_TYPE_EQ) {
391                         lnet_eq_free(list_entry(e, lnet_eq_t, eq_list));
392
393                 } else if (rec->rec_type == LNET_COOKIE_TYPE_MD) {
394                         lnet_md_free(list_entry(e, lnet_libmd_t, md_list));
395
396                 } else { /* NB: Active MEs should be attached on portals */
397                         LBUG();
398                 }
399                 count++;
400         }
401
402         if (count > 0) {
403                 /*
404                  * Found alive MD/ME/EQ, user really should unlink/free
405                  * all of them before finalize LNet, but if someone didn't,
406                  * we have to recycle garbage for him
407                  */
408                 CERROR("%d active elements on exit of %s container\n",
409                        count, lnet_res_type2str(rec->rec_type));
410         }
411
412         if (rec->rec_lh_hash) {
413                 LIBCFS_FREE(rec->rec_lh_hash,
414                             LNET_LH_HASH_SIZE * sizeof(rec->rec_lh_hash[0]));
415                 rec->rec_lh_hash = NULL;
416         }
417
418         rec->rec_type = 0; /* mark it as finalized */
419 }
420
421 static int
422 lnet_res_container_setup(struct lnet_res_container *rec, int cpt, int type)
423 {
424         int rc = 0;
425         int i;
426
427         LASSERT(!rec->rec_type);
428
429         rec->rec_type = type;
430         INIT_LIST_HEAD(&rec->rec_active);
431         rec->rec_lh_cookie = (cpt << LNET_COOKIE_TYPE_BITS) | type;
432
433         /* Arbitrary choice of hash table size */
434         LIBCFS_CPT_ALLOC(rec->rec_lh_hash, lnet_cpt_table(), cpt,
435                          LNET_LH_HASH_SIZE * sizeof(rec->rec_lh_hash[0]));
436         if (!rec->rec_lh_hash) {
437                 rc = -ENOMEM;
438                 goto out;
439         }
440
441         for (i = 0; i < LNET_LH_HASH_SIZE; i++)
442                 INIT_LIST_HEAD(&rec->rec_lh_hash[i]);
443
444         return 0;
445
446 out:
447         CERROR("Failed to setup %s resource container\n",
448                lnet_res_type2str(type));
449         lnet_res_container_cleanup(rec);
450         return rc;
451 }
452
453 static void
454 lnet_res_containers_destroy(struct lnet_res_container **recs)
455 {
456         struct lnet_res_container *rec;
457         int i;
458
459         cfs_percpt_for_each(rec, i, recs)
460                 lnet_res_container_cleanup(rec);
461
462         cfs_percpt_free(recs);
463 }
464
465 static struct lnet_res_container **
466 lnet_res_containers_create(int type)
467 {
468         struct lnet_res_container **recs;
469         struct lnet_res_container *rec;
470         int rc;
471         int i;
472
473         recs = cfs_percpt_alloc(lnet_cpt_table(), sizeof(*rec));
474         if (!recs) {
475                 CERROR("Failed to allocate %s resource containers\n",
476                        lnet_res_type2str(type));
477                 return NULL;
478         }
479
480         cfs_percpt_for_each(rec, i, recs) {
481                 rc = lnet_res_container_setup(rec, i, type);
482                 if (rc) {
483                         lnet_res_containers_destroy(recs);
484                         return NULL;
485                 }
486         }
487
488         return recs;
489 }
490
491 lnet_libhandle_t *
492 lnet_res_lh_lookup(struct lnet_res_container *rec, __u64 cookie)
493 {
494         /* ALWAYS called with lnet_res_lock held */
495         struct list_head *head;
496         lnet_libhandle_t *lh;
497         unsigned int hash;
498
499         if ((cookie & LNET_COOKIE_MASK) != rec->rec_type)
500                 return NULL;
501
502         hash = cookie >> (LNET_COOKIE_TYPE_BITS + LNET_CPT_BITS);
503         head = &rec->rec_lh_hash[hash & LNET_LH_HASH_MASK];
504
505         list_for_each_entry(lh, head, lh_hash_chain) {
506                 if (lh->lh_cookie == cookie)
507                         return lh;
508         }
509
510         return NULL;
511 }
512
513 void
514 lnet_res_lh_initialize(struct lnet_res_container *rec, lnet_libhandle_t *lh)
515 {
516         /* ALWAYS called with lnet_res_lock held */
517         unsigned int ibits = LNET_COOKIE_TYPE_BITS + LNET_CPT_BITS;
518         unsigned int hash;
519
520         lh->lh_cookie = rec->rec_lh_cookie;
521         rec->rec_lh_cookie += 1 << ibits;
522
523         hash = (lh->lh_cookie >> ibits) & LNET_LH_HASH_MASK;
524
525         list_add(&lh->lh_hash_chain, &rec->rec_lh_hash[hash]);
526 }
527
528 int lnet_unprepare(void);
529
530 static int
531 lnet_prepare(lnet_pid_t requested_pid)
532 {
533         /* Prepare to bring up the network */
534         struct lnet_res_container **recs;
535         int rc = 0;
536
537         if (requested_pid == LNET_PID_ANY) {
538                 /* Don't instantiate LNET just for me */
539                 return -ENETDOWN;
540         }
541
542         LASSERT(!the_lnet.ln_refcount);
543
544         the_lnet.ln_routing = 0;
545
546         LASSERT(!(requested_pid & LNET_PID_USERFLAG));
547         the_lnet.ln_pid = requested_pid;
548
549         INIT_LIST_HEAD(&the_lnet.ln_test_peers);
550         INIT_LIST_HEAD(&the_lnet.ln_nis);
551         INIT_LIST_HEAD(&the_lnet.ln_nis_cpt);
552         INIT_LIST_HEAD(&the_lnet.ln_nis_zombie);
553         INIT_LIST_HEAD(&the_lnet.ln_routers);
554
555         rc = lnet_create_remote_nets_table();
556         if (rc)
557                 goto failed;
558         /*
559          * NB the interface cookie in wire handles guards against delayed
560          * replies and ACKs appearing valid after reboot.
561          */
562         the_lnet.ln_interface_cookie = ktime_get_ns();
563
564         the_lnet.ln_counters = cfs_percpt_alloc(lnet_cpt_table(),
565                                                 sizeof(lnet_counters_t));
566         if (!the_lnet.ln_counters) {
567                 CERROR("Failed to allocate counters for LNet\n");
568                 rc = -ENOMEM;
569                 goto failed;
570         }
571
572         rc = lnet_peer_tables_create();
573         if (rc)
574                 goto failed;
575
576         rc = lnet_msg_containers_create();
577         if (rc)
578                 goto failed;
579
580         rc = lnet_res_container_setup(&the_lnet.ln_eq_container, 0,
581                                       LNET_COOKIE_TYPE_EQ);
582         if (rc)
583                 goto failed;
584
585         recs = lnet_res_containers_create(LNET_COOKIE_TYPE_ME);
586         if (!recs) {
587                 rc = -ENOMEM;
588                 goto failed;
589         }
590
591         the_lnet.ln_me_containers = recs;
592
593         recs = lnet_res_containers_create(LNET_COOKIE_TYPE_MD);
594         if (!recs) {
595                 rc = -ENOMEM;
596                 goto failed;
597         }
598
599         the_lnet.ln_md_containers = recs;
600
601         rc = lnet_portals_create();
602         if (rc) {
603                 CERROR("Failed to create portals for LNet: %d\n", rc);
604                 goto failed;
605         }
606
607         return 0;
608
609  failed:
610         lnet_unprepare();
611         return rc;
612 }
613
614 int
615 lnet_unprepare(void)
616 {
617         /*
618          * NB no LNET_LOCK since this is the last reference.  All LND instances
619          * have shut down already, so it is safe to unlink and free all
620          * descriptors, even those that appear committed to a network op (eg MD
621          * with non-zero pending count)
622          */
623         lnet_fail_nid(LNET_NID_ANY, 0);
624
625         LASSERT(!the_lnet.ln_refcount);
626         LASSERT(list_empty(&the_lnet.ln_test_peers));
627         LASSERT(list_empty(&the_lnet.ln_nis));
628         LASSERT(list_empty(&the_lnet.ln_nis_cpt));
629         LASSERT(list_empty(&the_lnet.ln_nis_zombie));
630
631         lnet_portals_destroy();
632
633         if (the_lnet.ln_md_containers) {
634                 lnet_res_containers_destroy(the_lnet.ln_md_containers);
635                 the_lnet.ln_md_containers = NULL;
636         }
637
638         if (the_lnet.ln_me_containers) {
639                 lnet_res_containers_destroy(the_lnet.ln_me_containers);
640                 the_lnet.ln_me_containers = NULL;
641         }
642
643         lnet_res_container_cleanup(&the_lnet.ln_eq_container);
644
645         lnet_msg_containers_destroy();
646         lnet_peer_tables_destroy();
647         lnet_rtrpools_free(0);
648
649         if (the_lnet.ln_counters) {
650                 cfs_percpt_free(the_lnet.ln_counters);
651                 the_lnet.ln_counters = NULL;
652         }
653         lnet_destroy_remote_nets_table();
654
655         return 0;
656 }
657
658 lnet_ni_t  *
659 lnet_net2ni_locked(__u32 net, int cpt)
660 {
661         struct list_head *tmp;
662         lnet_ni_t *ni;
663
664         LASSERT(cpt != LNET_LOCK_EX);
665
666         list_for_each(tmp, &the_lnet.ln_nis) {
667                 ni = list_entry(tmp, lnet_ni_t, ni_list);
668
669                 if (LNET_NIDNET(ni->ni_nid) == net) {
670                         lnet_ni_addref_locked(ni, cpt);
671                         return ni;
672                 }
673         }
674
675         return NULL;
676 }
677
678 lnet_ni_t *
679 lnet_net2ni(__u32 net)
680 {
681         lnet_ni_t *ni;
682
683         lnet_net_lock(0);
684         ni = lnet_net2ni_locked(net, 0);
685         lnet_net_unlock(0);
686
687         return ni;
688 }
689 EXPORT_SYMBOL(lnet_net2ni);
690
691 static unsigned int
692 lnet_nid_cpt_hash(lnet_nid_t nid, unsigned int number)
693 {
694         __u64 key = nid;
695         unsigned int val;
696
697         LASSERT(number >= 1 && number <= LNET_CPT_NUMBER);
698
699         if (number == 1)
700                 return 0;
701
702         val = hash_long(key, LNET_CPT_BITS);
703         /* NB: LNET_CP_NUMBER doesn't have to be PO2 */
704         if (val < number)
705                 return val;
706
707         return (unsigned int)(key + val + (val >> 1)) % number;
708 }
709
710 int
711 lnet_cpt_of_nid_locked(lnet_nid_t nid)
712 {
713         struct lnet_ni *ni;
714
715         /* must called with hold of lnet_net_lock */
716         if (LNET_CPT_NUMBER == 1)
717                 return 0; /* the only one */
718
719         /* take lnet_net_lock(any) would be OK */
720         if (!list_empty(&the_lnet.ln_nis_cpt)) {
721                 list_for_each_entry(ni, &the_lnet.ln_nis_cpt, ni_cptlist) {
722                         if (LNET_NIDNET(ni->ni_nid) != LNET_NIDNET(nid))
723                                 continue;
724
725                         LASSERT(ni->ni_cpts);
726                         return ni->ni_cpts[lnet_nid_cpt_hash
727                                            (nid, ni->ni_ncpts)];
728                 }
729         }
730
731         return lnet_nid_cpt_hash(nid, LNET_CPT_NUMBER);
732 }
733
734 int
735 lnet_cpt_of_nid(lnet_nid_t nid)
736 {
737         int cpt;
738         int cpt2;
739
740         if (LNET_CPT_NUMBER == 1)
741                 return 0; /* the only one */
742
743         if (list_empty(&the_lnet.ln_nis_cpt))
744                 return lnet_nid_cpt_hash(nid, LNET_CPT_NUMBER);
745
746         cpt = lnet_net_lock_current();
747         cpt2 = lnet_cpt_of_nid_locked(nid);
748         lnet_net_unlock(cpt);
749
750         return cpt2;
751 }
752 EXPORT_SYMBOL(lnet_cpt_of_nid);
753
754 int
755 lnet_islocalnet(__u32 net)
756 {
757         struct lnet_ni *ni;
758         int cpt;
759
760         cpt = lnet_net_lock_current();
761
762         ni = lnet_net2ni_locked(net, cpt);
763         if (ni)
764                 lnet_ni_decref_locked(ni, cpt);
765
766         lnet_net_unlock(cpt);
767
768         return !!ni;
769 }
770
771 lnet_ni_t  *
772 lnet_nid2ni_locked(lnet_nid_t nid, int cpt)
773 {
774         struct lnet_ni *ni;
775         struct list_head *tmp;
776
777         LASSERT(cpt != LNET_LOCK_EX);
778
779         list_for_each(tmp, &the_lnet.ln_nis) {
780                 ni = list_entry(tmp, lnet_ni_t, ni_list);
781
782                 if (ni->ni_nid == nid) {
783                         lnet_ni_addref_locked(ni, cpt);
784                         return ni;
785                 }
786         }
787
788         return NULL;
789 }
790
791 int
792 lnet_islocalnid(lnet_nid_t nid)
793 {
794         struct lnet_ni *ni;
795         int cpt;
796
797         cpt = lnet_net_lock_current();
798         ni = lnet_nid2ni_locked(nid, cpt);
799         if (ni)
800                 lnet_ni_decref_locked(ni, cpt);
801         lnet_net_unlock(cpt);
802
803         return !!ni;
804 }
805
806 int
807 lnet_count_acceptor_nis(void)
808 {
809         /* Return the # of NIs that need the acceptor. */
810         int count = 0;
811         struct list_head *tmp;
812         struct lnet_ni *ni;
813         int cpt;
814
815         cpt = lnet_net_lock_current();
816         list_for_each(tmp, &the_lnet.ln_nis) {
817                 ni = list_entry(tmp, lnet_ni_t, ni_list);
818
819                 if (ni->ni_lnd->lnd_accept)
820                         count++;
821         }
822
823         lnet_net_unlock(cpt);
824
825         return count;
826 }
827
828 static lnet_ping_info_t *
829 lnet_ping_info_create(int num_ni)
830 {
831         lnet_ping_info_t *ping_info;
832         unsigned int infosz;
833
834         infosz = offsetof(lnet_ping_info_t, pi_ni[num_ni]);
835         LIBCFS_ALLOC(ping_info, infosz);
836         if (!ping_info) {
837                 CERROR("Can't allocate ping info[%d]\n", num_ni);
838                 return NULL;
839         }
840
841         ping_info->pi_nnis = num_ni;
842         ping_info->pi_pid = the_lnet.ln_pid;
843         ping_info->pi_magic = LNET_PROTO_PING_MAGIC;
844         ping_info->pi_features = LNET_PING_FEAT_NI_STATUS;
845
846         return ping_info;
847 }
848
849 static inline int
850 lnet_get_ni_count(void)
851 {
852         struct lnet_ni *ni;
853         int count = 0;
854
855         lnet_net_lock(0);
856
857         list_for_each_entry(ni, &the_lnet.ln_nis, ni_list)
858                 count++;
859
860         lnet_net_unlock(0);
861
862         return count;
863 }
864
865 static inline void
866 lnet_ping_info_free(lnet_ping_info_t *pinfo)
867 {
868         LIBCFS_FREE(pinfo,
869                     offsetof(lnet_ping_info_t,
870                              pi_ni[pinfo->pi_nnis]));
871 }
872
873 static void
874 lnet_ping_info_destroy(void)
875 {
876         struct lnet_ni *ni;
877
878         lnet_net_lock(LNET_LOCK_EX);
879
880         list_for_each_entry(ni, &the_lnet.ln_nis, ni_list) {
881                 lnet_ni_lock(ni);
882                 ni->ni_status = NULL;
883                 lnet_ni_unlock(ni);
884         }
885
886         lnet_ping_info_free(the_lnet.ln_ping_info);
887         the_lnet.ln_ping_info = NULL;
888
889         lnet_net_unlock(LNET_LOCK_EX);
890 }
891
892 static void
893 lnet_ping_event_handler(lnet_event_t *event)
894 {
895         lnet_ping_info_t *pinfo = event->md.user_ptr;
896
897         if (event->unlinked)
898                 pinfo->pi_features = LNET_PING_FEAT_INVAL;
899 }
900
901 static int
902 lnet_ping_info_setup(lnet_ping_info_t **ppinfo, lnet_handle_md_t *md_handle,
903                      int ni_count, bool set_eq)
904 {
905         lnet_process_id_t id = {LNET_NID_ANY, LNET_PID_ANY};
906         lnet_handle_me_t me_handle;
907         lnet_md_t md = {0};
908         int rc, rc2;
909
910         if (set_eq) {
911                 rc = LNetEQAlloc(0, lnet_ping_event_handler,
912                                  &the_lnet.ln_ping_target_eq);
913                 if (rc) {
914                         CERROR("Can't allocate ping EQ: %d\n", rc);
915                         return rc;
916                 }
917         }
918
919         *ppinfo = lnet_ping_info_create(ni_count);
920         if (!*ppinfo) {
921                 rc = -ENOMEM;
922                 goto failed_0;
923         }
924
925         rc = LNetMEAttach(LNET_RESERVED_PORTAL, id,
926                           LNET_PROTO_PING_MATCHBITS, 0,
927                           LNET_UNLINK, LNET_INS_AFTER,
928                           &me_handle);
929         if (rc) {
930                 CERROR("Can't create ping ME: %d\n", rc);
931                 goto failed_1;
932         }
933
934         /* initialize md content */
935         md.start = *ppinfo;
936         md.length = offsetof(lnet_ping_info_t,
937                              pi_ni[(*ppinfo)->pi_nnis]);
938         md.threshold = LNET_MD_THRESH_INF;
939         md.max_size = 0;
940         md.options = LNET_MD_OP_GET | LNET_MD_TRUNCATE |
941                      LNET_MD_MANAGE_REMOTE;
942         md.user_ptr  = NULL;
943         md.eq_handle = the_lnet.ln_ping_target_eq;
944         md.user_ptr = *ppinfo;
945
946         rc = LNetMDAttach(me_handle, md, LNET_RETAIN, md_handle);
947         if (rc) {
948                 CERROR("Can't attach ping MD: %d\n", rc);
949                 goto failed_2;
950         }
951
952         return 0;
953
954 failed_2:
955         rc2 = LNetMEUnlink(me_handle);
956         LASSERT(!rc2);
957 failed_1:
958         lnet_ping_info_free(*ppinfo);
959         *ppinfo = NULL;
960 failed_0:
961         if (set_eq)
962                 LNetEQFree(the_lnet.ln_ping_target_eq);
963         return rc;
964 }
965
966 static void
967 lnet_ping_md_unlink(lnet_ping_info_t *pinfo, lnet_handle_md_t *md_handle)
968 {
969         sigset_t blocked = cfs_block_allsigs();
970
971         LNetMDUnlink(*md_handle);
972         LNetInvalidateHandle(md_handle);
973
974         /* NB md could be busy; this just starts the unlink */
975         while (pinfo->pi_features != LNET_PING_FEAT_INVAL) {
976                 CDEBUG(D_NET, "Still waiting for ping MD to unlink\n");
977                 set_current_state(TASK_UNINTERRUPTIBLE);
978                 schedule_timeout(cfs_time_seconds(1));
979         }
980
981         cfs_restore_sigs(blocked);
982 }
983
984 static void
985 lnet_ping_info_install_locked(lnet_ping_info_t *ping_info)
986 {
987         lnet_ni_status_t *ns;
988         lnet_ni_t *ni;
989         int i = 0;
990
991         list_for_each_entry(ni, &the_lnet.ln_nis, ni_list) {
992                 LASSERT(i < ping_info->pi_nnis);
993
994                 ns = &ping_info->pi_ni[i];
995
996                 ns->ns_nid = ni->ni_nid;
997
998                 lnet_ni_lock(ni);
999                 ns->ns_status = (ni->ni_status) ?
1000                                  ni->ni_status->ns_status : LNET_NI_STATUS_UP;
1001                 ni->ni_status = ns;
1002                 lnet_ni_unlock(ni);
1003
1004                 i++;
1005         }
1006 }
1007
1008 static void
1009 lnet_ping_target_update(lnet_ping_info_t *pinfo, lnet_handle_md_t md_handle)
1010 {
1011         lnet_ping_info_t *old_pinfo = NULL;
1012         lnet_handle_md_t old_md;
1013
1014         /* switch the NIs to point to the new ping info created */
1015         lnet_net_lock(LNET_LOCK_EX);
1016
1017         if (!the_lnet.ln_routing)
1018                 pinfo->pi_features |= LNET_PING_FEAT_RTE_DISABLED;
1019         lnet_ping_info_install_locked(pinfo);
1020
1021         if (the_lnet.ln_ping_info) {
1022                 old_pinfo = the_lnet.ln_ping_info;
1023                 old_md = the_lnet.ln_ping_target_md;
1024         }
1025         the_lnet.ln_ping_target_md = md_handle;
1026         the_lnet.ln_ping_info = pinfo;
1027
1028         lnet_net_unlock(LNET_LOCK_EX);
1029
1030         if (old_pinfo) {
1031                 /* unlink the old ping info */
1032                 lnet_ping_md_unlink(old_pinfo, &old_md);
1033                 lnet_ping_info_free(old_pinfo);
1034         }
1035 }
1036
1037 static void
1038 lnet_ping_target_fini(void)
1039 {
1040         int rc;
1041
1042         lnet_ping_md_unlink(the_lnet.ln_ping_info,
1043                             &the_lnet.ln_ping_target_md);
1044
1045         rc = LNetEQFree(the_lnet.ln_ping_target_eq);
1046         LASSERT(!rc);
1047
1048         lnet_ping_info_destroy();
1049 }
1050
1051 static int
1052 lnet_ni_tq_credits(lnet_ni_t *ni)
1053 {
1054         int credits;
1055
1056         LASSERT(ni->ni_ncpts >= 1);
1057
1058         if (ni->ni_ncpts == 1)
1059                 return ni->ni_maxtxcredits;
1060
1061         credits = ni->ni_maxtxcredits / ni->ni_ncpts;
1062         credits = max(credits, 8 * ni->ni_peertxcredits);
1063         credits = min(credits, ni->ni_maxtxcredits);
1064
1065         return credits;
1066 }
1067
1068 static void
1069 lnet_clear_zombies_nis_locked(void)
1070 {
1071         int i;
1072         int islo;
1073         lnet_ni_t *ni;
1074
1075         /*
1076          * Now wait for the NI's I just nuked to show up on ln_zombie_nis
1077          * and shut them down in guaranteed thread context
1078          */
1079         i = 2;
1080         while (!list_empty(&the_lnet.ln_nis_zombie)) {
1081                 int *ref;
1082                 int j;
1083
1084                 ni = list_entry(the_lnet.ln_nis_zombie.next,
1085                                 lnet_ni_t, ni_list);
1086                 list_del_init(&ni->ni_list);
1087                 cfs_percpt_for_each(ref, j, ni->ni_refs) {
1088                         if (!*ref)
1089                                 continue;
1090                         /* still busy, add it back to zombie list */
1091                         list_add(&ni->ni_list, &the_lnet.ln_nis_zombie);
1092                         break;
1093                 }
1094
1095                 if (!list_empty(&ni->ni_list)) {
1096                         lnet_net_unlock(LNET_LOCK_EX);
1097                         ++i;
1098                         if ((i & (-i)) == i) {
1099                                 CDEBUG(D_WARNING, "Waiting for zombie LNI %s\n",
1100                                        libcfs_nid2str(ni->ni_nid));
1101                         }
1102                         set_current_state(TASK_UNINTERRUPTIBLE);
1103                         schedule_timeout(cfs_time_seconds(1));
1104                         lnet_net_lock(LNET_LOCK_EX);
1105                         continue;
1106                 }
1107
1108                 ni->ni_lnd->lnd_refcount--;
1109                 lnet_net_unlock(LNET_LOCK_EX);
1110
1111                 islo = ni->ni_lnd->lnd_type == LOLND;
1112
1113                 LASSERT(!in_interrupt());
1114                 ni->ni_lnd->lnd_shutdown(ni);
1115
1116                 /*
1117                  * can't deref lnd anymore now; it might have unregistered
1118                  * itself...
1119                  */
1120                 if (!islo)
1121                         CDEBUG(D_LNI, "Removed LNI %s\n",
1122                                libcfs_nid2str(ni->ni_nid));
1123
1124                 lnet_ni_free(ni);
1125                 i = 2;
1126
1127                 lnet_net_lock(LNET_LOCK_EX);
1128         }
1129 }
1130
1131 static void
1132 lnet_shutdown_lndnis(void)
1133 {
1134         lnet_ni_t *ni;
1135         int i;
1136
1137         /* NB called holding the global mutex */
1138
1139         /* All quiet on the API front */
1140         LASSERT(!the_lnet.ln_shutdown);
1141         LASSERT(!the_lnet.ln_refcount);
1142         LASSERT(list_empty(&the_lnet.ln_nis_zombie));
1143
1144         lnet_net_lock(LNET_LOCK_EX);
1145         the_lnet.ln_shutdown = 1;       /* flag shutdown */
1146
1147         /* Unlink NIs from the global table */
1148         while (!list_empty(&the_lnet.ln_nis)) {
1149                 ni = list_entry(the_lnet.ln_nis.next,
1150                                 lnet_ni_t, ni_list);
1151                 /* move it to zombie list and nobody can find it anymore */
1152                 list_move(&ni->ni_list, &the_lnet.ln_nis_zombie);
1153                 lnet_ni_decref_locked(ni, 0);   /* drop ln_nis' ref */
1154
1155                 if (!list_empty(&ni->ni_cptlist)) {
1156                         list_del_init(&ni->ni_cptlist);
1157                         lnet_ni_decref_locked(ni, 0);
1158                 }
1159         }
1160
1161         /* Drop the cached eqwait NI. */
1162         if (the_lnet.ln_eq_waitni) {
1163                 lnet_ni_decref_locked(the_lnet.ln_eq_waitni, 0);
1164                 the_lnet.ln_eq_waitni = NULL;
1165         }
1166
1167         /* Drop the cached loopback NI. */
1168         if (the_lnet.ln_loni) {
1169                 lnet_ni_decref_locked(the_lnet.ln_loni, 0);
1170                 the_lnet.ln_loni = NULL;
1171         }
1172
1173         lnet_net_unlock(LNET_LOCK_EX);
1174
1175         /*
1176          * Clear lazy portals and drop delayed messages which hold refs
1177          * on their lnet_msg_t::msg_rxpeer
1178          */
1179         for (i = 0; i < the_lnet.ln_nportals; i++)
1180                 LNetClearLazyPortal(i);
1181
1182         /*
1183          * Clear the peer table and wait for all peers to go (they hold refs on
1184          * their NIs)
1185          */
1186         lnet_peer_tables_cleanup(NULL);
1187
1188         lnet_net_lock(LNET_LOCK_EX);
1189
1190         lnet_clear_zombies_nis_locked();
1191         the_lnet.ln_shutdown = 0;
1192         lnet_net_unlock(LNET_LOCK_EX);
1193 }
1194
1195 int
1196 lnet_shutdown_lndni(__u32 net)
1197 {
1198         lnet_ping_info_t *pinfo;
1199         lnet_handle_md_t md_handle;
1200         lnet_ni_t *found_ni = NULL;
1201         int ni_count;
1202         int rc;
1203
1204         if (LNET_NETTYP(net) == LOLND)
1205                 return -EINVAL;
1206
1207         ni_count = lnet_get_ni_count();
1208
1209         /* create and link a new ping info, before removing the old one */
1210         rc = lnet_ping_info_setup(&pinfo, &md_handle, ni_count - 1, false);
1211         if (rc)
1212                 return rc;
1213
1214         /* proceed with shutting down the NI */
1215         lnet_net_lock(LNET_LOCK_EX);
1216
1217         found_ni = lnet_net2ni_locked(net, 0);
1218         if (!found_ni) {
1219                 lnet_net_unlock(LNET_LOCK_EX);
1220                 lnet_ping_md_unlink(pinfo, &md_handle);
1221                 lnet_ping_info_free(pinfo);
1222                 return -EINVAL;
1223         }
1224
1225         /*
1226          * decrement the reference counter on found_ni which was
1227          * incremented when we called lnet_net2ni_locked()
1228          */
1229         lnet_ni_decref_locked(found_ni, 0);
1230         /* Move ni to zombie list so nobody can find it anymore */
1231         list_move(&found_ni->ni_list, &the_lnet.ln_nis_zombie);
1232
1233         /* Drop the lock reference for the ln_nis ref. */
1234         lnet_ni_decref_locked(found_ni, 0);
1235
1236         if (!list_empty(&found_ni->ni_cptlist)) {
1237                 list_del_init(&found_ni->ni_cptlist);
1238                 lnet_ni_decref_locked(found_ni, 0);
1239         }
1240
1241         lnet_net_unlock(LNET_LOCK_EX);
1242
1243         /* Do peer table cleanup for this ni */
1244         lnet_peer_tables_cleanup(found_ni);
1245
1246         lnet_net_lock(LNET_LOCK_EX);
1247         lnet_clear_zombies_nis_locked();
1248         lnet_net_unlock(LNET_LOCK_EX);
1249
1250         lnet_ping_target_update(pinfo, md_handle);
1251
1252         return 0;
1253 }
1254
1255 static int
1256 lnet_startup_lndnis(struct list_head *nilist, __s32 peer_timeout,
1257                     __s32 peer_cr, __s32 peer_buf_cr, __s32 credits,
1258                     int *ni_count)
1259 {
1260         lnd_t *lnd;
1261         struct lnet_ni *ni;
1262         struct lnet_tx_queue *tq;
1263         int i;
1264         int rc = 0;
1265         __u32 lnd_type;
1266
1267         while (!list_empty(nilist)) {
1268                 ni = list_entry(nilist->next, lnet_ni_t, ni_list);
1269                 lnd_type = LNET_NETTYP(LNET_NIDNET(ni->ni_nid));
1270
1271                 if (!libcfs_isknown_lnd(lnd_type))
1272                         goto failed;
1273
1274                 if (lnd_type == CIBLND    ||
1275                     lnd_type == OPENIBLND ||
1276                     lnd_type == IIBLND    ||
1277                     lnd_type == VIBLND) {
1278                         CERROR("LND %s obsoleted\n",
1279                                libcfs_lnd2str(lnd_type));
1280                         goto failed;
1281                 }
1282
1283                 /* Make sure this new NI is unique. */
1284                 lnet_net_lock(LNET_LOCK_EX);
1285                 if (!lnet_net_unique(LNET_NIDNET(ni->ni_nid),
1286                                      &the_lnet.ln_nis)) {
1287                         if (lnd_type == LOLND) {
1288                                 lnet_net_unlock(LNET_LOCK_EX);
1289                                 list_del(&ni->ni_list);
1290                                 lnet_ni_free(ni);
1291                                 continue;
1292                         }
1293
1294                         CERROR("Net %s is not unique\n",
1295                                libcfs_net2str(LNET_NIDNET(ni->ni_nid)));
1296                         lnet_net_unlock(LNET_LOCK_EX);
1297                         goto failed;
1298                 }
1299                 lnet_net_unlock(LNET_LOCK_EX);
1300
1301                 mutex_lock(&the_lnet.ln_lnd_mutex);
1302                 lnd = lnet_find_lnd_by_type(lnd_type);
1303
1304                 if (!lnd) {
1305                         mutex_unlock(&the_lnet.ln_lnd_mutex);
1306                         rc = request_module("%s",
1307                                             libcfs_lnd2modname(lnd_type));
1308                         mutex_lock(&the_lnet.ln_lnd_mutex);
1309
1310                         lnd = lnet_find_lnd_by_type(lnd_type);
1311                         if (!lnd) {
1312                                 mutex_unlock(&the_lnet.ln_lnd_mutex);
1313                                 CERROR("Can't load LND %s, module %s, rc=%d\n",
1314                                        libcfs_lnd2str(lnd_type),
1315                                        libcfs_lnd2modname(lnd_type), rc);
1316                                 goto failed;
1317                         }
1318                 }
1319
1320                 lnet_net_lock(LNET_LOCK_EX);
1321                 lnd->lnd_refcount++;
1322                 lnet_net_unlock(LNET_LOCK_EX);
1323
1324                 ni->ni_lnd = lnd;
1325
1326                 rc = lnd->lnd_startup(ni);
1327
1328                 mutex_unlock(&the_lnet.ln_lnd_mutex);
1329
1330                 if (rc) {
1331                         LCONSOLE_ERROR_MSG(0x105, "Error %d starting up LNI %s\n",
1332                                            rc, libcfs_lnd2str(lnd->lnd_type));
1333                         lnet_net_lock(LNET_LOCK_EX);
1334                         lnd->lnd_refcount--;
1335                         lnet_net_unlock(LNET_LOCK_EX);
1336                         goto failed;
1337                 }
1338
1339                 /*
1340                  * If given some LND tunable parameters, parse those now to
1341                  * override the values in the NI structure.
1342                  */
1343                 if (peer_buf_cr >= 0)
1344                         ni->ni_peerrtrcredits = peer_buf_cr;
1345                 if (peer_timeout >= 0)
1346                         ni->ni_peertimeout = peer_timeout;
1347                 /*
1348                  * TODO
1349                  * Note: For now, don't allow the user to change
1350                  * peertxcredits as this number is used in the
1351                  * IB LND to control queue depth.
1352                  * if (peer_cr != -1)
1353                  *      ni->ni_peertxcredits = peer_cr;
1354                  */
1355                 if (credits >= 0)
1356                         ni->ni_maxtxcredits = credits;
1357
1358                 LASSERT(ni->ni_peertimeout <= 0 || lnd->lnd_query);
1359
1360                 list_del(&ni->ni_list);
1361
1362                 lnet_net_lock(LNET_LOCK_EX);
1363                 /* refcount for ln_nis */
1364                 lnet_ni_addref_locked(ni, 0);
1365                 list_add_tail(&ni->ni_list, &the_lnet.ln_nis);
1366                 if (ni->ni_cpts) {
1367                         list_add_tail(&ni->ni_cptlist,
1368                                       &the_lnet.ln_nis_cpt);
1369                         lnet_ni_addref_locked(ni, 0);
1370                 }
1371
1372                 lnet_net_unlock(LNET_LOCK_EX);
1373
1374                 /* increment the ni_count here to account for the LOLND as
1375                  * well.  If we increment past this point then the number
1376                  * of count will be missing the LOLND, and then ping and
1377                  * will not report the LOLND
1378                  */
1379                 if (ni_count)
1380                         (*ni_count)++;
1381
1382                 if (lnd->lnd_type == LOLND) {
1383                         lnet_ni_addref(ni);
1384                         LASSERT(!the_lnet.ln_loni);
1385                         the_lnet.ln_loni = ni;
1386                         continue;
1387                 }
1388
1389                 if (!ni->ni_peertxcredits || !ni->ni_maxtxcredits) {
1390                         LCONSOLE_ERROR_MSG(0x107, "LNI %s has no %scredits\n",
1391                                            libcfs_lnd2str(lnd->lnd_type),
1392                                            !ni->ni_peertxcredits ?
1393                                            "" : "per-peer ");
1394                         goto failed;
1395                 }
1396
1397                 cfs_percpt_for_each(tq, i, ni->ni_tx_queues) {
1398                         tq->tq_credits_min =
1399                         tq->tq_credits_max =
1400                         tq->tq_credits = lnet_ni_tq_credits(ni);
1401                 }
1402
1403                 CDEBUG(D_LNI, "Added LNI %s [%d/%d/%d/%d]\n",
1404                        libcfs_nid2str(ni->ni_nid), ni->ni_peertxcredits,
1405                        lnet_ni_tq_credits(ni) * LNET_CPT_NUMBER,
1406                        ni->ni_peerrtrcredits, ni->ni_peertimeout);
1407         }
1408
1409         return 0;
1410 failed:
1411         while (!list_empty(nilist)) {
1412                 ni = list_entry(nilist->next, lnet_ni_t, ni_list);
1413                 list_del(&ni->ni_list);
1414                 lnet_ni_free(ni);
1415         }
1416         return -EINVAL;
1417 }
1418
1419 /**
1420  * Initialize LNet library.
1421  *
1422  * Only userspace program needs to call this function - it's automatically
1423  * called in the kernel at module loading time. Caller has to call lnet_fini()
1424  * after a call to lnet_init(), if and only if the latter returned 0. It must
1425  * be called exactly once.
1426  *
1427  * \return 0 on success, and -ve on failures.
1428  */
1429 int
1430 lnet_init(void)
1431 {
1432         int rc;
1433
1434         lnet_assert_wire_constants();
1435         LASSERT(!the_lnet.ln_init);
1436
1437         memset(&the_lnet, 0, sizeof(the_lnet));
1438
1439         /* refer to global cfs_cpt_table for now */
1440         the_lnet.ln_cpt_table   = cfs_cpt_table;
1441         the_lnet.ln_cpt_number  = cfs_cpt_number(cfs_cpt_table);
1442
1443         LASSERT(the_lnet.ln_cpt_number > 0);
1444         if (the_lnet.ln_cpt_number > LNET_CPT_MAX) {
1445                 /* we are under risk of consuming all lh_cookie */
1446                 CERROR("Can't have %d CPTs for LNet (max allowed is %d), please change setting of CPT-table and retry\n",
1447                        the_lnet.ln_cpt_number, LNET_CPT_MAX);
1448                 return -1;
1449         }
1450
1451         while ((1 << the_lnet.ln_cpt_bits) < the_lnet.ln_cpt_number)
1452                 the_lnet.ln_cpt_bits++;
1453
1454         rc = lnet_create_locks();
1455         if (rc) {
1456                 CERROR("Can't create LNet global locks: %d\n", rc);
1457                 return -1;
1458         }
1459
1460         the_lnet.ln_refcount = 0;
1461         the_lnet.ln_init = 1;
1462         LNetInvalidateHandle(&the_lnet.ln_rc_eqh);
1463         INIT_LIST_HEAD(&the_lnet.ln_lnds);
1464         INIT_LIST_HEAD(&the_lnet.ln_rcd_zombie);
1465         INIT_LIST_HEAD(&the_lnet.ln_rcd_deathrow);
1466
1467         /*
1468          * The hash table size is the number of bits it takes to express the set
1469          * ln_num_routes, minus 1 (better to under estimate than over so we
1470          * don't waste memory).
1471          */
1472         if (rnet_htable_size <= 0)
1473                 rnet_htable_size = LNET_REMOTE_NETS_HASH_DEFAULT;
1474         else if (rnet_htable_size > LNET_REMOTE_NETS_HASH_MAX)
1475                 rnet_htable_size = LNET_REMOTE_NETS_HASH_MAX;
1476         the_lnet.ln_remote_nets_hbits = max_t(int, 1,
1477                                            order_base_2(rnet_htable_size) - 1);
1478
1479         /*
1480          * All LNDs apart from the LOLND are in separate modules.  They
1481          * register themselves when their module loads, and unregister
1482          * themselves when their module is unloaded.
1483          */
1484         lnet_register_lnd(&the_lolnd);
1485         return 0;
1486 }
1487
1488 /**
1489  * Finalize LNet library.
1490  *
1491  * Only userspace program needs to call this function. It can be called
1492  * at most once.
1493  *
1494  * \pre lnet_init() called with success.
1495  * \pre All LNet users called LNetNIFini() for matching LNetNIInit() calls.
1496  */
1497 void
1498 lnet_fini(void)
1499 {
1500         LASSERT(the_lnet.ln_init);
1501         LASSERT(!the_lnet.ln_refcount);
1502
1503         while (!list_empty(&the_lnet.ln_lnds))
1504                 lnet_unregister_lnd(list_entry(the_lnet.ln_lnds.next,
1505                                                lnd_t, lnd_list));
1506         lnet_destroy_locks();
1507
1508         the_lnet.ln_init = 0;
1509 }
1510
1511 /**
1512  * Set LNet PID and start LNet interfaces, routing, and forwarding.
1513  *
1514  * Userspace program should call this after a successful call to lnet_init().
1515  * Users must call this function at least once before any other functions.
1516  * For each successful call there must be a corresponding call to
1517  * LNetNIFini(). For subsequent calls to LNetNIInit(), \a requested_pid is
1518  * ignored.
1519  *
1520  * The PID used by LNet may be different from the one requested.
1521  * See LNetGetId().
1522  *
1523  * \param requested_pid PID requested by the caller.
1524  *
1525  * \return >= 0 on success, and < 0 error code on failures.
1526  */
1527 int
1528 LNetNIInit(lnet_pid_t requested_pid)
1529 {
1530         int im_a_router = 0;
1531         int rc;
1532         int ni_count = 0;
1533         int lnd_type;
1534         struct lnet_ni *ni;
1535         lnet_ping_info_t *pinfo;
1536         lnet_handle_md_t md_handle;
1537         struct list_head net_head;
1538         char *nets;
1539
1540         INIT_LIST_HEAD(&net_head);
1541
1542         mutex_lock(&the_lnet.ln_api_mutex);
1543
1544         LASSERT(the_lnet.ln_init);
1545         CDEBUG(D_OTHER, "refs %d\n", the_lnet.ln_refcount);
1546
1547         if (the_lnet.ln_refcount > 0) {
1548                 rc = the_lnet.ln_refcount++;
1549                 mutex_unlock(&the_lnet.ln_api_mutex);
1550                 return rc;
1551         }
1552
1553         nets = lnet_get_networks();
1554
1555         rc = lnet_prepare(requested_pid);
1556         if (rc)
1557                 goto failed0;
1558
1559         rc = lnet_parse_networks(&net_head, nets);
1560         if (rc < 0)
1561                 goto failed1;
1562
1563         rc = lnet_startup_lndnis(&net_head, -1, -1, -1, -1, &ni_count);
1564         if (rc)
1565                 goto failed1;
1566
1567         if (the_lnet.ln_eq_waitni && ni_count > 1) {
1568                 lnd_type = the_lnet.ln_eq_waitni->ni_lnd->lnd_type;
1569                 LCONSOLE_ERROR_MSG(0x109, "LND %s can only run single-network\n",
1570                                    libcfs_lnd2str(lnd_type));
1571                 goto failed2;
1572         }
1573
1574         rc = lnet_parse_routes(lnet_get_routes(), &im_a_router);
1575         if (rc)
1576                 goto failed2;
1577
1578         rc = lnet_check_routes();
1579         if (rc)
1580                 goto failed2;
1581
1582         rc = lnet_rtrpools_alloc(im_a_router);
1583         if (rc)
1584                 goto failed2;
1585
1586         rc = lnet_acceptor_start();
1587         if (rc)
1588                 goto failed2;
1589
1590         the_lnet.ln_refcount = 1;
1591         /* Now I may use my own API functions... */
1592
1593         rc = lnet_ping_info_setup(&pinfo, &md_handle, ni_count, true);
1594         if (rc)
1595                 goto failed3;
1596
1597         lnet_ping_target_update(pinfo, md_handle);
1598
1599         rc = lnet_router_checker_start();
1600         if (rc)
1601                 goto failed4;
1602
1603         lnet_router_debugfs_init();
1604
1605         mutex_unlock(&the_lnet.ln_api_mutex);
1606
1607         return 0;
1608
1609  failed4:
1610         the_lnet.ln_refcount = 0;
1611         lnet_ping_md_unlink(pinfo, &md_handle);
1612         lnet_ping_info_free(pinfo);
1613  failed3:
1614         lnet_acceptor_stop();
1615         rc = LNetEQFree(the_lnet.ln_ping_target_eq);
1616         LASSERT(!rc);
1617  failed2:
1618         lnet_destroy_routes();
1619         lnet_shutdown_lndnis();
1620  failed1:
1621         lnet_unprepare();
1622  failed0:
1623         LASSERT(rc < 0);
1624         mutex_unlock(&the_lnet.ln_api_mutex);
1625         while (!list_empty(&net_head)) {
1626                 ni = list_entry(net_head.next, struct lnet_ni, ni_list);
1627                 list_del_init(&ni->ni_list);
1628                 lnet_ni_free(ni);
1629         }
1630         return rc;
1631 }
1632 EXPORT_SYMBOL(LNetNIInit);
1633
1634 /**
1635  * Stop LNet interfaces, routing, and forwarding.
1636  *
1637  * Users must call this function once for each successful call to LNetNIInit().
1638  * Once the LNetNIFini() operation has been started, the results of pending
1639  * API operations are undefined.
1640  *
1641  * \return always 0 for current implementation.
1642  */
1643 int
1644 LNetNIFini(void)
1645 {
1646         mutex_lock(&the_lnet.ln_api_mutex);
1647
1648         LASSERT(the_lnet.ln_init);
1649         LASSERT(the_lnet.ln_refcount > 0);
1650
1651         if (the_lnet.ln_refcount != 1) {
1652                 the_lnet.ln_refcount--;
1653         } else {
1654                 LASSERT(!the_lnet.ln_niinit_self);
1655
1656                 lnet_router_debugfs_fini();
1657                 lnet_router_checker_stop();
1658                 lnet_ping_target_fini();
1659
1660                 /* Teardown fns that use my own API functions BEFORE here */
1661                 the_lnet.ln_refcount = 0;
1662
1663                 lnet_acceptor_stop();
1664                 lnet_destroy_routes();
1665                 lnet_shutdown_lndnis();
1666                 lnet_unprepare();
1667         }
1668
1669         mutex_unlock(&the_lnet.ln_api_mutex);
1670         return 0;
1671 }
1672 EXPORT_SYMBOL(LNetNIFini);
1673
1674 int
1675 lnet_dyn_add_ni(lnet_pid_t requested_pid, char *nets,
1676                 __s32 peer_timeout, __s32 peer_cr, __s32 peer_buf_cr,
1677                 __s32 credits)
1678 {
1679         lnet_ping_info_t *pinfo;
1680         lnet_handle_md_t md_handle;
1681         struct lnet_ni *ni;
1682         struct list_head net_head;
1683         int rc;
1684
1685         INIT_LIST_HEAD(&net_head);
1686
1687         /* Create a ni structure for the network string */
1688         rc = lnet_parse_networks(&net_head, nets);
1689         if (rc < 0)
1690                 return rc;
1691
1692         mutex_lock(&the_lnet.ln_api_mutex);
1693
1694         if (rc > 1) {
1695                 rc = -EINVAL; /* only add one interface per call */
1696                 goto failed0;
1697         }
1698
1699         rc = lnet_ping_info_setup(&pinfo, &md_handle, 1 + lnet_get_ni_count(),
1700                                   false);
1701         if (rc)
1702                 goto failed0;
1703
1704         rc = lnet_startup_lndnis(&net_head, peer_timeout, peer_cr,
1705                                  peer_buf_cr, credits, NULL);
1706         if (rc)
1707                 goto failed1;
1708
1709         lnet_ping_target_update(pinfo, md_handle);
1710         mutex_unlock(&the_lnet.ln_api_mutex);
1711
1712         return 0;
1713
1714 failed1:
1715         lnet_ping_md_unlink(pinfo, &md_handle);
1716         lnet_ping_info_free(pinfo);
1717 failed0:
1718         mutex_unlock(&the_lnet.ln_api_mutex);
1719         while (!list_empty(&net_head)) {
1720                 ni = list_entry(net_head.next, struct lnet_ni, ni_list);
1721                 list_del_init(&ni->ni_list);
1722                 lnet_ni_free(ni);
1723         }
1724         return rc;
1725 }
1726
1727 int
1728 lnet_dyn_del_ni(__u32 net)
1729 {
1730         int rc;
1731
1732         mutex_lock(&the_lnet.ln_api_mutex);
1733         rc = lnet_shutdown_lndni(net);
1734         mutex_unlock(&the_lnet.ln_api_mutex);
1735
1736         return rc;
1737 }
1738
1739 /**
1740  * LNet ioctl handler.
1741  *
1742  */
1743 int
1744 LNetCtl(unsigned int cmd, void *arg)
1745 {
1746         struct libcfs_ioctl_data *data = arg;
1747         struct lnet_ioctl_config_data *config;
1748         lnet_process_id_t id = {0};
1749         lnet_ni_t *ni;
1750         int rc;
1751         unsigned long secs_passed;
1752
1753         LASSERT(the_lnet.ln_init);
1754
1755         switch (cmd) {
1756         case IOC_LIBCFS_GET_NI:
1757                 rc = LNetGetId(data->ioc_count, &id);
1758                 data->ioc_nid = id.nid;
1759                 return rc;
1760
1761         case IOC_LIBCFS_FAIL_NID:
1762                 return lnet_fail_nid(data->ioc_nid, data->ioc_count);
1763
1764         case IOC_LIBCFS_ADD_ROUTE:
1765                 mutex_lock(&the_lnet.ln_api_mutex);
1766                 rc = lnet_add_route(data->ioc_net, data->ioc_count,
1767                                     data->ioc_nid, data->ioc_priority);
1768                 mutex_unlock(&the_lnet.ln_api_mutex);
1769                 return rc ? rc : lnet_check_routes();
1770
1771         case IOC_LIBCFS_DEL_ROUTE:
1772                 config = arg;
1773
1774                 if (config->cfg_hdr.ioc_len < sizeof(*config))
1775                         return -EINVAL;
1776
1777                 mutex_lock(&the_lnet.ln_api_mutex);
1778                 rc = lnet_del_route(config->cfg_net, config->cfg_nid);
1779                 mutex_unlock(&the_lnet.ln_api_mutex);
1780                 return rc;
1781
1782         case IOC_LIBCFS_GET_ROUTE:
1783                 config = arg;
1784
1785                 if (config->cfg_hdr.ioc_len < sizeof(*config))
1786                         return -EINVAL;
1787
1788                 return lnet_get_route(config->cfg_count,
1789                                       &config->cfg_net,
1790                                       &config->cfg_config_u.cfg_route.rtr_hop,
1791                                       &config->cfg_nid,
1792                                       &config->cfg_config_u.cfg_route.rtr_flags,
1793                                       &config->cfg_config_u.cfg_route.rtr_priority);
1794
1795         case IOC_LIBCFS_ADD_NET:
1796                 return 0;
1797
1798         case IOC_LIBCFS_DEL_NET:
1799                 return 0;
1800
1801         case IOC_LIBCFS_GET_NET:
1802                 return 0;
1803
1804         case IOC_LIBCFS_GET_LNET_STATS: {
1805                 struct lnet_ioctl_lnet_stats *lnet_stats = arg;
1806
1807                 if (lnet_stats->st_hdr.ioc_len < sizeof(*lnet_stats))
1808                         return -EINVAL;
1809
1810                 lnet_counters_get(&lnet_stats->st_cntrs);
1811                 return 0;
1812         }
1813
1814         case IOC_LIBCFS_CONFIG_RTR:
1815                 return 0;
1816
1817         case IOC_LIBCFS_ADD_BUF:
1818                 return 0;
1819
1820         case IOC_LIBCFS_GET_BUF:
1821                 return 0;
1822
1823         case IOC_LIBCFS_GET_PEER_INFO:
1824                 return 0;
1825
1826         case IOC_LIBCFS_NOTIFY_ROUTER:
1827                 secs_passed = (ktime_get_real_seconds() - data->ioc_u64[0]);
1828                 return lnet_notify(NULL, data->ioc_nid, data->ioc_flags,
1829                                    jiffies - secs_passed * HZ);
1830
1831         case IOC_LIBCFS_LNET_DIST:
1832                 rc = LNetDist(data->ioc_nid, &data->ioc_nid, &data->ioc_u32[1]);
1833                 if (rc < 0 && rc != -EHOSTUNREACH)
1834                         return rc;
1835
1836                 data->ioc_u32[0] = rc;
1837                 return 0;
1838
1839         case IOC_LIBCFS_TESTPROTOCOMPAT:
1840                 lnet_net_lock(LNET_LOCK_EX);
1841                 the_lnet.ln_testprotocompat = data->ioc_flags;
1842                 lnet_net_unlock(LNET_LOCK_EX);
1843                 return 0;
1844
1845         case IOC_LIBCFS_PING:
1846                 id.nid = data->ioc_nid;
1847                 id.pid = data->ioc_u32[0];
1848                 rc = lnet_ping(id, data->ioc_u32[1], /* timeout */
1849                                data->ioc_pbuf1,
1850                                data->ioc_plen1 / sizeof(lnet_process_id_t));
1851                 if (rc < 0)
1852                         return rc;
1853                 data->ioc_count = rc;
1854                 return 0;
1855
1856         default:
1857                 ni = lnet_net2ni(data->ioc_net);
1858                 if (!ni)
1859                         return -EINVAL;
1860
1861                 if (!ni->ni_lnd->lnd_ctl)
1862                         rc = -EINVAL;
1863                 else
1864                         rc = ni->ni_lnd->lnd_ctl(ni, cmd, arg);
1865
1866                 lnet_ni_decref(ni);
1867                 return rc;
1868         }
1869         /* not reached */
1870 }
1871 EXPORT_SYMBOL(LNetCtl);
1872
1873 void LNetDebugPeer(lnet_process_id_t id)
1874 {
1875         lnet_debug_peer(id.nid);
1876 }
1877 EXPORT_SYMBOL(LNetDebugPeer);
1878
1879 /**
1880  * Retrieve the lnet_process_id_t ID of LNet interface at \a index. Note that
1881  * all interfaces share a same PID, as requested by LNetNIInit().
1882  *
1883  * \param index Index of the interface to look up.
1884  * \param id On successful return, this location will hold the
1885  * lnet_process_id_t ID of the interface.
1886  *
1887  * \retval 0 If an interface exists at \a index.
1888  * \retval -ENOENT If no interface has been found.
1889  */
1890 int
1891 LNetGetId(unsigned int index, lnet_process_id_t *id)
1892 {
1893         struct lnet_ni *ni;
1894         struct list_head *tmp;
1895         int cpt;
1896         int rc = -ENOENT;
1897
1898         LASSERT(the_lnet.ln_init);
1899
1900         /* LNetNI initilization failed? */
1901         if (!the_lnet.ln_refcount)
1902                 return rc;
1903
1904         cpt = lnet_net_lock_current();
1905
1906         list_for_each(tmp, &the_lnet.ln_nis) {
1907                 if (index--)
1908                         continue;
1909
1910                 ni = list_entry(tmp, lnet_ni_t, ni_list);
1911
1912                 id->nid = ni->ni_nid;
1913                 id->pid = the_lnet.ln_pid;
1914                 rc = 0;
1915                 break;
1916         }
1917
1918         lnet_net_unlock(cpt);
1919         return rc;
1920 }
1921 EXPORT_SYMBOL(LNetGetId);
1922
1923 /**
1924  * Print a string representation of handle \a h into buffer \a str of
1925  * \a len bytes.
1926  */
1927 void
1928 LNetSnprintHandle(char *str, int len, lnet_handle_any_t h)
1929 {
1930         snprintf(str, len, "%#llx", h.cookie);
1931 }
1932 EXPORT_SYMBOL(LNetSnprintHandle);
1933
1934 static int lnet_ping(lnet_process_id_t id, int timeout_ms,
1935                      lnet_process_id_t __user *ids, int n_ids)
1936 {
1937         lnet_handle_eq_t eqh;
1938         lnet_handle_md_t mdh;
1939         lnet_event_t event;
1940         lnet_md_t md = { NULL };
1941         int which;
1942         int unlinked = 0;
1943         int replied = 0;
1944         const int a_long_time = 60000; /* mS */
1945         int infosz;
1946         lnet_ping_info_t *info;
1947         lnet_process_id_t tmpid;
1948         int i;
1949         int nob;
1950         int rc;
1951         int rc2;
1952         sigset_t blocked;
1953
1954         infosz = offsetof(lnet_ping_info_t, pi_ni[n_ids]);
1955
1956         if (n_ids <= 0 ||
1957             id.nid == LNET_NID_ANY ||
1958             timeout_ms > 500000 ||            /* arbitrary limit! */
1959             n_ids > 20)                  /* arbitrary limit! */
1960                 return -EINVAL;
1961
1962         if (id.pid == LNET_PID_ANY)
1963                 id.pid = LUSTRE_SRV_LNET_PID;
1964
1965         LIBCFS_ALLOC(info, infosz);
1966         if (!info)
1967                 return -ENOMEM;
1968
1969         /* NB 2 events max (including any unlink event) */
1970         rc = LNetEQAlloc(2, LNET_EQ_HANDLER_NONE, &eqh);
1971         if (rc) {
1972                 CERROR("Can't allocate EQ: %d\n", rc);
1973                 goto out_0;
1974         }
1975
1976         /* initialize md content */
1977         md.start     = info;
1978         md.length    = infosz;
1979         md.threshold = 2; /*GET/REPLY*/
1980         md.max_size  = 0;
1981         md.options   = LNET_MD_TRUNCATE;
1982         md.user_ptr  = NULL;
1983         md.eq_handle = eqh;
1984
1985         rc = LNetMDBind(md, LNET_UNLINK, &mdh);
1986         if (rc) {
1987                 CERROR("Can't bind MD: %d\n", rc);
1988                 goto out_1;
1989         }
1990
1991         rc = LNetGet(LNET_NID_ANY, mdh, id,
1992                      LNET_RESERVED_PORTAL,
1993                      LNET_PROTO_PING_MATCHBITS, 0);
1994
1995         if (rc) {
1996                 /* Don't CERROR; this could be deliberate! */
1997
1998                 rc2 = LNetMDUnlink(mdh);
1999                 LASSERT(!rc2);
2000
2001                 /* NB must wait for the UNLINK event below... */
2002                 unlinked = 1;
2003                 timeout_ms = a_long_time;
2004         }
2005
2006         do {
2007                 /* MUST block for unlink to complete */
2008                 if (unlinked)
2009                         blocked = cfs_block_allsigs();
2010
2011                 rc2 = LNetEQPoll(&eqh, 1, timeout_ms, &event, &which);
2012
2013                 if (unlinked)
2014                         cfs_restore_sigs(blocked);
2015
2016                 CDEBUG(D_NET, "poll %d(%d %d)%s\n", rc2,
2017                        (rc2 <= 0) ? -1 : event.type,
2018                        (rc2 <= 0) ? -1 : event.status,
2019                        (rc2 > 0 && event.unlinked) ? " unlinked" : "");
2020
2021                 LASSERT(rc2 != -EOVERFLOW);     /* can't miss anything */
2022
2023                 if (rc2 <= 0 || event.status) {
2024                         /* timeout or error */
2025                         if (!replied && !rc)
2026                                 rc = (rc2 < 0) ? rc2 :
2027                                      !rc2 ? -ETIMEDOUT :
2028                                      event.status;
2029
2030                         if (!unlinked) {
2031                                 /* Ensure completion in finite time... */
2032                                 LNetMDUnlink(mdh);
2033                                 /* No assertion (racing with network) */
2034                                 unlinked = 1;
2035                                 timeout_ms = a_long_time;
2036                         } else if (!rc2) {
2037                                 /* timed out waiting for unlink */
2038                                 CWARN("ping %s: late network completion\n",
2039                                       libcfs_id2str(id));
2040                         }
2041                 } else if (event.type == LNET_EVENT_REPLY) {
2042                         replied = 1;
2043                         rc = event.mlength;
2044                 }
2045
2046         } while (rc2 <= 0 || !event.unlinked);
2047
2048         if (!replied) {
2049                 if (rc >= 0)
2050                         CWARN("%s: Unexpected rc >= 0 but no reply!\n",
2051                               libcfs_id2str(id));
2052                 rc = -EIO;
2053                 goto out_1;
2054         }
2055
2056         nob = rc;
2057         LASSERT(nob >= 0 && nob <= infosz);
2058
2059         rc = -EPROTO;                      /* if I can't parse... */
2060
2061         if (nob < 8) {
2062                 /* can't check magic/version */
2063                 CERROR("%s: ping info too short %d\n",
2064                        libcfs_id2str(id), nob);
2065                 goto out_1;
2066         }
2067
2068         if (info->pi_magic == __swab32(LNET_PROTO_PING_MAGIC)) {
2069                 lnet_swap_pinginfo(info);
2070         } else if (info->pi_magic != LNET_PROTO_PING_MAGIC) {
2071                 CERROR("%s: Unexpected magic %08x\n",
2072                        libcfs_id2str(id), info->pi_magic);
2073                 goto out_1;
2074         }
2075
2076         if (!(info->pi_features & LNET_PING_FEAT_NI_STATUS)) {
2077                 CERROR("%s: ping w/o NI status: 0x%x\n",
2078                        libcfs_id2str(id), info->pi_features);
2079                 goto out_1;
2080         }
2081
2082         if (nob < offsetof(lnet_ping_info_t, pi_ni[0])) {
2083                 CERROR("%s: Short reply %d(%d min)\n", libcfs_id2str(id),
2084                        nob, (int)offsetof(lnet_ping_info_t, pi_ni[0]));
2085                 goto out_1;
2086         }
2087
2088         if (info->pi_nnis < n_ids)
2089                 n_ids = info->pi_nnis;
2090
2091         if (nob < offsetof(lnet_ping_info_t, pi_ni[n_ids])) {
2092                 CERROR("%s: Short reply %d(%d expected)\n", libcfs_id2str(id),
2093                        nob, (int)offsetof(lnet_ping_info_t, pi_ni[n_ids]));
2094                 goto out_1;
2095         }
2096
2097         rc = -EFAULT;                      /* If I SEGV... */
2098
2099         memset(&tmpid, 0, sizeof(tmpid));
2100         for (i = 0; i < n_ids; i++) {
2101                 tmpid.pid = info->pi_pid;
2102                 tmpid.nid = info->pi_ni[i].ns_nid;
2103                 if (copy_to_user(&ids[i], &tmpid, sizeof(tmpid)))
2104                         goto out_1;
2105         }
2106         rc = info->pi_nnis;
2107
2108  out_1:
2109         rc2 = LNetEQFree(eqh);
2110         if (rc2)
2111                 CERROR("rc2 %d\n", rc2);
2112         LASSERT(!rc2);
2113
2114  out_0:
2115         LIBCFS_FREE(info, infosz);
2116         return rc;
2117 }