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(char *str, struct nidrange *nidrange)
 161 {
 162         struct addrrange *addrrange;
 163
 164         if (strcmp(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(str, strlen(str),
 176                                                 &addrrange->ar_numaddr_ranges);
 177 }
 178
 179 /**
 180  * Finds or creates struct nidrange.
 181  *
 182  * Checks if \a src is a valid network name, looks for corresponding
 183  * nidrange on the ist of nidranges (\a nidlist), creates new struct
 184  * nidrange if it is not found.
 185  *
 186  * \retval pointer to struct nidrange matching network specified via \a src
 187  * \retval NULL if \a src does not match any network
 188  */
 189 static struct nidrange *
 190 add_nidrange(char *str, struct list_head *nidlist)
 191 {
 192         struct netstrfns *nf;
 193         struct nidrange *nr;
 194         char *end;
 195         unsigned int netnum;
 196
 197         nf = libcfs_namenum2netstrfns(str);
 198         if (nf == NULL)
 199                 return NULL;
 200         end = str + strlen(nf->nf_name);
 201         if (!*end) {
 202                 /* network name only, e.g. "elan" or "tcp" */
 203                 netnum = 0;
 204         } else {
 205                 /* e.g. "elan25" or "tcp23", refuse to parse if
 206                  * network name is not appended with decimal or
 207                  * hexadecimal number
 208                  */
 209                 if (kstrtouint(end, 0, &netnum) != 0)
 210                         return NULL;
 211         }
 212
 213         list_for_each_entry(nr, nidlist, nr_link) {
 214                 if (nr->nr_netstrfns != nf)
 215                         continue;
 216                 if (nr->nr_netnum != netnum)
 217                         continue;
 218                 return nr;
 219         }
 220
 221         CFS_ALLOC_PTR(nr);
 222         if (nr == NULL)
 223                 return NULL;
 224         list_add_tail(&nr->nr_link, nidlist);
 225         INIT_LIST_HEAD(&nr->nr_addrranges);
 226         nr->nr_netstrfns = nf;
 227         nr->nr_all = 0;
 228         nr->nr_netnum = netnum;
 229
 230         return nr;
 231 }
 232
 233 /**
 234  * Parses \<nidrange\> token of the syntax.
 235  *
 236  * \retval 0 if \a src parses to \<addrrange\> '@' \<net\>
 237  * \retval -EINVAL otherwise
 238  */
 239 static int
 240 parse_nidrange(char *str, struct list_head *nidlist)
 241 {
 242         char *addrrange;
 243         char *net;
 244         struct nidrange *nr;
 245
 246         addrrange = strim(strsep(&str, "@"));
 247         if (!str)
 248                 goto failed;
 249
 250         net = strim(str);
 251         if (strchr(net, '@') != NULL || !*net)
 252                 goto failed;
 253
 254         nr = add_nidrange(net, nidlist);
 255         if (nr == NULL)
 256                 goto failed;
 257
 258         if (parse_addrange(addrrange, nr) != 0)
 259                 goto failed;
 260
 261         return 0;
 262 failed:
 263         return -EINVAL;
 264 }
 265
 266 /**
 267  * Frees addrrange structures of \a list.
 268  *
 269  * For each struct addrrange structure found on \a list it frees
 270  * cfs_expr_list list attached to it and frees the addrrange itself.
 271  *
 272  * \retval none
 273  */
 274 static void
 275 free_addrranges(struct list_head *list)
 276 {
 277         struct addrrange *ar;
 278
 279         while ((ar = list_first_entry_or_null(list,
 280                                               struct addrrange,
 281                                               ar_link)) != NULL) {
 282                 cfs_expr_list_free_list(&ar->ar_numaddr_ranges);
 283                 list_del(&ar->ar_link);
 284                 CFS_FREE_PTR(ar);
 285         }
 286 }
 287
 288 /**
 289  * Frees nidrange strutures of \a list.
 290  *
 291  * For each struct nidrange structure found on \a list it frees
 292  * addrrange list attached to it and frees the nidrange itself.
 293  *
 294  * \retval none
 295  */
 296 void
 297 cfs_free_nidlist(struct list_head *list)
 298 {
 299         struct list_head *pos, *next;
 300         struct nidrange *nr;
 301
 302         list_for_each_safe(pos, next, list) {
 303                 nr = list_entry(pos, struct nidrange, nr_link);
 304                 free_addrranges(&nr->nr_addrranges);
 305                 list_del(pos);
 306                 CFS_FREE_PTR(nr);
 307         }
 308 }
 309 EXPORT_SYMBOL(cfs_free_nidlist);
 310
 311 /**
 312  * Parses nid range list.
 313  *
 314  * Parses with rigorous syntax and overflow checking \a str into
 315  * \<nidrange\> [ ' ' \<nidrange\> ], compiles \a str into set of
 316  * structures and links that structure to \a nidlist. The resulting
 317  * list can be used to match a NID againts set of NIDS defined by \a
 318  * str.
 319  * \see cfs_match_nid
 320  *
 321  * \retval 0 on success
 322  * \retval -errno otherwise (-ENOMEM or -EINVAL)
 323  */
 324 int
 325 cfs_parse_nidlist(char *orig, struct list_head *nidlist)
 326 {
 327         int rc = 0;
 328         char *str;
 329
 330         orig = kstrdup(orig, GFP_KERNEL);
 331         if (!orig)
 332                 return -ENOMEM;
 333
 334         INIT_LIST_HEAD(nidlist);
 335         str = orig;
 336         while (rc == 0 && str) {
 337                 char *tok = strsep(&str, " ");
 338
 339                 if (*tok)
 340                         rc = parse_nidrange(tok, nidlist);
 341         }
 342         kfree(orig);
 343         if (rc)
 344                 cfs_free_nidlist(nidlist);
 345         else if (list_empty(nidlist))
 346                 rc = -EINVAL;
 347         return rc;
 348 }
 349 EXPORT_SYMBOL(cfs_parse_nidlist);
 350
 351 /**
 352  * Matches a nid (\a nid) against the compiled list of nidranges (\a nidlist).
 353  *
 354  * \see cfs_parse_nidlist()
 355  *
 356  * \retval 1 on match
 357  * \retval 0  otherwises
 358  */
 359 int cfs_match_nid(struct lnet_nid *nid, struct list_head *nidlist)
 360 {
 361         struct nidrange *nr;
 362         struct addrrange *ar;
 363
 364         if (!nid_is_nid4(nid))
 365                 return 0;
 366         list_for_each_entry(nr, nidlist, nr_link) {
 367                 if (nr->nr_netstrfns->nf_type != nid->nid_type)
 368                         continue;
 369                 if (nr->nr_netnum != be16_to_cpu(nid->nid_num))
 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(
 375                                     be32_to_cpu(nid->nid_addr[0]),
 376                                     &ar->ar_numaddr_ranges))
 377                                 return 1;
 378         }
 379         return 0;
 380 }
 381 EXPORT_SYMBOL(cfs_match_nid);
 382
 383 /**
 384  * Print the network part of the nidrange \a nr into the specified \a buffer.
 385  *
 386  * \retval number of characters written
 387  */
 388 static int
 389 cfs_print_network(char *buffer, int count, struct nidrange *nr)
 390 {
 391         struct netstrfns *nf = nr->nr_netstrfns;
 392
 393         if (nr->nr_netnum == 0)
 394                 return scnprintf(buffer, count, "@%s", nf->nf_name);
 395         else
 396                 return scnprintf(buffer, count, "@%s%u",
 397                                     nf->nf_name, nr->nr_netnum);
 398 }
 399
 400 /**
 401  * Print a list of addrrange (\a addrranges) into the specified \a buffer.
 402  * At max \a count characters can be printed into \a buffer.
 403  *
 404  * \retval number of characters written
 405  */
 406 static int
 407 cfs_print_addrranges(char *buffer, int count, struct list_head *addrranges,
 408                      struct nidrange *nr)
 409 {
 410         int i = 0;
 411         struct addrrange *ar;
 412         struct netstrfns *nf = nr->nr_netstrfns;
 413
 414         list_for_each_entry(ar, addrranges, ar_link) {
 415                 if (i != 0)
 416                         i += scnprintf(buffer + i, count - i, " ");
 417                 i += nf->nf_print_addrlist(buffer + i, count - i,
 418                                            &ar->ar_numaddr_ranges);
 419                 i += cfs_print_network(buffer + i, count - i, nr);
 420         }
 421         return i;
 422 }
 423
 424 /**
 425  * Print a list of nidranges (\a nidlist) into the specified \a buffer.
 426  * At max \a count characters can be printed into \a buffer.
 427  * Nidranges are separated by a space character.
 428  *
 429  * \retval number of characters written
 430  */
 431 int cfs_print_nidlist(char *buffer, int count, struct list_head *nidlist)
 432 {
 433         int i = 0;
 434         struct nidrange *nr;
 435
 436         if (count <= 0)
 437                 return 0;
 438
 439         list_for_each_entry(nr, nidlist, nr_link) {
 440                 if (i != 0)
 441                         i += scnprintf(buffer + i, count - i, " ");
 442
 443                 if (nr->nr_all != 0) {
 444                         LASSERT(list_empty(&nr->nr_addrranges));
 445                         i += scnprintf(buffer + i, count - i, "*");
 446                         i += cfs_print_network(buffer + i, count - i, nr);
 447                 } else {
 448                         i += cfs_print_addrranges(buffer + i, count - i,
 449                                                   &nr->nr_addrranges, nr);
 450                 }
 451         }
 452         return i;
 453 }
 454 EXPORT_SYMBOL(cfs_print_nidlist);
 455
 456 static int
 457 libcfs_lo_str2addr(const char *str, int nob, __u32 *addr)
 458 {
 459         *addr = 0;
 460         return 1;
 461 }
 462
 463 static void
 464 libcfs_ip_addr2str(__u32 addr, char *str, size_t size)
 465 {
 466         snprintf(str, size, "%u.%u.%u.%u",
 467                  (addr >> 24) & 0xff, (addr >> 16) & 0xff,
 468                  (addr >> 8) & 0xff, addr & 0xff);
 469 }
 470
 471 static void
 472 libcfs_ip_addr2str_size(const __be32 *addr, size_t asize,
 473                         char *str, size_t size)
 474 {
 475         struct sockaddr_storage sa = {};
 476
 477         switch (asize) {
 478         case 4:
 479                 sa.ss_family = AF_INET;
 480                 memcpy(&((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
 481                        addr, asize);
 482                 break;
 483         case 16:
 484                 sa.ss_family = AF_INET6;
 485                 memcpy(&((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
 486                        addr, asize);
 487                 break;
 488         default:
 489                 return;
 490         }
 491
 492         rpc_ntop((struct sockaddr *)&sa, str, size);
 493 }
 494
 495 /* CAVEAT EMPTOR XscanfX
 496  * I use "%n" at the end of a sscanf format to detect trailing junk.  However
 497  * sscanf may return immediately if it sees the terminating '0' in a string, so
 498  * I initialise the %n variable to the expected length.  If sscanf sets it;
 499  * fine, if it doesn't, then the scan ended at the end of the string, which is
 500  * fine too :) */
 501 static int
 502 libcfs_ip_str2addr(const char *str, int nob, __u32 *addr)
 503 {
 504         unsigned int    a;
 505         unsigned int    b;
 506         unsigned int    c;
 507         unsigned int    d;
 508         int             n = nob; /* XscanfX */
 509
 510         /* numeric IP? */
 511         if (sscanf(str, "%u.%u.%u.%u%n", &a, &b, &c, &d, &n) >= 4 &&
 512             n == nob &&
 513             (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
 514             (c & ~0xff) == 0 && (d & ~0xff) == 0) {
 515                 *addr = ((a<<24)|(b<<16)|(c<<8)|d);
 516                 return 1;
 517         }
 518         return 0;
 519 }
 520
 521 static int
 522 libcfs_ip_str2addr_size(const char *str, int nob,
 523                         __be32 *addr, size_t *alen)
 524 {
 525         struct sockaddr_storage sa;
 526
 527         /* Note: 'net' arg to rpc_pton is only needed for link-local
 528          * addresses.  Such addresses would not work with LNet routing,
 529          * so we can assume they aren't used.  So it doesn't matter
 530          * which net namespace is passed.
 531          */
 532         if (rpc_pton(&init_net, str, nob,
 533                      (struct sockaddr *)&sa, sizeof(sa)) == 0)
 534                 return 0;
 535         if (sa.ss_family == AF_INET6) {
 536                 memcpy(addr,
 537                        &((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
 538                        16);
 539                 *alen = 16;
 540                 return 1;
 541         }
 542         if (sa.ss_family == AF_INET) {
 543                 memcpy(addr,
 544                        &((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
 545                        4);
 546                 *alen = 4;
 547                 return 1;
 548         }
 549         return 0;
 550 }
 551
 552
 553 /* Used by lnet/config.c so it can't be static */
 554 int
 555 cfs_ip_addr_parse(char *str, int len_ignored, struct list_head *list)
 556 {
 557         struct cfs_expr_list *el;
 558         int rc = 0;
 559         int i = 0;
 560
 561         str = strim(str);
 562         while (rc == 0 && str) {
 563                 char *res;
 564
 565                 res = strsep(&str, ".");
 566                 res = strim(res);
 567                 if (!*res) {
 568                         rc = -EINVAL;
 569                 } else if ((rc = cfs_expr_list_parse(res, strlen(res),
 570                                                    0, 255, &el)) == 0) {
 571                         list_add_tail(&el->el_link, list);
 572                         i++;
 573                 }
 574         }
 575
 576         if (rc == 0 && i == 4)
 577                 return 0;
 578         cfs_expr_list_free_list(list);
 579
 580         return rc ?: -EINVAL;
 581 }
 582
 583 /**
 584  * Print the range expression \a re into specified \a buffer.
 585  * If \a bracketed is true, expression does not need additional
 586  * brackets.
 587  *
 588  * \retval number of characters written
 589  */
 590 static int
 591 cfs_range_expr_print(char *buffer, int count, struct cfs_range_expr *expr,
 592                      bool bracketed)
 593 {
 594         int i;
 595         char s[] = "[";
 596         char e[] = "]";
 597
 598         if (bracketed)
 599                 s[0] = e[0] = '\0';
 600
 601         if (expr->re_lo == expr->re_hi)
 602                 i = scnprintf(buffer, count, "%u", expr->re_lo);
 603         else if (expr->re_stride == 1)
 604                 i = scnprintf(buffer, count, "%s%u-%u%s",
 605                               s, expr->re_lo, expr->re_hi, e);
 606         else
 607                 i = scnprintf(buffer, count, "%s%u-%u/%u%s",
 608                               s, expr->re_lo, expr->re_hi,
 609                               expr->re_stride, e);
 610         return i;
 611 }
 612
 613 /**
 614  * Print a list of range expressions (\a expr_list) into specified \a buffer.
 615  * If the list contains several expressions, separate them with comma
 616  * and surround the list with brackets.
 617  *
 618  * \retval number of characters written
 619  */
 620 static int
 621 cfs_expr_list_print(char *buffer, int count, struct cfs_expr_list *expr_list)
 622 {
 623         struct cfs_range_expr *expr;
 624         int i = 0, j = 0;
 625         int numexprs = 0;
 626
 627         if (count <= 0)
 628                 return 0;
 629
 630         list_for_each_entry(expr, &expr_list->el_exprs, re_link)
 631                 numexprs++;
 632
 633         if (numexprs > 1)
 634                 i += scnprintf(buffer + i, count - i, "[");
 635
 636         list_for_each_entry(expr, &expr_list->el_exprs, re_link) {
 637                 if (j++ != 0)
 638                         i += scnprintf(buffer + i, count - i, ",");
 639                 i += cfs_range_expr_print(buffer + i, count - i, expr,
 640                                           numexprs > 1);
 641         }
 642
 643         if (numexprs > 1)
 644                 i += scnprintf(buffer + i, count - i, "]");
 645
 646         return i;
 647 }
 648
 649 static int
 650 libcfs_ip_addr_range_print(char *buffer, int count, struct list_head *list)
 651 {
 652         int i = 0, j = 0;
 653         struct cfs_expr_list *el;
 654
 655         list_for_each_entry(el, list, el_link) {
 656                 LASSERT(j++ < 4);
 657                 if (i != 0)
 658                         i += scnprintf(buffer + i, count - i, ".");
 659                 i += cfs_expr_list_print(buffer + i, count - i, el);
 660         }
 661         return i;
 662 }
 663
 664 /**
 665  * Matches address (\a addr) against address set encoded in \a list.
 666  *
 667  * \retval 1 if \a addr matches
 668  * \retval 0 otherwise
 669  */
 670 int
 671 cfs_ip_addr_match(__u32 addr, struct list_head *list)
 672 {
 673         struct cfs_expr_list *el;
 674         int i = 0;
 675
 676         list_for_each_entry_reverse(el, list, el_link) {
 677                 if (!cfs_expr_list_match(addr & 0xff, el))
 678                         return 0;
 679                 addr >>= 8;
 680                 i++;
 681         }
 682
 683         return i == 4;
 684 }
 685
 686 /**
 687  * Print the network part of the nidrange \a nr into the specified \a buffer.
 688  *
 689  * \retval number of characters written
 690  */
 691 static void
 692 libcfs_decnum_addr2str(__u32 addr, char *str, size_t size)
 693 {
 694         snprintf(str, size, "%u", addr);
 695 }
 696
 697 static int
 698 libcfs_num_str2addr(const char *str, int nob, __u32 *addr)
 699 {
 700         int     n;
 701
 702         n = nob;
 703         if (sscanf(str, "0x%x%n", addr, &n) >= 1 && n == nob)
 704                 return 1;
 705
 706         n = nob;
 707         if (sscanf(str, "0X%x%n", addr, &n) >= 1 && n == nob)
 708                 return 1;
 709
 710         n = nob;
 711         if (sscanf(str, "%u%n", addr, &n) >= 1 && n == nob)
 712                 return 1;
 713
 714         return 0;
 715 }
 716
 717 /**
 718  * Nf_parse_addrlist method for networks using numeric addresses.
 719  *
 720  * Examples of such networks are gm and elan.
 721  *
 722  * \retval 0 if \a str parsed to numeric address
 723  * \retval errno otherwise
 724  */
 725 int
 726 libcfs_num_parse(char *str, int len, struct list_head *list)
 727 {
 728         struct cfs_expr_list *el;
 729         int     rc;
 730
 731         rc = cfs_expr_list_parse(str, len, 0, MAX_NUMERIC_VALUE, &el);
 732         if (rc == 0)
 733                 list_add_tail(&el->el_link, list);
 734
 735         return rc;
 736 }
 737
 738 static int
 739 libcfs_num_addr_range_print(char *buffer, int count, struct list_head *list)
 740 {
 741         int i = 0, j = 0;
 742         struct cfs_expr_list *el;
 743
 744         list_for_each_entry(el, list, el_link) {
 745                 LASSERT(j++ < 1);
 746                 i += cfs_expr_list_print(buffer + i, count - i, el);
 747         }
 748         return i;
 749 }
 750
 751 /*
 752  * Nf_match_addr method for networks using numeric addresses
 753  *
 754  * \retval 1 on match
 755  * \retval 0 otherwise
 756  */
 757 static int
 758 libcfs_num_match(__u32 addr, struct list_head *numaddr)
 759 {
 760         struct cfs_expr_list *el;
 761
 762         LASSERT(!list_empty(numaddr));
 763         el = list_first_entry(numaddr, struct cfs_expr_list, el_link);
 764
 765         return cfs_expr_list_match(addr, el);
 766 }
 767
 768 static struct netstrfns libcfs_netstrfns[] = {
 769         { .nf_type              = LOLND,
 770           .nf_name              = "lo",
 771           .nf_modname           = "klolnd",
 772           .nf_addr2str          = libcfs_decnum_addr2str,
 773           .nf_str2addr          = libcfs_lo_str2addr,
 774           .nf_parse_addrlist    = libcfs_num_parse,
 775           .nf_print_addrlist    = libcfs_num_addr_range_print,
 776           .nf_match_addr        = libcfs_num_match
 777         },
 778         { .nf_type              = SOCKLND,
 779           .nf_name              = "tcp",
 780           .nf_modname           = "ksocklnd",
 781           .nf_addr2str          = libcfs_ip_addr2str,
 782           .nf_addr2str_size     = libcfs_ip_addr2str_size,
 783           .nf_str2addr          = libcfs_ip_str2addr,
 784           .nf_str2addr_size     = libcfs_ip_str2addr_size,
 785           .nf_parse_addrlist    = cfs_ip_addr_parse,
 786           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 787           .nf_match_addr        = cfs_ip_addr_match
 788         },
 789         { .nf_type              = O2IBLND,
 790           .nf_name              = "o2ib",
 791           .nf_modname           = "ko2iblnd",
 792           .nf_addr2str          = libcfs_ip_addr2str,
 793           .nf_str2addr          = libcfs_ip_str2addr,
 794           .nf_parse_addrlist    = cfs_ip_addr_parse,
 795           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 796           .nf_match_addr        = cfs_ip_addr_match
 797         },
 798         { .nf_type              = GNILND,
 799           .nf_name              = "gni",
 800           .nf_modname           = "kgnilnd",
 801           .nf_addr2str          = libcfs_decnum_addr2str,
 802           .nf_str2addr          = libcfs_num_str2addr,
 803           .nf_parse_addrlist    = libcfs_num_parse,
 804           .nf_print_addrlist    = libcfs_num_addr_range_print,
 805           .nf_match_addr        = libcfs_num_match
 806         },
 807         { .nf_type              = GNIIPLND,
 808           .nf_name              = "gip",
 809           .nf_modname           = "kgnilnd",
 810           .nf_addr2str          = libcfs_ip_addr2str,
 811           .nf_str2addr          = libcfs_ip_str2addr,
 812           .nf_parse_addrlist    = cfs_ip_addr_parse,
 813           .nf_print_addrlist    = libcfs_ip_addr_range_print,
 814           .nf_match_addr        = cfs_ip_addr_match
 815         },
 816         { .nf_type              = PTL4LND,
 817           .nf_name              = "ptlf",
 818           .nf_modname           = "kptl4lnd",
 819           .nf_addr2str          = libcfs_decnum_addr2str,
 820           .nf_str2addr          = libcfs_num_str2addr,
 821           .nf_parse_addrlist    = libcfs_num_parse,
 822           .nf_print_addrlist    = libcfs_num_addr_range_print,
 823           .nf_match_addr        = libcfs_num_match
 824         },
 825         {
 826           .nf_type              = KFILND,
 827           .nf_name              = "kfi",
 828           .nf_modname           = "kkfilnd",
 829           .nf_addr2str          = libcfs_decnum_addr2str,
 830           .nf_str2addr          = libcfs_num_str2addr,
 831           .nf_parse_addrlist    = libcfs_num_parse,
 832           .nf_print_addrlist    = libcfs_num_addr_range_print,
 833           .nf_match_addr        = libcfs_num_match
 834         },
 835 };
 836
 837 static const size_t libcfs_nnetstrfns = ARRAY_SIZE(libcfs_netstrfns);
 838
 839 static struct netstrfns *
 840 type2net_info(__u32 net_type)
 841 {
 842         int i;
 843
 844         for (i = 0; i < libcfs_nnetstrfns; i++) {
 845                 if (libcfs_netstrfns[i].nf_type == net_type)
 846                         return &libcfs_netstrfns[i];
 847         }
 848
 849         return NULL;
 850 }
 851
 852 int
 853 cfs_match_net(__u32 net_id, __u32 net_type, struct list_head *net_num_list)
 854 {
 855         __u32 net_num;
 856
 857         if (!net_num_list)
 858                 return 0;
 859
 860         if (net_type != LNET_NETTYP(net_id))
 861                 return 0;
 862
 863         net_num = LNET_NETNUM(net_id);
 864
 865         /* if there is a net number but the list passed in is empty, then
 866          * there is no match.
 867          */
 868         if (!net_num && list_empty(net_num_list))
 869                 return 1;
 870         else if (list_empty(net_num_list))
 871                 return 0;
 872
 873         if (!libcfs_num_match(net_num, net_num_list))
 874                 return 0;
 875
 876         return 1;
 877 }
 878
 879 int
 880 cfs_match_nid_net(struct lnet_nid *nid, __u32 net_type,
 881                    struct list_head *net_num_list,
 882                    struct list_head *addr)
 883 {
 884         __u32 address;
 885         struct netstrfns *nf;
 886
 887         if (!addr || list_empty(addr) || !net_num_list)
 888                 return 0;
 889
 890         nf = type2net_info(LNET_NETTYP(LNET_NID_NET(nid)));
 891         if (!nf)
 892                 return 0;
 893
 894         /* FIXME handle long-addr nid */
 895         address = LNET_NIDADDR(lnet_nid_to_nid4(nid));
 896
 897         /* if either the address or net number don't match then no match */
 898         if (!nf->nf_match_addr(address, addr) ||
 899             !cfs_match_net(LNET_NID_NET(nid), net_type, net_num_list))
 900                 return 0;
 901
 902         return 1;
 903 }
 904 EXPORT_SYMBOL(cfs_match_nid_net);
 905
 906 static struct netstrfns *
 907 libcfs_lnd2netstrfns(__u32 lnd)
 908 {
 909         int     i;
 910
 911         for (i = 0; i < libcfs_nnetstrfns; i++)
 912                 if (lnd == libcfs_netstrfns[i].nf_type)
 913                         return &libcfs_netstrfns[i];
 914
 915         return NULL;
 916 }
 917
 918 static struct netstrfns *
 919 libcfs_namenum2netstrfns(const char *name)
 920 {
 921         struct netstrfns *nf;
 922         int               i;
 923
 924         for (i = 0; i < libcfs_nnetstrfns; i++) {
 925                 nf = &libcfs_netstrfns[i];
 926                 if (!strncmp(name, nf->nf_name, strlen(nf->nf_name)))
 927                         return nf;
 928         }
 929         return NULL;
 930 }
 931
 932 static struct netstrfns *
 933 libcfs_name2netstrfns(const char *name)
 934 {
 935         int    i;
 936
 937         for (i = 0; i < libcfs_nnetstrfns; i++)
 938                 if (!strcmp(libcfs_netstrfns[i].nf_name, name))
 939                         return &libcfs_netstrfns[i];
 940
 941         return NULL;
 942 }
 943
 944 int
 945 libcfs_isknown_lnd(__u32 lnd)
 946 {
 947         return libcfs_lnd2netstrfns(lnd) != NULL;
 948 }
 949 EXPORT_SYMBOL(libcfs_isknown_lnd);
 950
 951 char *
 952 libcfs_lnd2modname(__u32 lnd)
 953 {
 954         struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
 955
 956         return (nf == NULL) ? NULL : nf->nf_modname;
 957 }
 958 EXPORT_SYMBOL(libcfs_lnd2modname);
 959
 960 int
 961 libcfs_str2lnd(const char *str)
 962 {
 963         struct netstrfns *nf = libcfs_name2netstrfns(str);
 964
 965         if (nf != NULL)
 966                 return nf->nf_type;
 967
 968         return -ENXIO;
 969 }
 970 EXPORT_SYMBOL(libcfs_str2lnd);
 971
 972 char *
 973 libcfs_lnd2str_r(__u32 lnd, char *buf, size_t buf_size)
 974 {
 975         struct netstrfns *nf;
 976
 977         nf = libcfs_lnd2netstrfns(lnd);
 978         if (nf == NULL)
 979                 snprintf(buf, buf_size, "?%u?", lnd);
 980         else
 981                 snprintf(buf, buf_size, "%s", nf->nf_name);
 982
 983         return buf;
 984 }
 985 EXPORT_SYMBOL(libcfs_lnd2str_r);
 986
 987 char *
 988 libcfs_net2str_r(__u32 net, char *buf, size_t buf_size)
 989 {
 990         __u32             nnum = LNET_NETNUM(net);
 991         __u32             lnd  = LNET_NETTYP(net);
 992         struct netstrfns *nf;
 993
 994         nf = libcfs_lnd2netstrfns(lnd);
 995         if (nf == NULL)
 996                 snprintf(buf, buf_size, "<%u:%u>", lnd, nnum);
 997         else if (nnum == 0)
 998                 snprintf(buf, buf_size, "%s", nf->nf_name);
 999         else
1000                 snprintf(buf, buf_size, "%s%u", nf->nf_name, nnum);
1001
1002         return buf;
1003 }
1004 EXPORT_SYMBOL(libcfs_net2str_r);
1005
1006 char *
1007 libcfs_nid2str_r(lnet_nid_t nid, char *buf, size_t buf_size)
1008 {
1009         __u32             addr = LNET_NIDADDR(nid);
1010         __u32             net  = LNET_NIDNET(nid);
1011         __u32             nnum = LNET_NETNUM(net);
1012         __u32             lnd  = LNET_NETTYP(net);
1013         struct netstrfns *nf;
1014
1015         if (nid == LNET_NID_ANY) {
1016                 strncpy(buf, "<?>", buf_size);
1017                 buf[buf_size - 1] = '\0';
1018                 return buf;
1019         }
1020
1021         nf = libcfs_lnd2netstrfns(lnd);
1022         if (nf == NULL) {
1023                 snprintf(buf, buf_size, "%x@<%u:%u>", addr, lnd, nnum);
1024         } else {
1025                 size_t addr_len;
1026
1027                 nf->nf_addr2str(addr, buf, buf_size);
1028                 addr_len = strlen(buf);
1029                 if (nnum == 0)
1030                         snprintf(buf + addr_len, buf_size - addr_len, "@%s",
1031                                  nf->nf_name);
1032                 else
1033                         snprintf(buf + addr_len, buf_size - addr_len, "@%s%u",
1034                                  nf->nf_name, nnum);
1035         }
1036
1037         return buf;
1038 }
1039 EXPORT_SYMBOL(libcfs_nid2str_r);
1040
1041 char *
1042 libcfs_nidstr_r(const struct lnet_nid *nid, char *buf, size_t buf_size)
1043 {
1044         __u32 nnum;
1045         __u32 lnd;
1046         struct netstrfns *nf;
1047
1048         if (LNET_NID_IS_ANY(nid)) {
1049                 strncpy(buf, "<?>", buf_size);
1050                 buf[buf_size - 1] = '\0';
1051                 return buf;
1052         }
1053
1054         nnum = be16_to_cpu(nid->nid_num);
1055         lnd = nid->nid_type;
1056         nf = libcfs_lnd2netstrfns(lnd);
1057         if (nf) {
1058                 size_t addr_len;
1059
1060                 if (nf->nf_addr2str_size)
1061                         nf->nf_addr2str_size(nid->nid_addr, NID_ADDR_BYTES(nid),
1062                                              buf, buf_size);
1063                 else
1064                         nf->nf_addr2str(ntohl(nid->nid_addr[0]), buf, buf_size);
1065                 addr_len = strlen(buf);
1066                 if (nnum == 0)
1067                         snprintf(buf + addr_len, buf_size - addr_len, "@%s",
1068                                  nf->nf_name);
1069                 else
1070                         snprintf(buf + addr_len, buf_size - addr_len, "@%s%u",
1071                                  nf->nf_name, nnum);
1072         } else {
1073                 int l = 0;
1074                 int words = DIV_ROUND_UP(NID_ADDR_BYTES(nid), 4);
1075                 int i;
1076
1077                 for (i = 0; i < words && i < 4; i++)
1078                         l = snprintf(buf+l, buf_size-l, "%s%x",
1079                                      i ? ":" : "", ntohl(nid->nid_addr[i]));
1080                 snprintf(buf+l, buf_size-l, "@<%u:%u>", lnd, nnum);
1081         }
1082
1083         return buf;
1084 }
1085 EXPORT_SYMBOL(libcfs_nidstr_r);
1086
1087 static struct netstrfns *
1088 libcfs_str2net_internal(const char *str, __u32 *net)
1089 {
1090         struct netstrfns *nf = NULL;
1091         int               nob;
1092         unsigned int      netnum;
1093         int               i;
1094
1095         for (i = 0; i < libcfs_nnetstrfns; i++) {
1096                 nf = &libcfs_netstrfns[i];
1097                 if (!strncmp(str, nf->nf_name, strlen(nf->nf_name)))
1098                         break;
1099         }
1100
1101         if (i == libcfs_nnetstrfns)
1102                 return NULL;
1103
1104         nob = strlen(nf->nf_name);
1105
1106         if (strlen(str) == (unsigned int)nob) {
1107                 netnum = 0;
1108         } else {
1109                 if (nf->nf_type == LOLND) /* net number not allowed */
1110                         return NULL;
1111
1112                 str += nob;
1113                 i = strlen(str);
1114                 if (sscanf(str, "%u%n", &netnum, &i) < 1 ||
1115                     i != (int)strlen(str))
1116                         return NULL;
1117         }
1118
1119         *net = LNET_MKNET(nf->nf_type, netnum);
1120         return nf;
1121 }
1122
1123 __u32
1124 libcfs_str2net(const char *str)
1125 {
1126         __u32  net;
1127
1128         if (libcfs_str2net_internal(str, &net) != NULL)
1129                 return net;
1130
1131         return LNET_NET_ANY;
1132 }
1133 EXPORT_SYMBOL(libcfs_str2net);
1134
1135 lnet_nid_t
1136 libcfs_str2nid(const char *str)
1137 {
1138         const char       *sep = strchr(str, '@');
1139         struct netstrfns *nf;
1140         __u32             net;
1141         __u32             addr;
1142
1143         if (sep != NULL) {
1144                 nf = libcfs_str2net_internal(sep + 1, &net);
1145                 if (nf == NULL)
1146                         return LNET_NID_ANY;
1147         } else {
1148                 sep = str + strlen(str);
1149                 net = LNET_MKNET(SOCKLND, 0);
1150                 nf = libcfs_lnd2netstrfns(SOCKLND);
1151                 LASSERT(nf != NULL);
1152         }
1153
1154         if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
1155                 return LNET_NID_ANY;
1156
1157         return LNET_MKNID(net, addr);
1158 }
1159 EXPORT_SYMBOL(libcfs_str2nid);
1160
1161 int
1162 libcfs_strnid(struct lnet_nid *nid, const char *str)
1163 {
1164         const char       *sep = strchr(str, '@');
1165         struct netstrfns *nf;
1166         __u32             net;
1167
1168         if (sep != NULL) {
1169                 nf = libcfs_str2net_internal(sep + 1, &net);
1170                 if (nf == NULL)
1171                         return -EINVAL;
1172         } else {
1173                 sep = str + strlen(str);
1174                 net = LNET_MKNET(SOCKLND, 0);
1175                 nf = libcfs_lnd2netstrfns(SOCKLND);
1176                 LASSERT(nf != NULL);
1177         }
1178
1179         memset(nid, 0, sizeof(*nid));
1180         nid->nid_type = LNET_NETTYP(net);
1181         nid->nid_num = htons(LNET_NETNUM(net));
1182         if (nf->nf_str2addr_size) {
1183                 size_t asize = 0;
1184
1185                 if (!nf->nf_str2addr_size(str, (int)(sep - str),
1186                                           nid->nid_addr, &asize))
1187                         return -EINVAL;
1188                 nid->nid_size = asize - 4;
1189         } else {
1190                 __u32 addr;
1191
1192                 if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
1193                         return -EINVAL;
1194                 nid->nid_addr[0] = htonl(addr);
1195                 nid->nid_size = 0;
1196         }
1197         return 0;
1198 }
1199 EXPORT_SYMBOL(libcfs_strnid);
1200
1201 char *
1202 libcfs_id2str(struct lnet_process_id id)
1203 {
1204         char *str = libcfs_next_nidstring();
1205
1206         if (id.pid == LNET_PID_ANY) {
1207                 snprintf(str, LNET_NIDSTR_SIZE,
1208                          "LNET_PID_ANY-%s", libcfs_nid2str(id.nid));
1209                 return str;
1210         }
1211
1212         snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
1213                  ((id.pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
1214                  (id.pid & ~LNET_PID_USERFLAG), libcfs_nid2str(id.nid));
1215         return str;
1216 }
1217 EXPORT_SYMBOL(libcfs_id2str);
1218
1219 char *
1220 libcfs_idstr(struct lnet_processid *id)
1221 {
1222         char *str = libcfs_next_nidstring();
1223
1224         if (id->pid == LNET_PID_ANY) {
1225                 snprintf(str, LNET_NIDSTR_SIZE,
1226                          "LNET_PID_ANY-%s", libcfs_nidstr(&id->nid));
1227                 return str;
1228         }
1229
1230         snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
1231                  ((id->pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
1232                  (id->pid & ~LNET_PID_USERFLAG), libcfs_nidstr(&id->nid));
1233         return str;
1234 }
1235 EXPORT_SYMBOL(libcfs_idstr);
1236
1237 int
1238 libcfs_strid(struct lnet_processid *id, const char *str)
1239 {
1240         char *tmp = strchr(str, '-');
1241
1242         id->pid = LNET_PID_LUSTRE;
1243         if (tmp &&
1244             strncmp("LNET_PID_ANY-", str, tmp - str) != 0) {
1245                 char pid[LNET_NIDSTR_SIZE];
1246                 int rc;
1247
1248                 strscpy(pid, str, tmp - str);
1249                 rc = kstrtou32(pid, 10, &id->pid);
1250                 if (rc < 0)
1251                         return rc;
1252                 tmp++;
1253         } else {
1254                 tmp = (char *)str;
1255         }
1256
1257         return libcfs_strnid(&id->nid, tmp);
1258 }
1259 EXPORT_SYMBOL(libcfs_strid);
1260
1261 int
1262 libcfs_str2anynid(lnet_nid_t *nidp, const char *str)
1263 {
1264         if (!strcmp(str, "*")) {
1265                 *nidp = LNET_NID_ANY;
1266                 return 1;
1267         }
1268
1269         *nidp = libcfs_str2nid(str);
1270         return *nidp != LNET_NID_ANY;
1271 }
1272 EXPORT_SYMBOL(libcfs_str2anynid);