lnet/lnet/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, 2015, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  *
  31  * lnet/lnet/nidstrings.c
  32  *
  33  * Author: Phil Schwan <phil@clusterfs.com>
  34  */
  35
  36 #define DEBUG_SUBSYSTEM S_LNET
  37
  38 #include <linux/sunrpc/addr.h>
  39 #include <libcfs/libcfs.h>
  40 #include <uapi/linux/lnet/nidstr.h>
  41 #include <lnet/lib-types.h>
  42
  43 /* max value for numeric network address */
  44 #define MAX_NUMERIC_VALUE 0xffffffff
  45
  46 #define IPSTRING_LENGTH 16
  47
  48 /* CAVEAT VENDITOR! Keep the canonical string representation of nets/nids
  49  * consistent in all conversion functions.  Some code fragments are copied
  50  * around for the sake of clarity...
  51  */
  52
  53 /* CAVEAT EMPTOR! Racey temporary buffer allocation!
  54  * Choose the number of nidstrings to support the MAXIMUM expected number of
  55  * concurrent users.  If there are more, the returned string will be volatile.
  56  * NB this number must allow for a process to be descheduled for a timeslice
  57  * between getting its string and using it.
  58  */
  59
  60 static char      libcfs_nidstrings[LNET_NIDSTR_COUNT][LNET_NIDSTR_SIZE];
  61 static int       libcfs_nidstring_idx;
  62
  63 static DEFINE_SPINLOCK(libcfs_nidstring_lock);
  64
  65 static struct netstrfns *libcfs_namenum2netstrfns(const char *name);
  66
  67 char *
  68 libcfs_next_nidstring(void)
  69 {
  70         char          *str;
  71         unsigned long  flags;
  72
  73         spin_lock_irqsave(&libcfs_nidstring_lock, flags);
  74
  75         str = libcfs_nidstrings[libcfs_nidstring_idx++];
  76         if (libcfs_nidstring_idx == ARRAY_SIZE(libcfs_nidstrings))
  77                 libcfs_nidstring_idx = 0;
  78
  79         spin_unlock_irqrestore(&libcfs_nidstring_lock, flags);
  80         return str;
  81 }
  82 EXPORT_SYMBOL(libcfs_next_nidstring);
  83
  84 /**
  85  * Nid range list syntax.
  86  * \verbatim
  87  *
  88  * <nidlist>         :== <nidrange> [ ' ' <nidrange> ]
  89  * <nidrange>        :== <addrrange> '@' <net>
  90  * <addrrange>       :== '*' |
  91  *                       <ipaddr_range> |
  92  *                       <cfs_expr_list>
  93  * <ipaddr_range>    :== <cfs_expr_list>.<cfs_expr_list>.<cfs_expr_list>.
  94  *                       <cfs_expr_list>
  95  * <cfs_expr_list>   :== <number> |
  96  *                       <expr_list>
  97  * <expr_list>       :== '[' <range_expr> [ ',' <range_expr>] ']'
  98  * <range_expr>      :== <number> |
  99  *                       <number> '-' <number> |
 100  *                       <number> '-' <number> '/' <number>
 101  * <net>             :== <netname> | <netname><number>
 102  * <netname>         :== "lo" | "tcp" | "o2ib" | "cib" | "openib" | "iib" |
 103  *                       "vib" | "ra" | "elan" | "mx" | "ptl"
 104  * \endverbatim
 105  */
 106
 107 /**
 108  * Structure to represent \<nidrange\> token of the syntax.
 109  *
 110  * One of this is created for each \<net\> parsed.
 111  */
 112 struct nidrange {
 113         /**
 114          * Link to list of this structures which is built on nid range
 115          * list parsing.
 116          */
 117         struct list_head nr_link;
 118         /**
 119          * List head for addrrange::ar_link.
 120          */
 121         struct list_head nr_addrranges;
 122         /**
 123          * Flag indicating that *@<net> is found.
 124          */
 125         int nr_all;
 126         /**
 127          * Pointer to corresponding element of libcfs_netstrfns.
 128          */
 129         struct netstrfns *nr_netstrfns;
 130         /**
 131          * Number of network. E.g. 5 if \<net\> is "elan5".
 132          */
 133         int nr_netnum;
 134 };
 135
 136 /**
 137  * Structure to represent \<addrrange\> token of the syntax.
 138  */
 139 struct addrrange {
 140         /**
 141          * Link to nidrange::nr_addrranges.
 142          */
 143         struct list_head ar_link;
 144         /**
 145          * List head for cfs_expr_list::el_list.
 146          */
 147         struct list_head ar_numaddr_ranges;
 148 };
 149
 150 /**
 151  * Parses \<addrrange\> token on the syntax.
 152  *
 153  * Allocates struct addrrange and links to \a nidrange via
 154  * (nidrange::nr_addrranges)
 155  *
 156  * \retval 0 if \a src parses to '*' | \<ipaddr_range\> | \<cfs_expr_list\>
 157  * \retval -errno otherwise
 158  */
 159 static int
 160 parse_addrange(const struct cfs_lstr *src, struct nidrange *nidrange)
 161 {
 162         struct addrrange *addrrange;
 163
 164         if (src->ls_len == 1 && src->ls_str[0] == '*') {
 165                 nidrange->nr_all = 1;
 166                 return 0;
 167         }
 168
 169         CFS_ALLOC_PTR(addrrange);
 170         if (addrrange == NULL)
 171                 return -ENOMEM;
 172         list_add_tail(&addrrange->ar_link, &nidrange->nr_addrranges);
 173         INIT_LIST_HEAD(&addrrange->ar_numaddr_ranges);
 174
 175         return nidrange->nr_netstrfns->nf_parse_addrlist(src->ls_str,
 176                                                 src->ls_len,
 177                                                 &addrrange->ar_numaddr_ranges);
 178 }
 179
 180 /**
 181  * Finds or creates struct nidrange.
 182  *
 183  * Checks if \a src is a valid network name, looks for corresponding
 184  * nidrange on the ist of nidranges (\a nidlist), creates new struct
 185  * nidrange if it is not found.
 186  *
 187  * \retval pointer to struct nidrange matching network specified via \a src
 188  * \retval NULL if \a src does not match any network
 189  */
 190 static struct nidrange *
 191 add_nidrange(const struct cfs_lstr *src,
 192              struct list_head *nidlist)
 193 {
 194         struct netstrfns *nf;
 195         struct nidrange *nr;
 196         int endlen;
 197         unsigned netnum;
 198
 199         if (src->ls_len >= LNET_NIDSTR_SIZE)
 200                 return NULL;
 201
 202         nf = libcfs_namenum2netstrfns(src->ls_str);
 203         if (nf == NULL)
 204                 return NULL;
 205         endlen = src->ls_len - strlen(nf->nf_name);
 206         if (endlen == 0)
 207                 /* network name only, e.g. "elan" or "tcp" */
 208                 netnum = 0;
 209         else {
 210                 /* e.g. "elan25" or "tcp23", refuse to parse if
 211                  * network name is not appended with decimal or
 212                  * hexadecimal number */
 213                 if (!cfs_str2num_check(src->ls_str + strlen(nf->nf_name),
 214                                        endlen, &netnum, 0, MAX_NUMERIC_VALUE))
 215                         return NULL;
 216         }
 217
 218         list_for_each_entry(nr, nidlist, nr_link) {
 219                 if (nr->nr_netstrfns != nf)
 220                         continue;
 221                 if (nr->nr_netnum != netnum)
 222                         continue;
 223                 return nr;
 224         }
 225
 226         CFS_ALLOC_PTR(nr);
 227         if (nr == NULL)
 228                 return NULL;
 229         list_add_tail(&nr->nr_link, nidlist);
 230         INIT_LIST_HEAD(&nr->nr_addrranges);
 231         nr->nr_netstrfns = nf;
 232         nr->nr_all = 0;
 233         nr->nr_netnum = netnum;
 234
 235         return nr;
 236 }
 237
 238 /**
 239  * Parses \<nidrange\> token of the syntax.
 240  *
 241  * \retval 1 if \a src parses to \<addrrange\> '@' \<net\>
 242  * \retval 0 otherwise
 243  */
 244 static int
 245 parse_nidrange(struct cfs_lstr *src, struct list_head *nidlist)
 246 {
 247         struct cfs_lstr addrrange;
 248         struct cfs_lstr net;
 249         struct nidrange *nr;
 250
 251         if (cfs_gettok(src, '@', &addrrange) == 0)
 252                 goto failed;
 253
 254         if (cfs_gettok(src, '@', &net) == 0 || src->ls_str != NULL)
 255                 goto failed;
 256
 257         nr = add_nidrange(&net, nidlist);
 258         if (nr == NULL)
 259                 goto failed;
 260
 261         if (parse_addrange(&addrrange, nr) != 0)
 262                 goto failed;
 263
 264         return 1;
 265 failed:
 266         return 0;
 267 }
 268
 269 /**
 270  * Frees addrrange structures of \a list.
 271  *
 272  * For each struct addrrange structure found on \a list it frees
 273  * cfs_expr_list list attached to it and frees the addrrange itself.
 274  *
 275  * \retval none
 276  */
 277 static void
 278 free_addrranges(struct list_head *list)
 279 {
 280         struct addrrange *ar;
 281
 282         while ((ar = list_first_entry_or_null(list,
 283                                               struct addrrange,
 284                                               ar_link)) != NULL) {
 285                 cfs_expr_list_free_list(&ar->ar_numaddr_ranges);
 286                 list_del(&ar->ar_link);
 287                 CFS_FREE_PTR(ar);
 288         }
 289 }
 290
 291 /**
 292  * Frees nidrange strutures of \a list.
 293  *
 294  * For each struct nidrange structure found on \a list it frees
 295  * addrrange list attached to it and frees the nidrange itself.
 296  *
 297  * \retval none
 298  */
 299 void
 300 cfs_free_nidlist(struct list_head *list)
 301 {
 302         struct list_head *pos, *next;
 303         struct nidrange *nr;
 304
 305         list_for_each_safe(pos, next, list) {
 306                 nr = list_entry(pos, struct nidrange, nr_link);
 307                 free_addrranges(&nr->nr_addrranges);
 308                 list_del(pos);
 309                 CFS_FREE_PTR(nr);
 310         }
 311 }
 312 EXPORT_SYMBOL(cfs_free_nidlist);
 313
 314 /**
 315  * Parses nid range list.
 316  *
 317  * Parses with rigorous syntax and overflow checking \a str into
 318  * \<nidrange\> [ ' ' \<nidrange\> ], compiles \a str into set of
 319  * structures and links that structure to \a nidlist. The resulting
 320  * list can be used to match a NID againts set of NIDS defined by \a
 321  * str.
 322  * \see cfs_match_nid
 323  *
 324  * \retval 1 on success
 325  * \retval 0 otherwise
 326  */
 327 int
 328 cfs_parse_nidlist(char *str, int len, struct list_head *nidlist)
 329 {
 330         struct cfs_lstr src;
 331         struct cfs_lstr res;
 332         int rc;
 333
 334         src.ls_str = str;
 335         src.ls_len = len;
 336         INIT_LIST_HEAD(nidlist);
 337         while (src.ls_str) {
 338                 rc = cfs_gettok(&src, ' ', &res);
 339                 if (rc == 0) {
 340                         cfs_free_nidlist(nidlist);
 341                         return 0;
 342                 }
 343                 rc = parse_nidrange(&res, nidlist);
 344                 if (rc == 0) {
 345                         cfs_free_nidlist(nidlist);
 346                         return 0;
 347                 }
 348         }
 349         return 1;
 350 }
 351 EXPORT_SYMBOL(cfs_parse_nidlist);
 352
 353 /**
 354  * Matches a nid (\a nid) against the compiled list of nidranges (\a nidlist).
 355  *
 356  * \see cfs_parse_nidlist()
 357  *
 358  * \retval 1 on match
 359  * \retval 0  otherwises
 360  */
 361 int cfs_match_nid(lnet_nid_t nid, struct list_head *nidlist)
 362 {
 363         struct nidrange *nr;
 364         struct addrrange *ar;
 365
 366         list_for_each_entry(nr, nidlist, nr_link) {
 367                 if (nr->nr_netstrfns->nf_type != LNET_NETTYP(LNET_NIDNET(nid)))
 368                         continue;
 369                 if (nr->nr_netnum != LNET_NETNUM(LNET_NIDNET(nid)))
 370                         continue;
 371                 if (nr->nr_all)
 372                         return 1;
 373                 list_for_each_entry(ar, &nr->nr_addrranges, ar_link)
 374                         if (nr->nr_netstrfns->nf_match_addr(LNET_NIDADDR(nid),
 375                                                         &ar->ar_numaddr_ranges))
 376                                 return 1;
 377         }
 378         return 0;
 379 }
 380 EXPORT_SYMBOL(cfs_match_nid);
 381
 382 /**
 383  * Print the network part of the nidrange \a nr into the specified \a buffer.
 384  *
 385  * \retval number of characters written
 386  */
 387 static int
 388 cfs_print_network(char *buffer, int count, struct nidrange *nr)
 389 {
 390         struct netstrfns *nf = nr->nr_netstrfns;
 391
 392         if (nr->nr_netnum == 0)
 393                 return scnprintf(buffer, count, "@%s", nf->nf_name);
 394         else
 395                 return scnprintf(buffer, count, "@%s%u",
 396                                     nf->nf_name, nr->nr_netnum);
 397 }
 398
 399 /**
 400  * Print a list of addrrange (\a addrranges) into the specified \a buffer.
 401  * At max \a count characters can be printed into \a buffer.
 402  *
 403  * \retval number of characters written
 404  */
 405 static int
 406 cfs_print_addrranges(char *buffer, int count, struct list_head *addrranges,
 407                      struct nidrange *nr)
 408 {
 409         int i = 0;
 410         struct addrrange *ar;
 411         struct netstrfns *nf = nr->nr_netstrfns;
 412
 413         list_for_each_entry(ar, addrranges, ar_link) {
 414                 if (i != 0)
 415                         i += scnprintf(buffer + i, count - i, " ");
 416                 i += nf->nf_print_addrlist(buffer + i, count - i,
 417                                            &ar->ar_numaddr_ranges);
 418                 i += cfs_print_network(buffer + i, count - i, nr);
 419         }
 420         return i;
 421 }
 422
 423 /**
 424  * Print a list of nidranges (\a nidlist) into the specified \a buffer.
 425  * At max \a count characters can be printed into \a buffer.
 426  * Nidranges are separated by a space character.
 427  *
 428  * \retval number of characters written
 429  */
 430 int cfs_print_nidlist(char *buffer, int count, struct list_head *nidlist)
 431 {
 432         int i = 0;
 433         struct nidrange *nr;
 434
 435         if (count <= 0)
 436                 return 0;
 437
 438         list_for_each_entry(nr, nidlist, nr_link) {
 439                 if (i != 0)
 440                         i += scnprintf(buffer + i, count - i, " ");
 441
 442                 if (nr->nr_all != 0) {
 443                         LASSERT(list_empty(&nr->nr_addrranges));
 444                         i += scnprintf(buffer + i, count - i, "*");
 445                         i += cfs_print_network(buffer + i, count - i, nr);
 446                 } else {
 447                         i += cfs_print_addrranges(buffer + i, count - i,
 448                                                   &nr->nr_addrranges, nr);
 449                 }
 450         }
 451         return i;
 452 }
 453 EXPORT_SYMBOL(cfs_print_nidlist);
 454
 455 static int
 456 libcfs_lo_str2addr(const char *str, int nob, __u32 *addr)
 457 {
 458         *addr = 0;
 459         return 1;
 460 }
 461
 462 static void
 463 libcfs_ip_addr2str(__u32 addr, char *str, size_t size)
 464 {
 465         snprintf(str, size, "%u.%u.%u.%u",
 466                  (addr >> 24) & 0xff, (addr >> 16) & 0xff,
 467                  (addr >> 8) & 0xff, addr & 0xff);
 468 }
 469
 470 static void
 471 libcfs_ip_addr2str_size(const __be32 *addr, size_t asize,
 472                         char *str, size_t size)
 473 {
 474         struct sockaddr_storage sa = {};
 475
 476         switch (asize) {
 477         case 4:
 478                 sa.ss_family = AF_INET;
 479                 memcpy(&((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
 480                        addr, asize);
 481                 break;
 482         case 16:
 483                 sa.ss_family = AF_INET6;
 484                 memcpy(&((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
 485                        addr, asize);
 486                 break;
 487         default:
 488                 return;
 489         }
 490
 491         rpc_ntop((struct sockaddr *)&sa, str, size);
 492 }
 493
 494 /* CAVEAT EMPTOR XscanfX
 495  * I use "%n" at the end of a sscanf format to detect trailing junk.  However
 496  * sscanf may return immediately if it sees the terminating '0' in a string, so
 497  * I initialise the %n variable to the expected length.  If sscanf sets it;
 498  * fine, if it doesn't, then the scan ended at the end of the string, which is
 499  * fine too :) */
 500 static int
 501 libcfs_ip_str2addr(const char *str, int nob, __u32 *addr)
 502 {
 503         unsigned int    a;
 504         unsigned int    b;
 505         unsigned int    c;
 506         unsigned int    d;
 507         int             n = nob; /* XscanfX */
 508
 509         /* numeric IP? */
 510         if (sscanf(str, "%u.%u.%u.%u%n", &a, &b, &c, &d, &n) >= 4 &&
 511             n == nob &&
 512             (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
 513             (c & ~0xff) == 0 && (d & ~0xff) == 0) {
 514                 *addr = ((a<<24)|(b<<16)|(c<<8)|d);
 515                 return 1;
 516         }
 517         return 0;
 518 }
 519
 520 static int
 521 libcfs_ip_str2addr_size(const char *str, int nob,
 522                         __be32 *addr, size_t *alen)
 523 {
 524         struct sockaddr_storage sa;
 525
 526         /* Note: 'net' arg to rpc_pton is only needed for link-local
 527          * addresses.  Such addresses would not work with LNet routing,
 528          * so we can assume they aren't used.  So it doesn't matter
 529          * which net namespace is passed.
 530          */
 531         if (rpc_pton(&init_net, str, nob,
 532                      (struct sockaddr *)&sa, sizeof(sa)) == 0)
 533                 return 0;
 534         if (sa.ss_family == AF_INET6) {
 535                 memcpy(addr,
 536                        &((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
 537                        16);
 538                 *alen = 16;
 539                 return 1;
 540         }
 541         if (sa.ss_family == AF_INET) {
 542                 memcpy(addr,
 543                        &((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
 544                        4);
 545                 *alen = 4;
 546                 return 1;
 547         }
 548         return 0;
 549 }
 550
 551
 552 /* Used by lnet/config.c so it can't be static */
 553 int
 554 cfs_ip_addr_parse(char *str, int len, struct list_head *list)
 555 {
 556         struct cfs_expr_list *el;
 557         struct cfs_lstr src;
 558         int rc;
 559         int i;
 560
 561         src.ls_str = str;
 562         src.ls_len = len;
 563         i = 0;
 564
 565         while (src.ls_str != NULL) {
 566                 struct cfs_lstr res;
 567
 568                 if (!cfs_gettok(&src, '.', &res)) {
 569                         rc = -EINVAL;
 570                         goto out;
 571                 }
 572
 573                 rc = cfs_expr_list_parse(res.ls_str, res.ls_len, 0, 255, &el);
 574                 if (rc != 0)
 575                         goto out;
 576
 577                 list_add_tail(&el->el_link, list);
 578                 i++;
 579         }
 580
 581         if (i == 4)
 582                 return 0;
 583
 584         rc = -EINVAL;
 585 out:
 586         cfs_expr_list_free_list(list);
 587
 588         return rc;
 589 }
 590
 591 static int
 592 libcfs_ip_addr_range_print(char *buffer, int count, struct list_head *list)
 593 {
 594         int i = 0, j = 0;
 595         struct cfs_expr_list *el;
 596
 597         list_for_each_entry(el, list, el_link) {
 598                 LASSERT(j++ < 4);
 599                 if (i != 0)
 600                         i += scnprintf(buffer + i, count - i, ".");
 601                 i += cfs_expr_list_print(buffer + i, count - i, el);
 602         }
 603         return i;
 604 }
 605
 606 /**
 607  * Matches address (\a addr) against address set encoded in \a list.
 608  *
 609  * \retval 1 if \a addr matches
 610  * \retval 0 otherwise
 611  */
 612 int
 613 cfs_ip_addr_match(__u32 addr, struct list_head *list)
 614 {
 615         struct cfs_expr_list *el;
 616         int i = 0;
 617
 618         list_for_each_entry_reverse(el, list, el_link) {
 619                 if (!cfs_expr_list_match(addr & 0xff, el))
 620                         return 0;
 621                 addr >>= 8;
 622                 i++;
 623         }
 624
 625         return i == 4;
 626 }
 627
 628 /**
 629  * Print the network part of the nidrange \a nr into the specified \a buffer.
 630  *
 631  * \retval number of characters written
 632  */
 633 static void
 634 libcfs_decnum_addr2str(__u32 addr, char *str, size_t size)
 635 {
 636         snprintf(str, size, "%u", addr);
 637 }
 638
 639 static int
 640 libcfs_num_str2addr(const char *str, int nob, __u32 *addr)
 641 {
 642         int     n;
 643
 644         n = nob;
 645         if (sscanf(str, "0x%x%n", addr, &n) >= 1 && n == nob)
 646                 return 1;
 647
 648         n = nob;
 649         if (sscanf(str, "0X%x%n", addr, &n) >= 1 && n == nob)
 650                 return 1;
 651
 652         n = nob;
 653         if (sscanf(str, "%u%n", addr, &n) >= 1 && n == nob)
 654                 return 1;
 655
 656         return 0;
 657 }
 658
 659 /**
 660  * Nf_parse_addrlist method for networks using numeric addresses.
 661  *
 662  * Examples of such networks are gm and elan.
 663  *
 664  * \retval 0 if \a str parsed to numeric address
 665  * \retval errno otherwise
 666  */
 667 int
 668 libcfs_num_parse(char *str, int len, struct list_head *list)
 669 {
 670         struct cfs_expr_list *el;
 671         int     rc;
 672
 673         rc = cfs_expr_list_parse(str, len, 0, MAX_NUMERIC_VALUE, &el);
 674         if (rc == 0)
 675                 list_add_tail(&el->el_link, list);
 676
 677         return rc;
 678 }
 679
 680 static int
 681 libcfs_num_addr_range_print(char *buffer, int count, struct list_head *list)
 682 {
 683         int i = 0, j = 0;
 684         struct cfs_expr_list *el;
 685
 686         list_for_each_entry(el, list, el_link) {
 687                 LASSERT(j++ < 1);
 688                 i += cfs_expr_list_print(buffer + i, count - i, el);
 689         }
 690         return i;
 691 }
 692
 693 /*
 694  * Nf_match_addr method for networks using numeric addresses
 695  *
 696  * \retval 1 on match
 697  * \retval 0 otherwise
 698  */
 699 static int
 700 libcfs_num_match(__u32 addr, struct list_head *numaddr)
 701 {
 702         struct cfs_expr_list *el;
 703
 704         LASSERT(!list_empty(numaddr));
 705         el = list_first_entry(numaddr, struct cfs_expr_list, el_link);
 706
 707         return cfs_expr_list_match(addr, el);
 708 }
 709
 710 static struct netstrfns libcfs_netstrfns[] = {
 711         { .nf_type              = LOLND,
 712           .nf_name              = "lo",
 713           .nf_modname           = "klolnd",
 714           .nf_addr2str          = libcfs_decnum_addr2str,
 715           .nf_str2addr          = libcfs_lo_str2addr,
 716           .nf_parse_addrlist    = libcfs_num_parse,
 717           .nf_print_addrlist    = libcfs_num_addr_range_print,
 718           .nf_match_addr        = libcfs_num_match
 719         },
 720         { .nf_type              = SOCKLND,
 721           .nf_name              = "tcp",
 722           .nf_modname           = "ksocklnd",
 723           .nf_addr2str          = libcfs_ip_addr2str,
 724           .nf_addr2str_size     = libcfs_ip_addr2str_size,
 725           .nf_str2addr          = libcfs_ip_str2addr,
 726           .nf_str2addr_size     = libcfs_ip_str2addr_size,
 727           .nf_parse_addrlist    = cfs_ip_addr_parse,
 728           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 729           .nf_match_addr        = cfs_ip_addr_match
 730         },
 731         { .nf_type              = O2IBLND,
 732           .nf_name              = "o2ib",
 733           .nf_modname           = "ko2iblnd",
 734           .nf_addr2str          = libcfs_ip_addr2str,
 735           .nf_str2addr          = libcfs_ip_str2addr,
 736           .nf_parse_addrlist    = cfs_ip_addr_parse,
 737           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 738           .nf_match_addr        = cfs_ip_addr_match
 739         },
 740         { .nf_type              = GNILND,
 741           .nf_name              = "gni",
 742           .nf_modname           = "kgnilnd",
 743           .nf_addr2str          = libcfs_decnum_addr2str,
 744           .nf_str2addr          = libcfs_num_str2addr,
 745           .nf_parse_addrlist    = libcfs_num_parse,
 746           .nf_print_addrlist    = libcfs_num_addr_range_print,
 747           .nf_match_addr        = libcfs_num_match
 748         },
 749         { .nf_type              = GNIIPLND,
 750           .nf_name              = "gip",
 751           .nf_modname           = "kgnilnd",
 752           .nf_addr2str          = libcfs_ip_addr2str,
 753           .nf_str2addr          = libcfs_ip_str2addr,
 754           .nf_parse_addrlist    = cfs_ip_addr_parse,
 755           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 756           .nf_match_addr        = cfs_ip_addr_match
 757         },
 758         { .nf_type              = PTL4LND,
 759           .nf_name              = "ptlf",
 760           .nf_modname           = "kptl4lnd",
 761           .nf_addr2str          = libcfs_decnum_addr2str,
 762           .nf_str2addr          = libcfs_num_str2addr,
 763           .nf_parse_addrlist    = libcfs_num_parse,
 764           .nf_print_addrlist    = libcfs_num_addr_range_print,
 765           .nf_match_addr        = libcfs_num_match
 766         },
 767 };
 768
 769 static const size_t libcfs_nnetstrfns = ARRAY_SIZE(libcfs_netstrfns);
 770
 771 static struct netstrfns *
 772 type2net_info(__u32 net_type)
 773 {
 774         int i;
 775
 776         for (i = 0; i < libcfs_nnetstrfns; i++) {
 777                 if (libcfs_netstrfns[i].nf_type == net_type)
 778                         return &libcfs_netstrfns[i];
 779         }
 780
 781         return NULL;
 782 }
 783
 784 int
 785 cfs_match_net(__u32 net_id, __u32 net_type, struct list_head *net_num_list)
 786 {
 787         __u32 net_num;
 788
 789         if (!net_num_list)
 790                 return 0;
 791
 792         if (net_type != LNET_NETTYP(net_id))
 793                 return 0;
 794
 795         net_num = LNET_NETNUM(net_id);
 796
 797         /* if there is a net number but the list passed in is empty, then
 798          * there is no match.
 799          */
 800         if (!net_num && list_empty(net_num_list))
 801                 return 1;
 802         else if (list_empty(net_num_list))
 803                 return 0;
 804
 805         if (!libcfs_num_match(net_num, net_num_list))
 806                 return 0;
 807
 808         return 1;
 809 }
 810
 811 int
 812 cfs_match_nid_net(struct lnet_nid *nid, __u32 net_type,
 813                    struct list_head *net_num_list,
 814                    struct list_head *addr)
 815 {
 816         __u32 address;
 817         struct netstrfns *nf;
 818
 819         if (!addr || !net_num_list)
 820                 return 0;
 821
 822         nf = type2net_info(LNET_NETTYP(LNET_NID_NET(nid)));
 823         if (!nf || !net_num_list || !addr)
 824                 return 0;
 825
 826         /* FIXME handle long-addr nid */
 827         address = LNET_NIDADDR(lnet_nid_to_nid4(nid));
 828
 829         /* if either the address or net number don't match then no match */
 830         if (!nf->nf_match_addr(address, addr) ||
 831             !cfs_match_net(LNET_NID_NET(nid), net_type, net_num_list))
 832                 return 0;
 833
 834         return 1;
 835 }
 836 EXPORT_SYMBOL(cfs_match_nid_net);
 837
 838 static struct netstrfns *
 839 libcfs_lnd2netstrfns(__u32 lnd)
 840 {
 841         int     i;
 842
 843         for (i = 0; i < libcfs_nnetstrfns; i++)
 844                 if (lnd == libcfs_netstrfns[i].nf_type)
 845                         return &libcfs_netstrfns[i];
 846
 847         return NULL;
 848 }
 849
 850 static struct netstrfns *
 851 libcfs_namenum2netstrfns(const char *name)
 852 {
 853         struct netstrfns *nf;
 854         int               i;
 855
 856         for (i = 0; i < libcfs_nnetstrfns; i++) {
 857                 nf = &libcfs_netstrfns[i];
 858                 if (!strncmp(name, nf->nf_name, strlen(nf->nf_name)))
 859                         return nf;
 860         }
 861         return NULL;
 862 }
 863
 864 static struct netstrfns *
 865 libcfs_name2netstrfns(const char *name)
 866 {
 867         int    i;
 868
 869         for (i = 0; i < libcfs_nnetstrfns; i++)
 870                 if (!strcmp(libcfs_netstrfns[i].nf_name, name))
 871                         return &libcfs_netstrfns[i];
 872
 873         return NULL;
 874 }
 875
 876 int
 877 libcfs_isknown_lnd(__u32 lnd)
 878 {
 879         return libcfs_lnd2netstrfns(lnd) != NULL;
 880 }
 881 EXPORT_SYMBOL(libcfs_isknown_lnd);
 882
 883 char *
 884 libcfs_lnd2modname(__u32 lnd)
 885 {
 886         struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
 887
 888         return (nf == NULL) ? NULL : nf->nf_modname;
 889 }
 890 EXPORT_SYMBOL(libcfs_lnd2modname);
 891
 892 int
 893 libcfs_str2lnd(const char *str)
 894 {
 895         struct netstrfns *nf = libcfs_name2netstrfns(str);
 896
 897         if (nf != NULL)
 898                 return nf->nf_type;
 899
 900         return -ENXIO;
 901 }
 902 EXPORT_SYMBOL(libcfs_str2lnd);
 903
 904 char *
 905 libcfs_lnd2str_r(__u32 lnd, char *buf, size_t buf_size)
 906 {
 907         struct netstrfns *nf;
 908
 909         nf = libcfs_lnd2netstrfns(lnd);
 910         if (nf == NULL)
 911                 snprintf(buf, buf_size, "?%u?", lnd);
 912         else
 913                 snprintf(buf, buf_size, "%s", nf->nf_name);
 914
 915         return buf;
 916 }
 917 EXPORT_SYMBOL(libcfs_lnd2str_r);
 918
 919 char *
 920 libcfs_net2str_r(__u32 net, char *buf, size_t buf_size)
 921 {
 922         __u32             nnum = LNET_NETNUM(net);
 923         __u32             lnd  = LNET_NETTYP(net);
 924         struct netstrfns *nf;
 925
 926         nf = libcfs_lnd2netstrfns(lnd);
 927         if (nf == NULL)
 928                 snprintf(buf, buf_size, "<%u:%u>", lnd, nnum);
 929         else if (nnum == 0)
 930                 snprintf(buf, buf_size, "%s", nf->nf_name);
 931         else
 932                 snprintf(buf, buf_size, "%s%u", nf->nf_name, nnum);
 933
 934         return buf;
 935 }
 936 EXPORT_SYMBOL(libcfs_net2str_r);
 937
 938 char *
 939 libcfs_nid2str_r(lnet_nid_t nid, char *buf, size_t buf_size)
 940 {
 941         __u32             addr = LNET_NIDADDR(nid);
 942         __u32             net  = LNET_NIDNET(nid);
 943         __u32             nnum = LNET_NETNUM(net);
 944         __u32             lnd  = LNET_NETTYP(net);
 945         struct netstrfns *nf;
 946
 947         if (nid == LNET_NID_ANY) {
 948                 strncpy(buf, "<?>", buf_size);
 949                 buf[buf_size - 1] = '\0';
 950                 return buf;
 951         }
 952
 953         nf = libcfs_lnd2netstrfns(lnd);
 954         if (nf == NULL) {
 955                 snprintf(buf, buf_size, "%x@<%u:%u>", addr, lnd, nnum);
 956         } else {
 957                 size_t addr_len;
 958
 959                 nf->nf_addr2str(addr, buf, buf_size);
 960                 addr_len = strlen(buf);
 961                 if (nnum == 0)
 962                         snprintf(buf + addr_len, buf_size - addr_len, "@%s",
 963                                  nf->nf_name);
 964                 else
 965                         snprintf(buf + addr_len, buf_size - addr_len, "@%s%u",
 966                                  nf->nf_name, nnum);
 967         }
 968
 969         return buf;
 970 }
 971 EXPORT_SYMBOL(libcfs_nid2str_r);
 972
 973 char *
 974 libcfs_nidstr_r(const struct lnet_nid *nid, char *buf, size_t buf_size)
 975 {
 976         __u32 nnum;
 977         __u32 lnd;
 978         struct netstrfns *nf;
 979
 980         if (LNET_NID_IS_ANY(nid)) {
 981                 strncpy(buf, "<?>", buf_size);
 982                 buf[buf_size - 1] = '\0';
 983                 return buf;
 984         }
 985
 986         nnum = be16_to_cpu(nid->nid_num);
 987         lnd = nid->nid_type;
 988         nf = libcfs_lnd2netstrfns(lnd);
 989         if (nf) {
 990                 size_t addr_len;
 991
 992                 if (nf->nf_addr2str_size)
 993                         nf->nf_addr2str_size(nid->nid_addr, NID_ADDR_BYTES(nid),
 994                                              buf, buf_size);
 995                 else
 996                         nf->nf_addr2str(ntohl(nid->nid_addr[0]), buf, buf_size);
 997                 addr_len = strlen(buf);
 998                 if (nnum == 0)
 999                         snprintf(buf + addr_len, buf_size - addr_len, "@%s",
1000                                  nf->nf_name);
1001                 else
1002                         snprintf(buf + addr_len, buf_size - addr_len, "@%s%u",
1003                                  nf->nf_name, nnum);
1004         } else {
1005                 int l = 0;
1006                 int words = DIV_ROUND_UP(NID_ADDR_BYTES(nid), 4);
1007                 int i;
1008
1009                 for (i = 0; i < words && i < 4; i++)
1010                         l = snprintf(buf+l, buf_size-l, "%s%x",
1011                                      i ? ":" : "", ntohl(nid->nid_addr[i]));
1012                 snprintf(buf+l, buf_size-l, "@<%u:%u>", lnd, nnum);
1013         }
1014
1015         return buf;
1016 }
1017 EXPORT_SYMBOL(libcfs_nidstr_r);
1018
1019 static struct netstrfns *
1020 libcfs_str2net_internal(const char *str, __u32 *net)
1021 {
1022         struct netstrfns *nf = NULL;
1023         int               nob;
1024         unsigned int      netnum;
1025         int               i;
1026
1027         for (i = 0; i < libcfs_nnetstrfns; i++) {
1028                 nf = &libcfs_netstrfns[i];
1029                 if (!strncmp(str, nf->nf_name, strlen(nf->nf_name)))
1030                         break;
1031         }
1032
1033         if (i == libcfs_nnetstrfns)
1034                 return NULL;
1035
1036         nob = strlen(nf->nf_name);
1037
1038         if (strlen(str) == (unsigned int)nob) {
1039                 netnum = 0;
1040         } else {
1041                 if (nf->nf_type == LOLND) /* net number not allowed */
1042                         return NULL;
1043
1044                 str += nob;
1045                 i = strlen(str);
1046                 if (sscanf(str, "%u%n", &netnum, &i) < 1 ||
1047                     i != (int)strlen(str))
1048                         return NULL;
1049         }
1050
1051         *net = LNET_MKNET(nf->nf_type, netnum);
1052         return nf;
1053 }
1054
1055 __u32
1056 libcfs_str2net(const char *str)
1057 {
1058         __u32  net;
1059
1060         if (libcfs_str2net_internal(str, &net) != NULL)
1061                 return net;
1062
1063         return LNET_NET_ANY;
1064 }
1065 EXPORT_SYMBOL(libcfs_str2net);
1066
1067 lnet_nid_t
1068 libcfs_str2nid(const char *str)
1069 {
1070         const char       *sep = strchr(str, '@');
1071         struct netstrfns *nf;
1072         __u32             net;
1073         __u32             addr;
1074
1075         if (sep != NULL) {
1076                 nf = libcfs_str2net_internal(sep + 1, &net);
1077                 if (nf == NULL)
1078                         return LNET_NID_ANY;
1079         } else {
1080                 sep = str + strlen(str);
1081                 net = LNET_MKNET(SOCKLND, 0);
1082                 nf = libcfs_lnd2netstrfns(SOCKLND);
1083                 LASSERT(nf != NULL);
1084         }
1085
1086         if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
1087                 return LNET_NID_ANY;
1088
1089         return LNET_MKNID(net, addr);
1090 }
1091 EXPORT_SYMBOL(libcfs_str2nid);
1092
1093 int
1094 libcfs_strnid(struct lnet_nid *nid, const char *str)
1095 {
1096         const char       *sep = strchr(str, '@');
1097         struct netstrfns *nf;
1098         __u32             net;
1099
1100         if (sep != NULL) {
1101                 nf = libcfs_str2net_internal(sep + 1, &net);
1102                 if (nf == NULL)
1103                         return -EINVAL;
1104         } else {
1105                 sep = str + strlen(str);
1106                 net = LNET_MKNET(SOCKLND, 0);
1107                 nf = libcfs_lnd2netstrfns(SOCKLND);
1108                 LASSERT(nf != NULL);
1109         }
1110
1111         memset(nid, 0, sizeof(*nid));
1112         nid->nid_type = LNET_NETTYP(net);
1113         nid->nid_num = htons(LNET_NETNUM(net));
1114         if (nf->nf_str2addr_size) {
1115                 size_t asize = 0;
1116
1117                 if (!nf->nf_str2addr_size(str, (int)(sep - str),
1118                                           nid->nid_addr, &asize))
1119                         return -EINVAL;
1120                 nid->nid_size = asize - 4;
1121         } else {
1122                 __u32 addr;
1123
1124                 if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
1125                         return -EINVAL;
1126                 nid->nid_addr[0] = htonl(addr);
1127                 nid->nid_size = 0;
1128         }
1129         return 0;
1130 }
1131 EXPORT_SYMBOL(libcfs_strnid);
1132
1133 char *
1134 libcfs_id2str(struct lnet_process_id id)
1135 {
1136         char *str = libcfs_next_nidstring();
1137
1138         if (id.pid == LNET_PID_ANY) {
1139                 snprintf(str, LNET_NIDSTR_SIZE,
1140                          "LNET_PID_ANY-%s", libcfs_nid2str(id.nid));
1141                 return str;
1142         }
1143
1144         snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
1145                  ((id.pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
1146                  (id.pid & ~LNET_PID_USERFLAG), libcfs_nid2str(id.nid));
1147         return str;
1148 }
1149 EXPORT_SYMBOL(libcfs_id2str);
1150
1151 char *
1152 libcfs_idstr(struct lnet_processid *id)
1153 {
1154         char *str = libcfs_next_nidstring();
1155
1156         if (id->pid == LNET_PID_ANY) {
1157                 snprintf(str, LNET_NIDSTR_SIZE,
1158                          "LNET_PID_ANY-%s", libcfs_nidstr(&id->nid));
1159                 return str;
1160         }
1161
1162         snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
1163                  ((id->pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
1164                  (id->pid & ~LNET_PID_USERFLAG), libcfs_nidstr(&id->nid));
1165         return str;
1166 }
1167 EXPORT_SYMBOL(libcfs_idstr);
1168
1169 int
1170 libcfs_str2anynid(lnet_nid_t *nidp, const char *str)
1171 {
1172         if (!strcmp(str, "*")) {
1173                 *nidp = LNET_NID_ANY;
1174                 return 1;
1175         }
1176
1177         *nidp = libcfs_str2nid(str);
1178         return *nidp != LNET_NID_ANY;
1179 }
1180 EXPORT_SYMBOL(libcfs_str2anynid);