Whamcloud - gitweb
LU-15983 lnet: Define KFILND network type
[fs/lustre-release.git] / libcfs / libcfs / util / nidstrings.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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  *
31  * libcfs/libcfs/util/nidstrings.c
32  *
33  * Author: Phil Schwan <phil@clusterfs.com>
34  */
35
36 #define DEBUG_SUBSYSTEM S_LNET
37
38 #include <assert.h>
39 #include <errno.h>
40 #include <stdio.h>
41 #include <stdbool.h>
42 #include <stdlib.h>
43 #include <string.h>
44
45 #include <libcfs/util/string.h>
46 #include <linux/lnet/lnet-types.h>
47 #include <linux/lnet/nidstr.h>
48 #ifdef HAVE_NETDB_H
49 # include <netdb.h>
50 #endif
51
52 /* max value for numeric network address */
53 #define MAX_NUMERIC_VALUE 0xffffffff
54
55 #define IPSTRING_LENGTH 16
56
57 /* CAVEAT VENDITOR! Keep the canonical string representation of nets/nids
58  * consistent in all conversion functions.  Some code fragments are copied
59  * around for the sake of clarity...
60  */
61
62 /* CAVEAT EMPTOR! Racey temporary buffer allocation!
63  * Choose the number of nidstrings to support the MAXIMUM expected number of
64  * concurrent users.  If there are more, the returned string will be volatile.
65  * NB this number must allow for a process to be descheduled for a timeslice
66  * between getting its string and using it.
67  */
68
69 static char      libcfs_nidstrings[LNET_NIDSTR_COUNT][LNET_NIDSTR_SIZE];
70 static int       libcfs_nidstring_idx;
71
72 char *
73 libcfs_next_nidstring(void)
74 {
75         char          *str;
76
77         str = libcfs_nidstrings[libcfs_nidstring_idx++];
78         if (libcfs_nidstring_idx ==
79             sizeof(libcfs_nidstrings)/sizeof(libcfs_nidstrings[0]))
80                 libcfs_nidstring_idx = 0;
81
82         return str;
83 }
84
85 static int
86 libcfs_lo_str2addr(const char *str, int nob, __u32 *addr)
87 {
88         *addr = 0;
89         return 1;
90 }
91
92 static void
93 libcfs_ip_addr2str(__u32 addr, char *str, size_t size)
94 {
95         snprintf(str, size, "%u.%u.%u.%u",
96                  (addr >> 24) & 0xff, (addr >> 16) & 0xff,
97                  (addr >> 8) & 0xff, addr & 0xff);
98 }
99
100 /* CAVEAT EMPTOR XscanfX
101  * I use "%n" at the end of a sscanf format to detect trailing junk.  However
102  * sscanf may return immediately if it sees the terminating '0' in a string, so
103  * I initialise the %n variable to the expected length.  If sscanf sets it;
104  * fine, if it doesn't, then the scan ended at the end of the string, which is
105  * fine too :) */
106 static int
107 libcfs_ip_str2addr(const char *str, int nob, __u32 *addr)
108 {
109         unsigned int    a;
110         unsigned int    b;
111         unsigned int    c;
112         unsigned int    d;
113         int             n = nob; /* XscanfX */
114
115         /* numeric IP? */
116         if (sscanf(str, "%u.%u.%u.%u%n", &a, &b, &c, &d, &n) >= 4 &&
117             n == nob &&
118             (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
119             (c & ~0xff) == 0 && (d & ~0xff) == 0) {
120                 *addr = ((a<<24)|(b<<16)|(c<<8)|d);
121                 return 1;
122         }
123
124 #ifdef HAVE_GETHOSTBYNAME
125         /* known hostname? */
126         if (('a' <= str[0] && str[0] <= 'z') ||
127             ('A' <= str[0] && str[0] <= 'Z')) {
128                 char *tmp;
129
130                 tmp = calloc(1, nob + 1);
131                 if (tmp != NULL) {
132                         struct hostent *he;
133
134                         memcpy(tmp, str, nob);
135                         tmp[nob] = 0;
136
137                         he = gethostbyname(tmp);
138
139                         free(tmp);
140
141                         if (he != NULL) {
142                                 __u32 ip = *(__u32 *)he->h_addr;
143
144                                 *addr = ntohl(ip);
145                                 return 1;
146                         }
147                 }
148         }
149 #endif
150         return 0;
151 }
152
153 int
154 cfs_ip_addr_parse(char *str, int len, struct list_head *list)
155 {
156         struct cfs_expr_list *el;
157         struct cfs_lstr src;
158         int rc;
159         int i;
160
161         src.ls_str = str;
162         src.ls_len = len;
163         i = 0;
164
165         while (src.ls_str != NULL) {
166                 struct cfs_lstr res;
167
168                 if (!cfs_gettok(&src, '.', &res)) {
169                         rc = -EINVAL;
170                         goto out;
171                 }
172
173                 rc = cfs_expr_list_parse(res.ls_str, res.ls_len, 0, 255, &el);
174                 if (rc != 0)
175                         goto out;
176
177                 list_add_tail(&el->el_link, list);
178                 i++;
179         }
180
181         if (i == 4)
182                 return 0;
183
184         rc = -EINVAL;
185 out:
186         cfs_expr_list_free_list(list);
187
188         return rc;
189 }
190
191 int
192 cfs_expr2str(struct list_head *list, char *str, size_t size)
193 {
194         struct cfs_expr_list *expr;
195         struct cfs_range_expr *range;
196         char tmp[LNET_NIDSTR_SIZE];
197         size_t len;
198         bool first;
199         bool bracket = false;
200         char *format;
201         char *tmpc;
202
203         list_for_each_entry(expr, list, el_link) {
204                 first = true;
205                 list_for_each_entry(range, &expr->el_exprs, re_link) {
206                         if (range->re_lo == range->re_hi) {
207                                 snprintf(tmp,
208                                          LNET_NIDSTR_SIZE,
209                                          "%u.", range->re_lo);
210                         } else if (range->re_lo < range->re_hi) {
211                                 if (range->re_stride > 1) {
212                                         if (first)
213                                                 format = "[%u-%u/%u,";
214                                         else
215                                                 format = "%u-%u/%u,";
216                                         snprintf(tmp, LNET_NIDSTR_SIZE,
217                                                 format, range->re_lo,
218                                                 range->re_hi, range->re_stride);
219                                         bracket = true;
220                                 } else {
221                                         if (first)
222                                                 format = "[%u-%u,";
223                                         else
224                                                 format = "%u-%u,";
225                                         snprintf(tmp, LNET_NIDSTR_SIZE,
226                                                 format, range->re_lo,
227                                                 range->re_hi);
228                                         bracket = true;
229                                 }
230                         } else {
231                                 return -EINVAL;
232                         }
233                         len = strlen(tmp);
234                         size -= (len + 1);
235                         if (size < 0)
236                                 return -ENOBUFS;
237
238                         strncat(str, tmp, size + len);
239                         first = false;
240                 }
241                 if (bracket) {
242                         tmpc = str + (strlen(str) - 1);
243                         size -= 1;
244                         if (size < 0)
245                                 return -ENOBUFS;
246                         *tmpc = ']';
247                         *(tmpc+1) = '.';
248                         bracket = false;
249                 }
250         }
251
252         /*
253          * get rid of the trailing '.' at the end of the string
254          * only if we actually had something on the list passed in.
255          * otherwise we could write outside the array
256          */
257         if (!list_empty(list))
258                 str[strlen(str)-1] = '\0';
259         return size;
260 }
261
262 static int
263 libcfs_num_addr_range_expand(struct list_head *addrranges, __u32 *addrs,
264                              int max_addrs)
265 {
266         struct cfs_expr_list *expr_list;
267         struct cfs_range_expr *range;
268         int i;
269         int max_idx = max_addrs - 1;
270         int addrs_idx = max_idx;
271
272         list_for_each_entry(expr_list, addrranges, el_link) {
273                 list_for_each_entry(range, &expr_list->el_exprs, re_link) {
274                         for (i = range->re_lo; i <= range->re_hi;
275                              i += range->re_stride) {
276                                 if (addrs_idx < 0)
277                                         return -1;
278
279                                 addrs[addrs_idx] = i;
280                                 addrs_idx--;
281                         }
282                 }
283         }
284
285         return max_idx - addrs_idx;
286 }
287
288 static int
289 libcfs_ip_addr_range_expand(struct list_head *addrranges, __u32 *addrs,
290                             int max_addrs)
291 {
292         int rc = 0;
293
294         rc = cfs_ip_addr_range_gen(addrs, max_addrs, addrranges);
295
296         if (rc == -1)
297                 return rc;
298         else
299                 return max_addrs - rc - 1;
300 }
301
302 static int
303 libcfs_ip_addr_range_print(char *buffer, int count, struct list_head *list)
304 {
305         int i = 0, j = 0;
306         struct cfs_expr_list *el;
307
308         list_for_each_entry(el, list, el_link) {
309                 assert(j++ < 4);
310                 if (i != 0)
311                         i += scnprintf(buffer + i, count - i, ".");
312                 i += cfs_expr_list_print(buffer + i, count - i, el);
313         }
314         return i;
315 }
316
317 static int
318 cfs_ip_addr_range_gen_recurse(__u32 *ip_list, int *count, int shift,
319                               __u32 result, struct list_head *head_el,
320                               struct cfs_expr_list *octet_el)
321 {
322         __u32 value = 0;
323         int i;
324         struct cfs_expr_list *next_octet_el;
325         struct cfs_range_expr *octet_expr;
326
327         /*
328          * each octet can have multiple expressions so we need to traverse
329          * all of the expressions
330          */
331         list_for_each_entry(octet_expr, &octet_el->el_exprs, re_link) {
332                 for (i = octet_expr->re_lo; i <= octet_expr->re_hi; i++) {
333                         if (((i - octet_expr->re_lo) % octet_expr->re_stride) == 0) {
334                                 /*
335                                  * we have a hit calculate the result and
336                                  * pass it forward to the next iteration
337                                  * of the recursion.
338                                  */
339                                 next_octet_el =
340                                         list_entry(octet_el->el_link.next,
341                                                         typeof(*next_octet_el),
342                                                         el_link);
343                                 value = result | (i << (shift * 8));
344                                 if (next_octet_el->el_link.next != head_el) {
345                                         /*
346                                          * We still have more octets in
347                                          * the IP address so traverse
348                                          * that. We're doing a depth first
349                                          * recursion here.
350                                          */
351                                         if (cfs_ip_addr_range_gen_recurse(ip_list, count,
352                                                                           shift - 1, value,
353                                                                           head_el,
354                                                                           next_octet_el) == -1)
355                                                 return -1;
356                                 } else {
357                                         /*
358                                          * We have hit a leaf so store the
359                                          * calculated IP address in the
360                                          * list. If we have run out of
361                                          * space stop the recursion.
362                                          */
363                                         if (*count == -1)
364                                                 return -1;
365                                         /* add ip to the list */
366                                         ip_list[*count] = value;
367                                         (*count)--;
368                                 }
369                         }
370                 }
371         }
372         return 0;
373 }
374
375 /*
376  * only generate maximum of count ip addresses from the given expression
377  */
378 int
379 cfs_ip_addr_range_gen(__u32 *ip_list, int count, struct list_head *ip_addr_expr)
380 {
381         struct cfs_expr_list *octet_el;
382         int idx = count - 1;
383
384         octet_el = list_entry(ip_addr_expr->next, typeof(*octet_el), el_link);
385
386         (void) cfs_ip_addr_range_gen_recurse(ip_list, &idx, 3, 0, &octet_el->el_link, octet_el);
387
388         return idx;
389 }
390
391 /**
392  * Matches address (\a addr) against address set encoded in \a list.
393  *
394  * \retval 1 if \a addr matches
395  * \retval 0 otherwise
396  */
397 int
398 cfs_ip_addr_match(__u32 addr, struct list_head *list)
399 {
400         struct cfs_expr_list *el;
401         int i = 0;
402
403         list_for_each_entry_reverse(el, list, el_link) {
404                 if (!cfs_expr_list_match(addr & 0xff, el))
405                         return 0;
406                 addr >>= 8;
407                 i++;
408         }
409
410         return i == 4;
411 }
412
413 static void
414 libcfs_decnum_addr2str(__u32 addr, char *str, size_t size)
415 {
416         snprintf(str, size, "%u", addr);
417 }
418
419 static int
420 libcfs_num_str2addr(const char *str, int nob, __u32 *addr)
421 {
422         int     n;
423
424         n = nob;
425         if (sscanf(str, "0x%x%n", addr, &n) >= 1 && n == nob)
426                 return 1;
427
428         n = nob;
429         if (sscanf(str, "0X%x%n", addr, &n) >= 1 && n == nob)
430                 return 1;
431
432         n = nob;
433         if (sscanf(str, "%u%n", addr, &n) >= 1 && n == nob)
434                 return 1;
435
436         return 0;
437 }
438
439 /**
440  * Nf_parse_addrlist method for networks using numeric addresses.
441  *
442  * Examples of such networks are gm and elan.
443  *
444  * \retval 0 if \a str parsed to numeric address
445  * \retval errno otherwise
446  */
447 int
448 libcfs_num_parse(char *str, int len, struct list_head *list)
449 {
450         struct cfs_expr_list *el;
451         int     rc;
452
453         rc = cfs_expr_list_parse(str, len, 0, MAX_NUMERIC_VALUE, &el);
454         if (rc == 0)
455                 list_add_tail(&el->el_link, list);
456
457         return rc;
458 }
459
460 static int
461 libcfs_num_addr_range_print(char *buffer, int count, struct list_head *list)
462 {
463         struct cfs_expr_list *el;
464         int i = 0, j = 0;
465
466         list_for_each_entry(el, list, el_link) {
467                 assert(j++ < 1);
468                 i += cfs_expr_list_print(buffer + i, count - i, el);
469         }
470         return i;
471 }
472
473 /*
474  * Nf_match_addr method for networks using numeric addresses
475  *
476  * \retval 1 on match
477  * \retval 0 otherwise
478  */
479 static int
480 libcfs_num_match(__u32 addr, struct list_head *numaddr)
481 {
482         struct cfs_expr_list *el;
483
484         assert(!list_empty(numaddr));
485         el = list_entry(numaddr->next, struct cfs_expr_list, el_link);
486
487         return cfs_expr_list_match(addr, el);
488 }
489
490 static int cfs_ip_min_max(struct list_head *nidlist, __u32 *min, __u32 *max);
491 static int cfs_num_min_max(struct list_head *nidlist, __u32 *min, __u32 *max);
492
493 static struct netstrfns libcfs_netstrfns[] = {
494         {
495                 .nf_type                = LOLND,
496                 .nf_name                = "lo",
497                 .nf_modname             = "klolnd",
498                 .nf_addr2str            = libcfs_decnum_addr2str,
499                 .nf_str2addr            = libcfs_lo_str2addr,
500                 .nf_parse_addrlist      = libcfs_num_parse,
501                 .nf_print_addrlist      = libcfs_num_addr_range_print,
502                 .nf_match_addr          = libcfs_num_match,
503                 .nf_min_max             = cfs_num_min_max,
504                 .nf_expand_addrrange    = libcfs_num_addr_range_expand
505         },
506         {
507                 .nf_type                = SOCKLND,
508                 .nf_name                = "tcp",
509                 .nf_modname             = "ksocklnd",
510                 .nf_addr2str            = libcfs_ip_addr2str,
511                 .nf_str2addr            = libcfs_ip_str2addr,
512                 .nf_parse_addrlist      = cfs_ip_addr_parse,
513                 .nf_print_addrlist      = libcfs_ip_addr_range_print,
514                 .nf_match_addr          = cfs_ip_addr_match,
515                 .nf_min_max             = cfs_ip_min_max,
516                 .nf_expand_addrrange    = libcfs_ip_addr_range_expand
517         },
518         {
519                 .nf_type                = O2IBLND,
520                 .nf_name                = "o2ib",
521                 .nf_modname             = "ko2iblnd",
522                 .nf_addr2str            = libcfs_ip_addr2str,
523                 .nf_str2addr            = libcfs_ip_str2addr,
524                 .nf_parse_addrlist      = cfs_ip_addr_parse,
525                 .nf_print_addrlist      = libcfs_ip_addr_range_print,
526                 .nf_match_addr          = cfs_ip_addr_match,
527                 .nf_min_max             = cfs_ip_min_max,
528                 .nf_expand_addrrange    = libcfs_ip_addr_range_expand
529         },
530         {
531                 .nf_type                = GNILND,
532                 .nf_name                = "gni",
533                 .nf_modname             = "kgnilnd",
534                 .nf_addr2str            = libcfs_decnum_addr2str,
535                 .nf_str2addr            = libcfs_num_str2addr,
536                 .nf_parse_addrlist      = libcfs_num_parse,
537                 .nf_print_addrlist      = libcfs_num_addr_range_print,
538                 .nf_match_addr          = libcfs_num_match,
539                 .nf_min_max             = cfs_num_min_max,
540                 .nf_expand_addrrange    = libcfs_num_addr_range_expand
541         },
542         {
543                 .nf_type                = GNIIPLND,
544                 .nf_name                = "gip",
545                 .nf_modname             = "kgnilnd",
546                 .nf_addr2str            = libcfs_ip_addr2str,
547                 .nf_str2addr            = libcfs_ip_str2addr,
548                 .nf_parse_addrlist      = cfs_ip_addr_parse,
549                 .nf_print_addrlist      = libcfs_ip_addr_range_print,
550                 .nf_match_addr          = cfs_ip_addr_match,
551                 .nf_min_max             = cfs_ip_min_max,
552                 .nf_expand_addrrange    = libcfs_ip_addr_range_expand
553         },
554         {
555                 .nf_type                = PTL4LND,
556                 .nf_name                = "ptlf",
557                 .nf_modname             = "kptl4lnd",
558                 .nf_addr2str            = libcfs_decnum_addr2str,
559                 .nf_str2addr            = libcfs_num_str2addr,
560                 .nf_parse_addrlist      = libcfs_num_parse,
561                 .nf_print_addrlist      = libcfs_num_addr_range_print,
562                 .nf_match_addr          = libcfs_num_match,
563                 .nf_min_max             = cfs_num_min_max,
564                 .nf_expand_addrrange    = libcfs_num_addr_range_expand
565         },
566         {
567                 .nf_type                = KFILND,
568                 .nf_name                = "kfi",
569                 .nf_modname             = "kkfilnd",
570                 .nf_addr2str            = libcfs_decnum_addr2str,
571                 .nf_str2addr            = libcfs_num_str2addr,
572                 .nf_parse_addrlist      = libcfs_num_parse,
573                 .nf_print_addrlist      = libcfs_num_addr_range_print,
574                 .nf_match_addr          = libcfs_num_match,
575                 .nf_min_max             = cfs_num_min_max,
576                 .nf_expand_addrrange    = libcfs_num_addr_range_expand
577         }
578 };
579
580 static const size_t libcfs_nnetstrfns =
581         sizeof(libcfs_netstrfns)/sizeof(libcfs_netstrfns[0]);
582
583 static struct netstrfns *
584 libcfs_lnd2netstrfns(__u32 lnd)
585 {
586         int     i;
587
588         for (i = 0; i < libcfs_nnetstrfns; i++)
589                 if (lnd == libcfs_netstrfns[i].nf_type)
590                         return &libcfs_netstrfns[i];
591
592         return NULL;
593 }
594
595 static struct netstrfns *
596 libcfs_namenum2netstrfns(const char *name)
597 {
598         struct netstrfns *nf;
599         int               i;
600
601         for (i = 0; i < libcfs_nnetstrfns; i++) {
602                 nf = &libcfs_netstrfns[i];
603                 if (!strncmp(name, nf->nf_name, strlen(nf->nf_name)))
604                         return nf;
605         }
606         return NULL;
607 }
608
609 static struct netstrfns *
610 libcfs_name2netstrfns(const char *name)
611 {
612         int    i;
613
614         for (i = 0; i < libcfs_nnetstrfns; i++)
615                 if (!strcmp(libcfs_netstrfns[i].nf_name, name))
616                         return &libcfs_netstrfns[i];
617
618         return NULL;
619 }
620
621 int
622 libcfs_isknown_lnd(__u32 lnd)
623 {
624         return libcfs_lnd2netstrfns(lnd) != NULL;
625 }
626
627 char *
628 libcfs_lnd2modname(__u32 lnd)
629 {
630         struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
631
632         return (nf == NULL) ? NULL : nf->nf_modname;
633 }
634
635 int
636 libcfs_str2lnd(const char *str)
637 {
638         struct netstrfns *nf = libcfs_name2netstrfns(str);
639
640         if (nf != NULL)
641                 return nf->nf_type;
642
643         return -1;
644 }
645
646 char *
647 libcfs_lnd2str_r(__u32 lnd, char *buf, size_t buf_size)
648 {
649         struct netstrfns *nf;
650
651         nf = libcfs_lnd2netstrfns(lnd);
652         if (nf == NULL)
653                 snprintf(buf, buf_size, "?%u?", lnd);
654         else
655                 snprintf(buf, buf_size, "%s", nf->nf_name);
656
657         return buf;
658 }
659
660 char *
661 libcfs_net2str_r(__u32 net, char *buf, size_t buf_size)
662 {
663         __u32             nnum = LNET_NETNUM(net);
664         __u32             lnd  = LNET_NETTYP(net);
665         struct netstrfns *nf;
666
667         nf = libcfs_lnd2netstrfns(lnd);
668         if (nf == NULL)
669                 snprintf(buf, buf_size, "<%u:%u>", lnd, nnum);
670         else if (nnum == 0)
671                 snprintf(buf, buf_size, "%s", nf->nf_name);
672         else
673                 snprintf(buf, buf_size, "%s%u", nf->nf_name, nnum);
674
675         return buf;
676 }
677
678 char *
679 libcfs_nid2str_r(lnet_nid_t nid, char *buf, size_t buf_size)
680 {
681         __u32             addr = LNET_NIDADDR(nid);
682         __u32             net  = LNET_NIDNET(nid);
683         __u32             nnum = LNET_NETNUM(net);
684         __u32             lnd  = LNET_NETTYP(net);
685         struct netstrfns *nf;
686
687         if (nid == LNET_NID_ANY) {
688                 strncpy(buf, "<?>", buf_size);
689                 buf[buf_size - 1] = '\0';
690                 return buf;
691         }
692
693         nf = libcfs_lnd2netstrfns(lnd);
694         if (nf == NULL) {
695                 snprintf(buf, buf_size, "%x@<%u:%u>", addr, lnd, nnum);
696         } else {
697                 size_t addr_len;
698
699                 nf->nf_addr2str(addr, buf, buf_size);
700                 addr_len = strlen(buf);
701                 if (nnum == 0)
702                         snprintf(buf + addr_len, buf_size - addr_len, "@%s",
703                                  nf->nf_name);
704                 else
705                         snprintf(buf + addr_len, buf_size - addr_len, "@%s%u",
706                                  nf->nf_name, nnum);
707         }
708
709         return buf;
710 }
711
712 static struct netstrfns *
713 libcfs_str2net_internal(const char *str, __u32 *net)
714 {
715         struct netstrfns *nf = NULL;
716         int               nob;
717         unsigned int      netnum;
718         int               i;
719
720         for (i = 0; i < libcfs_nnetstrfns; i++) {
721                 nf = &libcfs_netstrfns[i];
722                 if (!strncmp(str, nf->nf_name, strlen(nf->nf_name)))
723                         break;
724         }
725
726         if (i == libcfs_nnetstrfns)
727                 return NULL;
728
729         nob = strlen(nf->nf_name);
730
731         if (strlen(str) == (unsigned int)nob) {
732                 netnum = 0;
733         } else {
734                 if (nf->nf_type == LOLND) /* net number not allowed */
735                         return NULL;
736
737                 str += nob;
738                 i = strlen(str);
739                 if (sscanf(str, "%u%n", &netnum, &i) < 1 ||
740                     i != (int)strlen(str))
741                         return NULL;
742         }
743
744         *net = LNET_MKNET(nf->nf_type, netnum);
745         return nf;
746 }
747
748 __u32
749 libcfs_str2net(const char *str)
750 {
751         __u32  net;
752
753         if (libcfs_str2net_internal(str, &net) != NULL)
754                 return net;
755
756         return LNET_NET_ANY;
757 }
758
759 lnet_nid_t
760 libcfs_str2nid(const char *str)
761 {
762         const char       *sep = strchr(str, '@');
763         struct netstrfns *nf;
764         __u32             net;
765         __u32             addr;
766
767         if (sep != NULL) {
768                 nf = libcfs_str2net_internal(sep + 1, &net);
769                 if (nf == NULL)
770                         return LNET_NID_ANY;
771         } else {
772                 sep = str + strlen(str);
773                 net = LNET_MKNET(SOCKLND, 0);
774                 nf = libcfs_lnd2netstrfns(SOCKLND);
775                 assert(nf != NULL);
776         }
777
778         if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
779                 return LNET_NID_ANY;
780
781         return LNET_MKNID(net, addr);
782 }
783
784 char *
785 libcfs_id2str(struct lnet_process_id id)
786 {
787         char *str = libcfs_next_nidstring();
788
789         if (id.pid == LNET_PID_ANY) {
790                 snprintf(str, LNET_NIDSTR_SIZE,
791                          "LNET_PID_ANY-%s", libcfs_nid2str(id.nid));
792                 return str;
793         }
794
795         snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
796                  ((id.pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
797                  (id.pid & ~LNET_PID_USERFLAG), libcfs_nid2str(id.nid));
798         return str;
799 }
800
801 int
802 libcfs_str2anynid(lnet_nid_t *nidp, const char *str)
803 {
804         if (!strcmp(str, "*")) {
805                 *nidp = LNET_NID_ANY;
806                 return 1;
807         }
808
809         *nidp = libcfs_str2nid(str);
810         return *nidp != LNET_NID_ANY;
811 }
812
813 /**
814  * Nid range list syntax.
815  * \verbatim
816  *
817  * <nidlist>         :== <nidrange> [ ' ' <nidrange> ]
818  * <nidrange>        :== <addrrange> '@' <net>
819  * <addrrange>       :== '*' |
820  *                       <ipaddr_range> |
821  *                       <cfs_expr_list>
822  * <ipaddr_range>    :== <cfs_expr_list>.<cfs_expr_list>.<cfs_expr_list>.
823  *                       <cfs_expr_list>
824  * <cfs_expr_list>   :== <number> |
825  *                       <expr_list>
826  * <expr_list>       :== '[' <range_expr> [ ',' <range_expr>] ']'
827  * <range_expr>      :== <number> |
828  *                       <number> '-' <number> |
829  *                       <number> '-' <number> '/' <number>
830  * <net>             :== <netname> | <netname><number>
831  * <netname>         :== "lo" | "tcp" | "o2ib" | "cib" | "openib" | "iib" |
832  *                       "vib" | "ra" | "elan" | "mx" | "ptl"
833  * \endverbatim
834  */
835
836 /**
837  * Structure to represent \<nidrange\> token of the syntax.
838  *
839  * One of this is created for each \<net\> parsed.
840  */
841 struct nidrange {
842         /**
843          * Link to list of this structures which is built on nid range
844          * list parsing.
845          */
846         struct list_head nr_link;
847         /**
848          * List head for addrrange::ar_link.
849          */
850         struct list_head nr_addrranges;
851         /**
852          * Flag indicating that *@<net> is found.
853          */
854         int nr_all;
855         /**
856          * Pointer to corresponding element of libcfs_netstrfns.
857          */
858         struct netstrfns *nr_netstrfns;
859         /**
860          * Number of network. E.g. 5 if \<net\> is "elan5".
861          */
862         int nr_netnum;
863 };
864
865 /**
866  * Structure to represent \<addrrange\> token of the syntax.
867  */
868 struct addrrange {
869         /**
870          * Link to nidrange::nr_addrranges.
871          */
872         struct list_head ar_link;
873         /**
874          * List head for cfs_expr_list::el_list.
875          */
876         struct list_head ar_numaddr_ranges;
877 };
878
879 /**
880  * Parses \<addrrange\> token on the syntax.
881  *
882  * Allocates struct addrrange and links to \a nidrange via
883  * (nidrange::nr_addrranges)
884  *
885  * \retval 0 if \a src parses to '*' | \<ipaddr_range\> | \<cfs_expr_list\>
886  * \retval -errno otherwise
887  */
888 static int
889 parse_addrange(const struct cfs_lstr *src, struct nidrange *nidrange)
890 {
891         struct addrrange *addrrange;
892
893         if (src->ls_len == 1 && src->ls_str[0] == '*') {
894                 nidrange->nr_all = 1;
895                 return 0;
896         }
897
898         addrrange = calloc(1, sizeof(struct addrrange));
899         if (addrrange == NULL)
900                 return -ENOMEM;
901         list_add_tail(&addrrange->ar_link, &nidrange->nr_addrranges);
902         INIT_LIST_HEAD(&addrrange->ar_numaddr_ranges);
903
904         return nidrange->nr_netstrfns->nf_parse_addrlist(src->ls_str,
905                                                 src->ls_len,
906                                                 &addrrange->ar_numaddr_ranges);
907 }
908
909 /**
910  * Finds or creates struct nidrange.
911  *
912  * Checks if \a src is a valid network name, looks for corresponding
913  * nidrange on the ist of nidranges (\a nidlist), creates new struct
914  * nidrange if it is not found.
915  *
916  * \retval pointer to struct nidrange matching network specified via \a src
917  * \retval NULL if \a src does not match any network
918  */
919 static struct nidrange *
920 add_nidrange(const struct cfs_lstr *src,
921              struct list_head *nidlist)
922 {
923         struct netstrfns *nf;
924         struct nidrange *nr;
925         int endlen;
926         unsigned netnum;
927
928         if (src->ls_len >= LNET_NIDSTR_SIZE)
929                 return NULL;
930
931         nf = libcfs_namenum2netstrfns(src->ls_str);
932         if (nf == NULL)
933                 return NULL;
934         endlen = src->ls_len - strlen(nf->nf_name);
935         if (endlen == 0)
936                 /* network name only, e.g. "elan" or "tcp" */
937                 netnum = 0;
938         else {
939                 /* e.g. "elan25" or "tcp23", refuse to parse if
940                  * network name is not appended with decimal or
941                  * hexadecimal number */
942                 if (!cfs_str2num_check(src->ls_str + strlen(nf->nf_name),
943                                        endlen, &netnum, 0, MAX_NUMERIC_VALUE))
944                         return NULL;
945         }
946
947         list_for_each_entry(nr, nidlist, nr_link) {
948                 if (nr->nr_netstrfns != nf)
949                         continue;
950                 if (nr->nr_netnum != netnum)
951                         continue;
952                 return nr;
953         }
954
955         nr = calloc(1, sizeof(struct nidrange));
956         if (nr == NULL)
957                 return NULL;
958         list_add_tail(&nr->nr_link, nidlist);
959         INIT_LIST_HEAD(&nr->nr_addrranges);
960         nr->nr_netstrfns = nf;
961         nr->nr_all = 0;
962         nr->nr_netnum = netnum;
963
964         return nr;
965 }
966
967 /**
968  * Parses \<nidrange\> token of the syntax.
969  *
970  * \retval 1 if \a src parses to \<addrrange\> '@' \<net\>
971  * \retval 0 otherwise
972  */
973 static int
974 parse_nidrange(struct cfs_lstr *src, struct list_head *nidlist)
975 {
976         struct cfs_lstr addrrange;
977         struct cfs_lstr net;
978         struct cfs_lstr tmp;
979         struct nidrange *nr;
980
981         tmp = *src;
982         if (cfs_gettok(src, '@', &addrrange) == 0)
983                 goto failed;
984
985         if (cfs_gettok(src, '@', &net) == 0 || src->ls_str != NULL)
986                 goto failed;
987
988         nr = add_nidrange(&net, nidlist);
989         if (nr == NULL)
990                 goto failed;
991
992         if (parse_addrange(&addrrange, nr) != 0)
993                 goto failed;
994
995         return 1;
996  failed:
997         fprintf(stderr, "can't parse nidrange: \"%.*s\"\n",
998                 tmp.ls_len, tmp.ls_str);
999         return 0;
1000 }
1001
1002 static __u32
1003 libcfs_net_str_len(const char *str)
1004 {
1005         int i;
1006         struct netstrfns *nf = NULL;
1007
1008         for (i = 0; i < libcfs_nnetstrfns; i++) {
1009                 nf = &libcfs_netstrfns[i];
1010                 if (!strncmp(str, nf->nf_name, strlen(nf->nf_name)))
1011                         return strlen(nf->nf_name);
1012         }
1013
1014         return 0;
1015 }
1016
1017 int
1018 parse_net_range(char *str, __u32 len, struct list_head *net_num,
1019                 __u32 *net_type)
1020 {
1021         struct cfs_lstr next;
1022         __u32 net_type_len;
1023         __u32 net;
1024         char *bracket;
1025         char *star;
1026
1027         if (!str)
1028                 return -EINVAL;
1029
1030         next.ls_str = str;
1031         next.ls_len = len;
1032
1033         net_type_len = libcfs_net_str_len(str);
1034
1035         if (net_type_len < len) {
1036                 char c = str[net_type_len];
1037
1038                 str[net_type_len] = '\0';
1039                 net = libcfs_str2net(str);
1040                 str[net_type_len] = c;
1041         } else {
1042                 net = libcfs_str2net(str);
1043         }
1044
1045         if (net == LNET_NIDNET(LNET_NID_ANY))
1046                 return -EINVAL;
1047
1048         *net_type = LNET_NETTYP(net);
1049
1050         /*
1051          * the net is either followed with an absolute number, *, or an
1052          * expression enclosed in []
1053          */
1054         bracket = strchr(next.ls_str, '[');
1055         star = strchr(next.ls_str, '*');
1056
1057         /* "*[" pattern not allowed */
1058         if (bracket && star && star < bracket)
1059                 return -EINVAL;
1060
1061         if (!bracket) {
1062                 next.ls_str = str + net_type_len;
1063                 next.ls_len = strlen(next.ls_str);
1064         } else {
1065                 next.ls_str = bracket;
1066                 next.ls_len = strlen(bracket);
1067         }
1068
1069         /* if there is no net number just return */
1070         if (next.ls_len == 0)
1071                 return 0;
1072
1073         return libcfs_num_parse(next.ls_str, next.ls_len,
1074                                 net_num);
1075 }
1076
1077 int
1078 parse_address(struct cfs_lstr *src, const __u32 net_type,
1079               struct list_head *addr)
1080 {
1081         int i;
1082         struct netstrfns *nf = NULL;
1083
1084         for (i = 0; i < libcfs_nnetstrfns; i++) {
1085                 nf = &libcfs_netstrfns[i];
1086                 if (net_type == nf->nf_type)
1087                         return nf->nf_parse_addrlist(src->ls_str, src->ls_len,
1088                                                      addr);
1089         }
1090
1091         return -EINVAL;
1092 }
1093
1094 int
1095 cfs_parse_nid_parts(char *str, struct list_head *addr,
1096                     struct list_head *net_num, __u32 *net_type)
1097 {
1098         struct cfs_lstr next;
1099         struct cfs_lstr addrrange;
1100         bool found = false;
1101         int rc;
1102
1103         if (!str)
1104                 return -EINVAL;
1105
1106         next.ls_str = str;
1107         next.ls_len = strlen(str);
1108
1109         rc = cfs_gettok(&next, '@', &addrrange);
1110         if (!rc)
1111                 return -EINVAL;
1112
1113         if (!next.ls_str) {
1114                 /* only net is present */
1115                 next.ls_str = str;
1116                 next.ls_len = strlen(str);
1117         } else {
1118                 found = true;
1119         }
1120
1121         /* assume only net is present */
1122         rc = parse_net_range(next.ls_str, next.ls_len, net_num, net_type);
1123
1124         /*
1125          * if we successfully parsed the net range and there is no
1126          * address, or if we fail to parse the net range then return
1127          */
1128         if ((!rc && !found) || rc)
1129                 return rc;
1130
1131         return parse_address(&addrrange, *net_type, addr);
1132 }
1133
1134 /**
1135  * Frees addrrange structures of \a list.
1136  *
1137  * For each struct addrrange structure found on \a list it frees
1138  * cfs_expr_list list attached to it and frees the addrrange itself.
1139  *
1140  * \retval none
1141  */
1142 static void
1143 free_addrranges(struct list_head *list)
1144 {
1145         while (!list_empty(list)) {
1146                 struct addrrange *ar;
1147
1148                 ar = list_entry(list->next, struct addrrange, ar_link);
1149
1150                 cfs_expr_list_free_list(&ar->ar_numaddr_ranges);
1151                 list_del(&ar->ar_link);
1152                 free(ar);
1153         }
1154 }
1155
1156 /**
1157  * Frees nidrange strutures of \a list.
1158  *
1159  * For each struct nidrange structure found on \a list it frees
1160  * addrrange list attached to it and frees the nidrange itself.
1161  *
1162  * \retval none
1163  */
1164 void
1165 cfs_free_nidlist(struct list_head *list)
1166 {
1167         struct list_head *pos, *next;
1168         struct nidrange *nr;
1169
1170         list_for_each_safe(pos, next, list) {
1171                 nr = list_entry(pos, struct nidrange, nr_link);
1172                 free_addrranges(&nr->nr_addrranges);
1173                 list_del(pos);
1174                 free(nr);
1175         }
1176 }
1177
1178 /**
1179  * Parses nid range list.
1180  *
1181  * Parses with rigorous syntax and overflow checking \a str into
1182  * \<nidrange\> [ ' ' \<nidrange\> ], compiles \a str into set of
1183  * structures and links that structure to \a nidlist. The resulting
1184  * list can be used to match a NID againts set of NIDS defined by \a
1185  * str.
1186  * \see cfs_match_nid
1187  *
1188  * \retval 1 on success
1189  * \retval 0 otherwise
1190  */
1191 int
1192 cfs_parse_nidlist(char *str, int len, struct list_head *nidlist)
1193 {
1194         struct cfs_lstr src;
1195         struct cfs_lstr res;
1196         int rc;
1197
1198         src.ls_str = str;
1199         src.ls_len = len;
1200         INIT_LIST_HEAD(nidlist);
1201         while (src.ls_str) {
1202                 rc = cfs_gettok(&src, ' ', &res);
1203                 if (rc == 0) {
1204                         cfs_free_nidlist(nidlist);
1205                         return 0;
1206                 }
1207                 rc = parse_nidrange(&res, nidlist);
1208                 if (rc == 0) {
1209                         cfs_free_nidlist(nidlist);
1210                         return 0;
1211                 }
1212         }
1213         return 1;
1214 }
1215
1216 /**
1217  * Matches a nid (\a nid) against the compiled list of nidranges (\a nidlist).
1218  *
1219  * \see cfs_parse_nidlist()
1220  *
1221  * \retval 1 on match
1222  * \retval 0  otherwises
1223  */
1224 int cfs_match_nid(lnet_nid_t nid, struct list_head *nidlist)
1225 {
1226         struct nidrange *nr;
1227         struct addrrange *ar;
1228
1229         list_for_each_entry(nr, nidlist, nr_link) {
1230                 if (nr->nr_netstrfns->nf_type != LNET_NETTYP(LNET_NIDNET(nid)))
1231                         continue;
1232                 if (nr->nr_netnum != LNET_NETNUM(LNET_NIDNET(nid)))
1233                         continue;
1234                 if (nr->nr_all)
1235                         return 1;
1236                 list_for_each_entry(ar, &nr->nr_addrranges, ar_link)
1237                         if (nr->nr_netstrfns->nf_match_addr(LNET_NIDADDR(nid),
1238                                                         &ar->ar_numaddr_ranges))
1239                                 return 1;
1240         }
1241         return 0;
1242 }
1243
1244 int
1245 cfs_match_net(__u32 net_id, __u32 net_type, struct list_head *net_num_list)
1246 {
1247         __u32 net_num;
1248
1249         if (!net_num_list)
1250                 return 0;
1251
1252         if (net_type != LNET_NETTYP(net_id))
1253                 return 0;
1254
1255         net_num = LNET_NETNUM(net_id);
1256
1257         /*
1258          * if there is a net number but the list passed in is empty, then
1259          * there is no match.
1260          */
1261         if (!net_num && list_empty(net_num_list))
1262                 return 1;
1263         else if (list_empty(net_num_list))
1264                 return 0;
1265
1266         if (!libcfs_num_match(net_num, net_num_list))
1267                 return 0;
1268
1269         return 1;
1270 }
1271
1272 /**
1273  * Print the network part of the nidrange \a nr into the specified \a buffer.
1274  *
1275  * \retval number of characters written
1276  */
1277 static int
1278 cfs_print_network(char *buffer, int count, struct nidrange *nr)
1279 {
1280         struct netstrfns *nf = nr->nr_netstrfns;
1281
1282         if (nr->nr_netnum == 0)
1283                 return scnprintf(buffer, count, "@%s", nf->nf_name);
1284         else
1285                 return scnprintf(buffer, count, "@%s%u",
1286                                  nf->nf_name, nr->nr_netnum);
1287 }
1288
1289
1290 /**
1291  * Print a list of addrrange (\a addrranges) into the specified \a buffer.
1292  * At max \a count characters can be printed into \a buffer.
1293  *
1294  * \retval number of characters written
1295  */
1296 static int
1297 cfs_print_addrranges(char *buffer, int count, struct list_head *addrranges,
1298                      struct nidrange *nr)
1299 {
1300         int i = 0;
1301         struct addrrange *ar;
1302         struct netstrfns *nf = nr->nr_netstrfns;
1303
1304         list_for_each_entry(ar, addrranges, ar_link) {
1305                 if (i != 0)
1306                         i += scnprintf(buffer + i, count - i, " ");
1307                 i += nf->nf_print_addrlist(buffer + i, count - i,
1308                                            &ar->ar_numaddr_ranges);
1309                 i += cfs_print_network(buffer + i, count - i, nr);
1310         }
1311         return i;
1312 }
1313
1314 /**
1315  * Print a list of nidranges (\a nidlist) into the specified \a buffer.
1316  * At max \a count characters can be printed into \a buffer.
1317  * Nidranges are separated by a space character.
1318  *
1319  * \retval number of characters written
1320  */
1321 int cfs_print_nidlist(char *buffer, int count, struct list_head *nidlist)
1322 {
1323         int i = 0;
1324         struct nidrange *nr;
1325
1326         if (count <= 0)
1327                 return 0;
1328
1329         list_for_each_entry(nr, nidlist, nr_link) {
1330                 if (i != 0)
1331                         i += scnprintf(buffer + i, count - i, " ");
1332
1333                 if (nr->nr_all != 0) {
1334                         assert(list_empty(&nr->nr_addrranges));
1335                         i += scnprintf(buffer + i, count - i, "*");
1336                         i += cfs_print_network(buffer + i, count - i, nr);
1337                 } else {
1338                         i += cfs_print_addrranges(buffer + i, count - i,
1339                                                   &nr->nr_addrranges, nr);
1340                 }
1341         }
1342         return i;
1343 }
1344
1345 /**
1346  * Determines minimum and maximum addresses for a single
1347  * numeric address range
1348  *
1349  * \param       ar
1350  * \param[out]  *min_nid __u32 representation of min NID
1351  * \param[out]  *max_nid __u32 representation of max NID
1352  * \retval      -EINVAL unsupported LNET range
1353  * \retval      -ERANGE non-contiguous LNET range
1354  */
1355 static int cfs_ip_ar_min_max(struct addrrange *ar, __u32 *min_nid,
1356                               __u32 *max_nid)
1357 {
1358         struct cfs_expr_list *expr_list;
1359         struct cfs_range_expr *range;
1360         unsigned int min_ip[4] = {0};
1361         unsigned int max_ip[4] = {0};
1362         int cur_octet = 0;
1363         bool expect_full_octet = false;
1364
1365         list_for_each_entry(expr_list, &ar->ar_numaddr_ranges, el_link) {
1366                 int re_count = 0;
1367
1368                 list_for_each_entry(range, &expr_list->el_exprs, re_link) {
1369                         /* XXX: add support for multiple & non-contig. re's */
1370                         if (re_count > 0)
1371                                 return -EINVAL;
1372
1373                         /* if a previous octet was ranged, then all remaining
1374                          * octets must be full for contiguous range */
1375                         if (expect_full_octet && (range->re_lo != 0 ||
1376                                                   range->re_hi != 255))
1377                                 return -ERANGE;
1378
1379                         if (range->re_stride != 1)
1380                                 return -ERANGE;
1381
1382                         if (range->re_lo > range->re_hi)
1383                                 return -EINVAL;
1384
1385                         if (range->re_lo != range->re_hi)
1386                                 expect_full_octet = true;
1387
1388                         min_ip[cur_octet] = range->re_lo;
1389                         max_ip[cur_octet] = range->re_hi;
1390
1391                         re_count++;
1392                 }
1393
1394                 cur_octet++;
1395         }
1396
1397         if (min_nid != NULL)
1398                 *min_nid = ((min_ip[0] << 24) | (min_ip[1] << 16) |
1399                             (min_ip[2] << 8) | min_ip[3]);
1400
1401         if (max_nid != NULL)
1402                 *max_nid = ((max_ip[0] << 24) | (max_ip[1] << 16) |
1403                             (max_ip[2] << 8) | max_ip[3]);
1404
1405         return 0;
1406 }
1407
1408 /**
1409  * Determines minimum and maximum addresses for a single
1410  * numeric address range
1411  *
1412  * \param       ar
1413  * \param[out]  *min_nid __u32 representation of min NID
1414  * \param[out]  *max_nid __u32 representation of max NID
1415  * \retval      -EINVAL unsupported LNET range
1416  */
1417 static int cfs_num_ar_min_max(struct addrrange *ar, __u32 *min_nid,
1418                                __u32 *max_nid)
1419 {
1420         struct cfs_expr_list *el;
1421         struct cfs_range_expr *re;
1422         unsigned int min_addr = 0;
1423         unsigned int max_addr = 0;
1424
1425         list_for_each_entry(el, &ar->ar_numaddr_ranges, el_link) {
1426                 int re_count = 0;
1427
1428                 list_for_each_entry(re, &el->el_exprs, re_link) {
1429                         if (re_count > 0)
1430                                 return -EINVAL;
1431                         if (re->re_lo > re->re_hi)
1432                                 return -EINVAL;
1433
1434                         if (re->re_lo < min_addr || min_addr == 0)
1435                                 min_addr = re->re_lo;
1436                         if (re->re_hi > max_addr)
1437                                 max_addr = re->re_hi;
1438
1439                         re_count++;
1440                 }
1441         }
1442
1443         if (min_nid != NULL)
1444                 *min_nid = min_addr;
1445         if (max_nid != NULL)
1446                 *max_nid = max_addr;
1447
1448         return 0;
1449 }
1450
1451 /**
1452  * Takes a linked list of nidrange expressions, determines the minimum
1453  * and maximum nid and creates appropriate nid structures
1454  *
1455  * \param       *nidlist
1456  * \param[out]  *min_nid string representation of min NID
1457  * \param[out]  *max_nid string representation of max NID
1458  * \retval      -EINVAL unsupported LNET range
1459  * \retval      -ERANGE non-contiguous LNET range
1460  */
1461 int cfs_nidrange_find_min_max(struct list_head *nidlist, char *min_nid,
1462                               char *max_nid, size_t nidstr_length)
1463 {
1464         struct nidrange *first_nidrange;
1465         int netnum;
1466         struct netstrfns *nf;
1467         char *lndname;
1468         __u32 min_addr;
1469         __u32 max_addr;
1470         char min_addr_str[IPSTRING_LENGTH];
1471         char max_addr_str[IPSTRING_LENGTH];
1472         int rc;
1473
1474         first_nidrange = list_entry(nidlist->next, struct nidrange, nr_link);
1475
1476         netnum = first_nidrange->nr_netnum;
1477         nf = first_nidrange->nr_netstrfns;
1478         lndname = nf->nf_name;
1479
1480         rc = nf->nf_min_max(nidlist, &min_addr, &max_addr);
1481         if (rc < 0)
1482                 return rc;
1483
1484         nf->nf_addr2str(min_addr, min_addr_str, sizeof(min_addr_str));
1485         nf->nf_addr2str(max_addr, max_addr_str, sizeof(max_addr_str));
1486
1487         snprintf(min_nid, nidstr_length, "%s@%s%d", min_addr_str, lndname,
1488                  netnum);
1489         snprintf(max_nid, nidstr_length, "%s@%s%d", max_addr_str, lndname,
1490                  netnum);
1491
1492         return 0;
1493 }
1494
1495 /**
1496  * Determines the min and max NID values for num LNDs
1497  *
1498  * \param       *nidlist
1499  * \param[out]  *min_nid if provided, returns string representation of min NID
1500  * \param[out]  *max_nid if provided, returns string representation of max NID
1501  * \retval      -EINVAL unsupported LNET range
1502  * \retval      -ERANGE non-contiguous LNET range
1503  */
1504 static int cfs_num_min_max(struct list_head *nidlist, __u32 *min_nid,
1505                             __u32 *max_nid)
1506 {
1507         struct nidrange *nr;
1508         struct addrrange *ar;
1509         unsigned int tmp_min_addr = 0;
1510         unsigned int tmp_max_addr = 0;
1511         unsigned int min_addr = 0;
1512         unsigned int max_addr = 0;
1513         int nidlist_count = 0;
1514         int rc;
1515
1516         list_for_each_entry(nr, nidlist, nr_link) {
1517                 if (nidlist_count > 0)
1518                         return -EINVAL;
1519
1520                 list_for_each_entry(ar, &nr->nr_addrranges, ar_link) {
1521                         rc = cfs_num_ar_min_max(ar, &tmp_min_addr,
1522                                                 &tmp_max_addr);
1523                         if (rc < 0)
1524                                 return rc;
1525
1526                         if (tmp_min_addr < min_addr || min_addr == 0)
1527                                 min_addr = tmp_min_addr;
1528                         if (tmp_max_addr > max_addr)
1529                                 max_addr = tmp_min_addr;
1530                 }
1531         }
1532         if (max_nid != NULL)
1533                 *max_nid = max_addr;
1534         if (min_nid != NULL)
1535                 *min_nid = min_addr;
1536
1537         return 0;
1538 }
1539
1540 /**
1541  * Takes an nidlist and determines the minimum and maximum
1542  * ip addresses.
1543  *
1544  * \param       *nidlist
1545  * \param[out]  *min_nid if provided, returns string representation of min NID
1546  * \param[out]  *max_nid if provided, returns string representation of max NID
1547  * \retval      -EINVAL unsupported LNET range
1548  * \retval      -ERANGE non-contiguous LNET range
1549  */
1550 static int cfs_ip_min_max(struct list_head *nidlist, __u32 *min_nid,
1551                            __u32 *max_nid)
1552 {
1553         struct nidrange *nr;
1554         struct addrrange *ar;
1555         __u32 tmp_min_ip_addr = 0;
1556         __u32 tmp_max_ip_addr = 0;
1557         __u32 min_ip_addr = 0;
1558         __u32 max_ip_addr = 0;
1559         int nidlist_count = 0;
1560         int rc;
1561
1562         list_for_each_entry(nr, nidlist, nr_link) {
1563                 if (nidlist_count > 0)
1564                         return -EINVAL;
1565
1566                 if (nr->nr_all) {
1567                         min_ip_addr = 0;
1568                         max_ip_addr = 0xffffffff;
1569                         break;
1570                 }
1571
1572                 list_for_each_entry(ar, &nr->nr_addrranges, ar_link) {
1573                         rc = cfs_ip_ar_min_max(ar, &tmp_min_ip_addr,
1574                                                &tmp_max_ip_addr);
1575                         if (rc < 0)
1576                                 return rc;
1577
1578                         if (tmp_min_ip_addr < min_ip_addr || min_ip_addr == 0)
1579                                 min_ip_addr = tmp_min_ip_addr;
1580                         if (tmp_max_ip_addr > max_ip_addr)
1581                                 max_ip_addr = tmp_max_ip_addr;
1582                 }
1583
1584                 nidlist_count++;
1585         }
1586
1587         if (max_nid != NULL)
1588                 *max_nid = max_ip_addr;
1589         if (min_nid != NULL)
1590                 *min_nid = min_ip_addr;
1591
1592         return 0;
1593 }
1594
1595 static int
1596 libcfs_expand_nidrange(struct nidrange *nr, __u32 *addrs, int max_nids)
1597 {
1598         struct addrrange *ar;
1599         int rc = 0, count = max_nids;
1600         struct netstrfns *nf = nr->nr_netstrfns;
1601
1602         list_for_each_entry(ar, &nr->nr_addrranges, ar_link) {
1603                 rc = nf->nf_expand_addrrange(&ar->ar_numaddr_ranges, addrs,
1604                                              count);
1605                 if (rc < 0)
1606                         return rc;
1607
1608                 count -= rc;
1609         }
1610
1611         return max_nids - count;
1612 }
1613
1614 int cfs_expand_nidlist(struct list_head *nidlist, lnet_nid_t *lnet_nidlist,
1615                        int max_nids)
1616 {
1617         struct nidrange *nr;
1618         int rc = 0, count = max_nids;
1619         int i, j = 0;
1620         __u32 *addrs;
1621         struct netstrfns *nf;
1622         __u32 net;
1623
1624         addrs = calloc(max_nids, sizeof(__u32));
1625         if (!addrs)
1626                 return -ENOMEM;
1627
1628         list_for_each_entry(nr, nidlist, nr_link) {
1629                 rc = libcfs_expand_nidrange(nr, addrs, count);
1630
1631                 if (rc < 0) {
1632                         free(addrs);
1633                         return rc;
1634                 }
1635
1636                 nf = nr->nr_netstrfns;
1637                 net = LNET_MKNET(nf->nf_type, nr->nr_netnum);
1638
1639                 for (i = count - 1; i >= count - rc; i--)
1640                         lnet_nidlist[j++] = LNET_MKNID(net, addrs[i]);
1641
1642                 count -= rc;
1643         }
1644
1645         free(addrs);
1646         return max_nids - count;
1647 }