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(struct lnet_nid *nid, struct list_head *nidlist)
 362 {
 363         struct nidrange *nr;
 364         struct addrrange *ar;
 365
 366         if (!nid_is_nid4(nid))
 367                 return 0;
 368         list_for_each_entry(nr, nidlist, nr_link) {
 369                 if (nr->nr_netstrfns->nf_type != nid->nid_type)
 370                         continue;
 371                 if (nr->nr_netnum != be16_to_cpu(nid->nid_num))
 372                         continue;
 373                 if (nr->nr_all)
 374                         return 1;
 375                 list_for_each_entry(ar, &nr->nr_addrranges, ar_link)
 376                         if (nr->nr_netstrfns->nf_match_addr(
 377                                     be32_to_cpu(nid->nid_addr[0]),
 378                                     &ar->ar_numaddr_ranges))
 379                                 return 1;
 380         }
 381         return 0;
 382 }
 383 EXPORT_SYMBOL(cfs_match_nid);
 384
 385 /**
 386  * Print the network part of the nidrange \a nr into the specified \a buffer.
 387  *
 388  * \retval number of characters written
 389  */
 390 static int
 391 cfs_print_network(char *buffer, int count, struct nidrange *nr)
 392 {
 393         struct netstrfns *nf = nr->nr_netstrfns;
 394
 395         if (nr->nr_netnum == 0)
 396                 return scnprintf(buffer, count, "@%s", nf->nf_name);
 397         else
 398                 return scnprintf(buffer, count, "@%s%u",
 399                                     nf->nf_name, nr->nr_netnum);
 400 }
 401
 402 /**
 403  * Print a list of addrrange (\a addrranges) into the specified \a buffer.
 404  * At max \a count characters can be printed into \a buffer.
 405  *
 406  * \retval number of characters written
 407  */
 408 static int
 409 cfs_print_addrranges(char *buffer, int count, struct list_head *addrranges,
 410                      struct nidrange *nr)
 411 {
 412         int i = 0;
 413         struct addrrange *ar;
 414         struct netstrfns *nf = nr->nr_netstrfns;
 415
 416         list_for_each_entry(ar, addrranges, ar_link) {
 417                 if (i != 0)
 418                         i += scnprintf(buffer + i, count - i, " ");
 419                 i += nf->nf_print_addrlist(buffer + i, count - i,
 420                                            &ar->ar_numaddr_ranges);
 421                 i += cfs_print_network(buffer + i, count - i, nr);
 422         }
 423         return i;
 424 }
 425
 426 /**
 427  * Print a list of nidranges (\a nidlist) into the specified \a buffer.
 428  * At max \a count characters can be printed into \a buffer.
 429  * Nidranges are separated by a space character.
 430  *
 431  * \retval number of characters written
 432  */
 433 int cfs_print_nidlist(char *buffer, int count, struct list_head *nidlist)
 434 {
 435         int i = 0;
 436         struct nidrange *nr;
 437
 438         if (count <= 0)
 439                 return 0;
 440
 441         list_for_each_entry(nr, nidlist, nr_link) {
 442                 if (i != 0)
 443                         i += scnprintf(buffer + i, count - i, " ");
 444
 445                 if (nr->nr_all != 0) {
 446                         LASSERT(list_empty(&nr->nr_addrranges));
 447                         i += scnprintf(buffer + i, count - i, "*");
 448                         i += cfs_print_network(buffer + i, count - i, nr);
 449                 } else {
 450                         i += cfs_print_addrranges(buffer + i, count - i,
 451                                                   &nr->nr_addrranges, nr);
 452                 }
 453         }
 454         return i;
 455 }
 456 EXPORT_SYMBOL(cfs_print_nidlist);
 457
 458 static int
 459 libcfs_lo_str2addr(const char *str, int nob, __u32 *addr)
 460 {
 461         *addr = 0;
 462         return 1;
 463 }
 464
 465 static void
 466 libcfs_ip_addr2str(__u32 addr, char *str, size_t size)
 467 {
 468         snprintf(str, size, "%u.%u.%u.%u",
 469                  (addr >> 24) & 0xff, (addr >> 16) & 0xff,
 470                  (addr >> 8) & 0xff, addr & 0xff);
 471 }
 472
 473 static void
 474 libcfs_ip_addr2str_size(const __be32 *addr, size_t asize,
 475                         char *str, size_t size)
 476 {
 477         struct sockaddr_storage sa = {};
 478
 479         switch (asize) {
 480         case 4:
 481                 sa.ss_family = AF_INET;
 482                 memcpy(&((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
 483                        addr, asize);
 484                 break;
 485         case 16:
 486                 sa.ss_family = AF_INET6;
 487                 memcpy(&((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
 488                        addr, asize);
 489                 break;
 490         default:
 491                 return;
 492         }
 493
 494         rpc_ntop((struct sockaddr *)&sa, str, size);
 495 }
 496
 497 /* CAVEAT EMPTOR XscanfX
 498  * I use "%n" at the end of a sscanf format to detect trailing junk.  However
 499  * sscanf may return immediately if it sees the terminating '0' in a string, so
 500  * I initialise the %n variable to the expected length.  If sscanf sets it;
 501  * fine, if it doesn't, then the scan ended at the end of the string, which is
 502  * fine too :) */
 503 static int
 504 libcfs_ip_str2addr(const char *str, int nob, __u32 *addr)
 505 {
 506         unsigned int    a;
 507         unsigned int    b;
 508         unsigned int    c;
 509         unsigned int    d;
 510         int             n = nob; /* XscanfX */
 511
 512         /* numeric IP? */
 513         if (sscanf(str, "%u.%u.%u.%u%n", &a, &b, &c, &d, &n) >= 4 &&
 514             n == nob &&
 515             (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
 516             (c & ~0xff) == 0 && (d & ~0xff) == 0) {
 517                 *addr = ((a<<24)|(b<<16)|(c<<8)|d);
 518                 return 1;
 519         }
 520         return 0;
 521 }
 522
 523 static int
 524 libcfs_ip_str2addr_size(const char *str, int nob,
 525                         __be32 *addr, size_t *alen)
 526 {
 527         struct sockaddr_storage sa;
 528
 529         /* Note: 'net' arg to rpc_pton is only needed for link-local
 530          * addresses.  Such addresses would not work with LNet routing,
 531          * so we can assume they aren't used.  So it doesn't matter
 532          * which net namespace is passed.
 533          */
 534         if (rpc_pton(&init_net, str, nob,
 535                      (struct sockaddr *)&sa, sizeof(sa)) == 0)
 536                 return 0;
 537         if (sa.ss_family == AF_INET6) {
 538                 memcpy(addr,
 539                        &((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
 540                        16);
 541                 *alen = 16;
 542                 return 1;
 543         }
 544         if (sa.ss_family == AF_INET) {
 545                 memcpy(addr,
 546                        &((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
 547                        4);
 548                 *alen = 4;
 549                 return 1;
 550         }
 551         return 0;
 552 }
 553
 554
 555 /* Used by lnet/config.c so it can't be static */
 556 int
 557 cfs_ip_addr_parse(char *str, int len, struct list_head *list)
 558 {
 559         struct cfs_expr_list *el;
 560         struct cfs_lstr src;
 561         int rc;
 562         int i;
 563
 564         src.ls_str = str;
 565         src.ls_len = len;
 566         i = 0;
 567
 568         while (src.ls_str != NULL) {
 569                 struct cfs_lstr res;
 570
 571                 if (!cfs_gettok(&src, '.', &res)) {
 572                         rc = -EINVAL;
 573                         goto out;
 574                 }
 575
 576                 rc = cfs_expr_list_parse(res.ls_str, res.ls_len, 0, 255, &el);
 577                 if (rc != 0)
 578                         goto out;
 579
 580                 list_add_tail(&el->el_link, list);
 581                 i++;
 582         }
 583
 584         if (i == 4)
 585                 return 0;
 586
 587         rc = -EINVAL;
 588 out:
 589         cfs_expr_list_free_list(list);
 590
 591         return rc;
 592 }
 593
 594 static int
 595 libcfs_ip_addr_range_print(char *buffer, int count, struct list_head *list)
 596 {
 597         int i = 0, j = 0;
 598         struct cfs_expr_list *el;
 599
 600         list_for_each_entry(el, list, el_link) {
 601                 LASSERT(j++ < 4);
 602                 if (i != 0)
 603                         i += scnprintf(buffer + i, count - i, ".");
 604                 i += cfs_expr_list_print(buffer + i, count - i, el);
 605         }
 606         return i;
 607 }
 608
 609 /**
 610  * Matches address (\a addr) against address set encoded in \a list.
 611  *
 612  * \retval 1 if \a addr matches
 613  * \retval 0 otherwise
 614  */
 615 int
 616 cfs_ip_addr_match(__u32 addr, struct list_head *list)
 617 {
 618         struct cfs_expr_list *el;
 619         int i = 0;
 620
 621         list_for_each_entry_reverse(el, list, el_link) {
 622                 if (!cfs_expr_list_match(addr & 0xff, el))
 623                         return 0;
 624                 addr >>= 8;
 625                 i++;
 626         }
 627
 628         return i == 4;
 629 }
 630
 631 /**
 632  * Print the network part of the nidrange \a nr into the specified \a buffer.
 633  *
 634  * \retval number of characters written
 635  */
 636 static void
 637 libcfs_decnum_addr2str(__u32 addr, char *str, size_t size)
 638 {
 639         snprintf(str, size, "%u", addr);
 640 }
 641
 642 static int
 643 libcfs_num_str2addr(const char *str, int nob, __u32 *addr)
 644 {
 645         int     n;
 646
 647         n = nob;
 648         if (sscanf(str, "0x%x%n", addr, &n) >= 1 && n == nob)
 649                 return 1;
 650
 651         n = nob;
 652         if (sscanf(str, "0X%x%n", addr, &n) >= 1 && n == nob)
 653                 return 1;
 654
 655         n = nob;
 656         if (sscanf(str, "%u%n", addr, &n) >= 1 && n == nob)
 657                 return 1;
 658
 659         return 0;
 660 }
 661
 662 /**
 663  * Nf_parse_addrlist method for networks using numeric addresses.
 664  *
 665  * Examples of such networks are gm and elan.
 666  *
 667  * \retval 0 if \a str parsed to numeric address
 668  * \retval errno otherwise
 669  */
 670 int
 671 libcfs_num_parse(char *str, int len, struct list_head *list)
 672 {
 673         struct cfs_expr_list *el;
 674         int     rc;
 675
 676         rc = cfs_expr_list_parse(str, len, 0, MAX_NUMERIC_VALUE, &el);
 677         if (rc == 0)
 678                 list_add_tail(&el->el_link, list);
 679
 680         return rc;
 681 }
 682
 683 static int
 684 libcfs_num_addr_range_print(char *buffer, int count, struct list_head *list)
 685 {
 686         int i = 0, j = 0;
 687         struct cfs_expr_list *el;
 688
 689         list_for_each_entry(el, list, el_link) {
 690                 LASSERT(j++ < 1);
 691                 i += cfs_expr_list_print(buffer + i, count - i, el);
 692         }
 693         return i;
 694 }
 695
 696 /*
 697  * Nf_match_addr method for networks using numeric addresses
 698  *
 699  * \retval 1 on match
 700  * \retval 0 otherwise
 701  */
 702 static int
 703 libcfs_num_match(__u32 addr, struct list_head *numaddr)
 704 {
 705         struct cfs_expr_list *el;
 706
 707         LASSERT(!list_empty(numaddr));
 708         el = list_first_entry(numaddr, struct cfs_expr_list, el_link);
 709
 710         return cfs_expr_list_match(addr, el);
 711 }
 712
 713 static struct netstrfns libcfs_netstrfns[] = {
 714         { .nf_type              = LOLND,
 715           .nf_name              = "lo",
 716           .nf_modname           = "klolnd",
 717           .nf_addr2str          = libcfs_decnum_addr2str,
 718           .nf_str2addr          = libcfs_lo_str2addr,
 719           .nf_parse_addrlist    = libcfs_num_parse,
 720           .nf_print_addrlist    = libcfs_num_addr_range_print,
 721           .nf_match_addr        = libcfs_num_match
 722         },
 723         { .nf_type              = SOCKLND,
 724           .nf_name              = "tcp",
 725           .nf_modname           = "ksocklnd",
 726           .nf_addr2str          = libcfs_ip_addr2str,
 727           .nf_addr2str_size     = libcfs_ip_addr2str_size,
 728           .nf_str2addr          = libcfs_ip_str2addr,
 729           .nf_str2addr_size     = libcfs_ip_str2addr_size,
 730           .nf_parse_addrlist    = cfs_ip_addr_parse,
 731           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 732           .nf_match_addr        = cfs_ip_addr_match
 733         },
 734         { .nf_type              = O2IBLND,
 735           .nf_name              = "o2ib",
 736           .nf_modname           = "ko2iblnd",
 737           .nf_addr2str          = libcfs_ip_addr2str,
 738           .nf_str2addr          = libcfs_ip_str2addr,
 739           .nf_parse_addrlist    = cfs_ip_addr_parse,
 740           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 741           .nf_match_addr        = cfs_ip_addr_match
 742         },
 743         { .nf_type              = GNILND,
 744           .nf_name              = "gni",
 745           .nf_modname           = "kgnilnd",
 746           .nf_addr2str          = libcfs_decnum_addr2str,
 747           .nf_str2addr          = libcfs_num_str2addr,
 748           .nf_parse_addrlist    = libcfs_num_parse,
 749           .nf_print_addrlist    = libcfs_num_addr_range_print,
 750           .nf_match_addr        = libcfs_num_match
 751         },
 752         { .nf_type              = GNIIPLND,
 753           .nf_name              = "gip",
 754           .nf_modname           = "kgnilnd",
 755           .nf_addr2str          = libcfs_ip_addr2str,
 756           .nf_str2addr          = libcfs_ip_str2addr,
 757           .nf_parse_addrlist    = cfs_ip_addr_parse,
 758           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 759           .nf_match_addr        = cfs_ip_addr_match
 760         },
 761         { .nf_type              = PTL4LND,
 762           .nf_name              = "ptlf",
 763           .nf_modname           = "kptl4lnd",
 764           .nf_addr2str          = libcfs_decnum_addr2str,
 765           .nf_str2addr          = libcfs_num_str2addr,
 766           .nf_parse_addrlist    = libcfs_num_parse,
 767           .nf_print_addrlist    = libcfs_num_addr_range_print,
 768           .nf_match_addr        = libcfs_num_match
 769         },
 770         {
 771           .nf_type              = KFILND,
 772           .nf_name              = "kfi",
 773           .nf_modname           = "kkfilnd",
 774           .nf_addr2str          = libcfs_decnum_addr2str,
 775           .nf_str2addr          = libcfs_num_str2addr,
 776           .nf_parse_addrlist    = libcfs_num_parse,
 777           .nf_print_addrlist    = libcfs_num_addr_range_print,
 778           .nf_match_addr        = libcfs_num_match
 779         },
 780 };
 781
 782 static const size_t libcfs_nnetstrfns = ARRAY_SIZE(libcfs_netstrfns);
 783
 784 static struct netstrfns *
 785 type2net_info(__u32 net_type)
 786 {
 787         int i;
 788
 789         for (i = 0; i < libcfs_nnetstrfns; i++) {
 790                 if (libcfs_netstrfns[i].nf_type == net_type)
 791                         return &libcfs_netstrfns[i];
 792         }
 793
 794         return NULL;
 795 }
 796
 797 int
 798 cfs_match_net(__u32 net_id, __u32 net_type, struct list_head *net_num_list)
 799 {
 800         __u32 net_num;
 801
 802         if (!net_num_list)
 803                 return 0;
 804
 805         if (net_type != LNET_NETTYP(net_id))
 806                 return 0;
 807
 808         net_num = LNET_NETNUM(net_id);
 809
 810         /* if there is a net number but the list passed in is empty, then
 811          * there is no match.
 812          */
 813         if (!net_num && list_empty(net_num_list))
 814                 return 1;
 815         else if (list_empty(net_num_list))
 816                 return 0;
 817
 818         if (!libcfs_num_match(net_num, net_num_list))
 819                 return 0;
 820
 821         return 1;
 822 }
 823
 824 int
 825 cfs_match_nid_net(struct lnet_nid *nid, __u32 net_type,
 826                    struct list_head *net_num_list,
 827                    struct list_head *addr)
 828 {
 829         __u32 address;
 830         struct netstrfns *nf;
 831
 832         if (!addr || list_empty(addr) || !net_num_list)
 833                 return 0;
 834
 835         nf = type2net_info(LNET_NETTYP(LNET_NID_NET(nid)));
 836         if (!nf)
 837                 return 0;
 838
 839         /* FIXME handle long-addr nid */
 840         address = LNET_NIDADDR(lnet_nid_to_nid4(nid));
 841
 842         /* if either the address or net number don't match then no match */
 843         if (!nf->nf_match_addr(address, addr) ||
 844             !cfs_match_net(LNET_NID_NET(nid), net_type, net_num_list))
 845                 return 0;
 846
 847         return 1;
 848 }
 849 EXPORT_SYMBOL(cfs_match_nid_net);
 850
 851 static struct netstrfns *
 852 libcfs_lnd2netstrfns(__u32 lnd)
 853 {
 854         int     i;
 855
 856         for (i = 0; i < libcfs_nnetstrfns; i++)
 857                 if (lnd == libcfs_netstrfns[i].nf_type)
 858                         return &libcfs_netstrfns[i];
 859
 860         return NULL;
 861 }
 862
 863 static struct netstrfns *
 864 libcfs_namenum2netstrfns(const char *name)
 865 {
 866         struct netstrfns *nf;
 867         int               i;
 868
 869         for (i = 0; i < libcfs_nnetstrfns; i++) {
 870                 nf = &libcfs_netstrfns[i];
 871                 if (!strncmp(name, nf->nf_name, strlen(nf->nf_name)))
 872                         return nf;
 873         }
 874         return NULL;
 875 }
 876
 877 static struct netstrfns *
 878 libcfs_name2netstrfns(const char *name)
 879 {
 880         int    i;
 881
 882         for (i = 0; i < libcfs_nnetstrfns; i++)
 883                 if (!strcmp(libcfs_netstrfns[i].nf_name, name))
 884                         return &libcfs_netstrfns[i];
 885
 886         return NULL;
 887 }
 888
 889 int
 890 libcfs_isknown_lnd(__u32 lnd)
 891 {
 892         return libcfs_lnd2netstrfns(lnd) != NULL;
 893 }
 894 EXPORT_SYMBOL(libcfs_isknown_lnd);
 895
 896 char *
 897 libcfs_lnd2modname(__u32 lnd)
 898 {
 899         struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
 900
 901         return (nf == NULL) ? NULL : nf->nf_modname;
 902 }
 903 EXPORT_SYMBOL(libcfs_lnd2modname);
 904
 905 int
 906 libcfs_str2lnd(const char *str)
 907 {
 908         struct netstrfns *nf = libcfs_name2netstrfns(str);
 909
 910         if (nf != NULL)
 911                 return nf->nf_type;
 912
 913         return -ENXIO;
 914 }
 915 EXPORT_SYMBOL(libcfs_str2lnd);
 916
 917 char *
 918 libcfs_lnd2str_r(__u32 lnd, char *buf, size_t buf_size)
 919 {
 920         struct netstrfns *nf;
 921
 922         nf = libcfs_lnd2netstrfns(lnd);
 923         if (nf == NULL)
 924                 snprintf(buf, buf_size, "?%u?", lnd);
 925         else
 926                 snprintf(buf, buf_size, "%s", nf->nf_name);
 927
 928         return buf;
 929 }
 930 EXPORT_SYMBOL(libcfs_lnd2str_r);
 931
 932 char *
 933 libcfs_net2str_r(__u32 net, char *buf, size_t buf_size)
 934 {
 935         __u32             nnum = LNET_NETNUM(net);
 936         __u32             lnd  = LNET_NETTYP(net);
 937         struct netstrfns *nf;
 938
 939         nf = libcfs_lnd2netstrfns(lnd);
 940         if (nf == NULL)
 941                 snprintf(buf, buf_size, "<%u:%u>", lnd, nnum);
 942         else if (nnum == 0)
 943                 snprintf(buf, buf_size, "%s", nf->nf_name);
 944         else
 945                 snprintf(buf, buf_size, "%s%u", nf->nf_name, nnum);
 946
 947         return buf;
 948 }
 949 EXPORT_SYMBOL(libcfs_net2str_r);
 950
 951 char *
 952 libcfs_nid2str_r(lnet_nid_t nid, char *buf, size_t buf_size)
 953 {
 954         __u32             addr = LNET_NIDADDR(nid);
 955         __u32             net  = LNET_NIDNET(nid);
 956         __u32             nnum = LNET_NETNUM(net);
 957         __u32             lnd  = LNET_NETTYP(net);
 958         struct netstrfns *nf;
 959
 960         if (nid == LNET_NID_ANY) {
 961                 strncpy(buf, "<?>", buf_size);
 962                 buf[buf_size - 1] = '\0';
 963                 return buf;
 964         }
 965
 966         nf = libcfs_lnd2netstrfns(lnd);
 967         if (nf == NULL) {
 968                 snprintf(buf, buf_size, "%x@<%u:%u>", addr, lnd, nnum);
 969         } else {
 970                 size_t addr_len;
 971
 972                 nf->nf_addr2str(addr, buf, buf_size);
 973                 addr_len = strlen(buf);
 974                 if (nnum == 0)
 975                         snprintf(buf + addr_len, buf_size - addr_len, "@%s",
 976                                  nf->nf_name);
 977                 else
 978                         snprintf(buf + addr_len, buf_size - addr_len, "@%s%u",
 979                                  nf->nf_name, nnum);
 980         }
 981
 982         return buf;
 983 }
 984 EXPORT_SYMBOL(libcfs_nid2str_r);
 985
 986 char *
 987 libcfs_nidstr_r(const struct lnet_nid *nid, char *buf, size_t buf_size)
 988 {
 989         __u32 nnum;
 990         __u32 lnd;
 991         struct netstrfns *nf;
 992
 993         if (LNET_NID_IS_ANY(nid)) {
 994                 strncpy(buf, "<?>", buf_size);
 995                 buf[buf_size - 1] = '\0';
 996                 return buf;
 997         }
 998
 999         nnum = be16_to_cpu(nid->nid_num);
1000         lnd = nid->nid_type;
1001         nf = libcfs_lnd2netstrfns(lnd);
1002         if (nf) {
1003                 size_t addr_len;
1004
1005                 if (nf->nf_addr2str_size)
1006                         nf->nf_addr2str_size(nid->nid_addr, NID_ADDR_BYTES(nid),
1007                                              buf, buf_size);
1008                 else
1009                         nf->nf_addr2str(ntohl(nid->nid_addr[0]), buf, buf_size);
1010                 addr_len = strlen(buf);
1011                 if (nnum == 0)
1012                         snprintf(buf + addr_len, buf_size - addr_len, "@%s",
1013                                  nf->nf_name);
1014                 else
1015                         snprintf(buf + addr_len, buf_size - addr_len, "@%s%u",
1016                                  nf->nf_name, nnum);
1017         } else {
1018                 int l = 0;
1019                 int words = DIV_ROUND_UP(NID_ADDR_BYTES(nid), 4);
1020                 int i;
1021
1022                 for (i = 0; i < words && i < 4; i++)
1023                         l = snprintf(buf+l, buf_size-l, "%s%x",
1024                                      i ? ":" : "", ntohl(nid->nid_addr[i]));
1025                 snprintf(buf+l, buf_size-l, "@<%u:%u>", lnd, nnum);
1026         }
1027
1028         return buf;
1029 }
1030 EXPORT_SYMBOL(libcfs_nidstr_r);
1031
1032 static struct netstrfns *
1033 libcfs_str2net_internal(const char *str, __u32 *net)
1034 {
1035         struct netstrfns *nf = NULL;
1036         int               nob;
1037         unsigned int      netnum;
1038         int               i;
1039
1040         for (i = 0; i < libcfs_nnetstrfns; i++) {
1041                 nf = &libcfs_netstrfns[i];
1042                 if (!strncmp(str, nf->nf_name, strlen(nf->nf_name)))
1043                         break;
1044         }
1045
1046         if (i == libcfs_nnetstrfns)
1047                 return NULL;
1048
1049         nob = strlen(nf->nf_name);
1050
1051         if (strlen(str) == (unsigned int)nob) {
1052                 netnum = 0;
1053         } else {
1054                 if (nf->nf_type == LOLND) /* net number not allowed */
1055                         return NULL;
1056
1057                 str += nob;
1058                 i = strlen(str);
1059                 if (sscanf(str, "%u%n", &netnum, &i) < 1 ||
1060                     i != (int)strlen(str))
1061                         return NULL;
1062         }
1063
1064         *net = LNET_MKNET(nf->nf_type, netnum);
1065         return nf;
1066 }
1067
1068 __u32
1069 libcfs_str2net(const char *str)
1070 {
1071         __u32  net;
1072
1073         if (libcfs_str2net_internal(str, &net) != NULL)
1074                 return net;
1075
1076         return LNET_NET_ANY;
1077 }
1078 EXPORT_SYMBOL(libcfs_str2net);
1079
1080 lnet_nid_t
1081 libcfs_str2nid(const char *str)
1082 {
1083         const char       *sep = strchr(str, '@');
1084         struct netstrfns *nf;
1085         __u32             net;
1086         __u32             addr;
1087
1088         if (sep != NULL) {
1089                 nf = libcfs_str2net_internal(sep + 1, &net);
1090                 if (nf == NULL)
1091                         return LNET_NID_ANY;
1092         } else {
1093                 sep = str + strlen(str);
1094                 net = LNET_MKNET(SOCKLND, 0);
1095                 nf = libcfs_lnd2netstrfns(SOCKLND);
1096                 LASSERT(nf != NULL);
1097         }
1098
1099         if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
1100                 return LNET_NID_ANY;
1101
1102         return LNET_MKNID(net, addr);
1103 }
1104 EXPORT_SYMBOL(libcfs_str2nid);
1105
1106 int
1107 libcfs_strnid(struct lnet_nid *nid, const char *str)
1108 {
1109         const char       *sep = strchr(str, '@');
1110         struct netstrfns *nf;
1111         __u32             net;
1112
1113         if (sep != NULL) {
1114                 nf = libcfs_str2net_internal(sep + 1, &net);
1115                 if (nf == NULL)
1116                         return -EINVAL;
1117         } else {
1118                 sep = str + strlen(str);
1119                 net = LNET_MKNET(SOCKLND, 0);
1120                 nf = libcfs_lnd2netstrfns(SOCKLND);
1121                 LASSERT(nf != NULL);
1122         }
1123
1124         memset(nid, 0, sizeof(*nid));
1125         nid->nid_type = LNET_NETTYP(net);
1126         nid->nid_num = htons(LNET_NETNUM(net));
1127         if (nf->nf_str2addr_size) {
1128                 size_t asize = 0;
1129
1130                 if (!nf->nf_str2addr_size(str, (int)(sep - str),
1131                                           nid->nid_addr, &asize))
1132                         return -EINVAL;
1133                 nid->nid_size = asize - 4;
1134         } else {
1135                 __u32 addr;
1136
1137                 if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
1138                         return -EINVAL;
1139                 nid->nid_addr[0] = htonl(addr);
1140                 nid->nid_size = 0;
1141         }
1142         return 0;
1143 }
1144 EXPORT_SYMBOL(libcfs_strnid);
1145
1146 char *
1147 libcfs_id2str(struct lnet_process_id id)
1148 {
1149         char *str = libcfs_next_nidstring();
1150
1151         if (id.pid == LNET_PID_ANY) {
1152                 snprintf(str, LNET_NIDSTR_SIZE,
1153                          "LNET_PID_ANY-%s", libcfs_nid2str(id.nid));
1154                 return str;
1155         }
1156
1157         snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
1158                  ((id.pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
1159                  (id.pid & ~LNET_PID_USERFLAG), libcfs_nid2str(id.nid));
1160         return str;
1161 }
1162 EXPORT_SYMBOL(libcfs_id2str);
1163
1164 char *
1165 libcfs_idstr(struct lnet_processid *id)
1166 {
1167         char *str = libcfs_next_nidstring();
1168
1169         if (id->pid == LNET_PID_ANY) {
1170                 snprintf(str, LNET_NIDSTR_SIZE,
1171                          "LNET_PID_ANY-%s", libcfs_nidstr(&id->nid));
1172                 return str;
1173         }
1174
1175         snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
1176                  ((id->pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
1177                  (id->pid & ~LNET_PID_USERFLAG), libcfs_nidstr(&id->nid));
1178         return str;
1179 }
1180 EXPORT_SYMBOL(libcfs_idstr);
1181
1182 int
1183 libcfs_strid(struct lnet_processid *id, const char *str)
1184 {
1185         char *tmp = strchr(str, '-');
1186
1187         id->pid = LNET_PID_LUSTRE;
1188         if (tmp &&
1189             strncmp("LNET_PID_ANY-", str, tmp - str) != 0) {
1190                 char pid[LNET_NIDSTR_SIZE];
1191                 int rc;
1192
1193                 strscpy(pid, str, tmp - str);
1194                 rc = kstrtou32(pid, 10, &id->pid);
1195                 if (rc < 0)
1196                         return rc;
1197                 tmp++;
1198         } else {
1199                 tmp = (char *)str;
1200         }
1201
1202         return libcfs_strnid(&id->nid, tmp);
1203 }
1204 EXPORT_SYMBOL(libcfs_strid);
1205
1206 int
1207 libcfs_str2anynid(lnet_nid_t *nidp, const char *str)
1208 {
1209         if (!strcmp(str, "*")) {
1210                 *nidp = LNET_NID_ANY;
1211                 return 1;
1212         }
1213
1214         *nidp = libcfs_str2nid(str);
1215         return *nidp != LNET_NID_ANY;
1216 }
1217 EXPORT_SYMBOL(libcfs_str2anynid);