-/*
- * GPL HEADER START
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 only,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License version 2 for more details (a copy is included
- * in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU General Public License
- * version 2 along with this program; If not, see
- * http://www.gnu.org/licenses/gpl-2.0.html
- *
- * GPL HEADER END
- */
-/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
+
+/* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
* Copyright (c) 2011, 2015, Intel Corporation.
*/
-/*
- * This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
- *
- * lnet/lnet/nidstrings.c
+
+/* This file is part of Lustre, http://www.lustre.org/
*
* Author: Phil Schwan <phil@clusterfs.com>
*/
#define DEBUG_SUBSYSTEM S_LNET
+#include <linux/sunrpc/addr.h>
#include <libcfs/libcfs.h>
#include <uapi/linux/lnet/nidstr.h>
+#include <lnet/lib-types.h>
/* max value for numeric network address */
#define MAX_NUMERIC_VALUE 0xffffffff
* \retval -errno otherwise
*/
static int
-parse_addrange(const struct cfs_lstr *src, struct nidrange *nidrange)
+parse_addrange(char *str, struct nidrange *nidrange)
{
struct addrrange *addrrange;
- if (src->ls_len == 1 && src->ls_str[0] == '*') {
+ if (strcmp(str, "*") == 0) {
nidrange->nr_all = 1;
return 0;
}
- LIBCFS_ALLOC(addrrange, sizeof(struct addrrange));
+ CFS_ALLOC_PTR(addrrange);
if (addrrange == NULL)
return -ENOMEM;
list_add_tail(&addrrange->ar_link, &nidrange->nr_addrranges);
INIT_LIST_HEAD(&addrrange->ar_numaddr_ranges);
- return nidrange->nr_netstrfns->nf_parse_addrlist(src->ls_str,
- src->ls_len,
+ return nidrange->nr_netstrfns->nf_parse_addrlist(str, strlen(str),
&addrrange->ar_numaddr_ranges);
}
* \retval NULL if \a src does not match any network
*/
static struct nidrange *
-add_nidrange(const struct cfs_lstr *src,
- struct list_head *nidlist)
+add_nidrange(char *str, struct list_head *nidlist)
{
struct netstrfns *nf;
struct nidrange *nr;
- int endlen;
- unsigned netnum;
+ char *end;
+ unsigned int netnum;
- if (src->ls_len >= LNET_NIDSTR_SIZE)
- return NULL;
-
- nf = libcfs_namenum2netstrfns(src->ls_str);
+ nf = libcfs_namenum2netstrfns(str);
if (nf == NULL)
return NULL;
- endlen = src->ls_len - strlen(nf->nf_name);
- if (endlen == 0)
+ end = str + strlen(nf->nf_name);
+ if (!*end) {
/* network name only, e.g. "elan" or "tcp" */
netnum = 0;
- else {
+ } else {
/* e.g. "elan25" or "tcp23", refuse to parse if
* network name is not appended with decimal or
- * hexadecimal number */
- if (!cfs_str2num_check(src->ls_str + strlen(nf->nf_name),
- endlen, &netnum, 0, MAX_NUMERIC_VALUE))
+ * hexadecimal number
+ */
+ if (kstrtouint(end, 0, &netnum) != 0)
return NULL;
}
return nr;
}
- LIBCFS_ALLOC(nr, sizeof(struct nidrange));
+ CFS_ALLOC_PTR(nr);
if (nr == NULL)
return NULL;
list_add_tail(&nr->nr_link, nidlist);
/**
* Parses \<nidrange\> token of the syntax.
*
- * \retval
1 if \a src parses to \<addrrange\> '@' \<net\>
- * \retval 0 otherwise
+ * \retval
0 if \a src parses to \<addrrange\> '@' \<net\>
+ * \retval -EINVAL otherwise
*/
static int
-parse_nidrange(struct cfs_lstr *src, struct list_head *nidlist)
+parse_nidrange(char *str, struct list_head *nidlist)
{
- struct cfs_lstr addrrange;
- struct cfs_lstr net;
+ char *addrrange;
+ char *net;
struct nidrange *nr;
- if (cfs_gettok(src, '@', &addrrange) == 0)
+ addrrange = strim(strsep(&str, "@"));
+ if (!str)
goto failed;
- if (cfs_gettok(src, '@', &net) == 0 || src->ls_str != NULL)
+ net = strim(str);
+ if (strchr(net, '@') != NULL || !*net)
goto failed;
- nr = add_nidrange(&net, nidlist);
+ nr = add_nidrange(net, nidlist);
if (nr == NULL)
goto failed;
- if (parse_addrange(&addrrange, nr) != 0)
+ if (parse_addrange(addrrange, nr) != 0)
goto failed;
- return 1;
-failed:
return 0;
+failed:
+ return -EINVAL;
}
/**
static void
free_addrranges(struct list_head *list)
{
- while (!list_empty(list)) {
- struct addrrange *ar;
-
- ar = list_entry(list->next, struct addrrange, ar_link);
+ struct addrrange *ar;
+ while ((ar = list_first_entry_or_null(list,
+ struct addrrange,
+ ar_link)) != NULL) {
cfs_expr_list_free_list(&ar->ar_numaddr_ranges);
list_del(&ar->ar_link);
- LIBCFS_FREE(ar, sizeof(struct addrrange));
+ CFS_FREE_PTR(ar);
}
}
nr = list_entry(pos, struct nidrange, nr_link);
free_addrranges(&nr->nr_addrranges);
list_del(pos);
- LIBCFS_FREE(nr, sizeof(struct nidrange));
+ CFS_FREE_PTR(nr);
}
}
EXPORT_SYMBOL(cfs_free_nidlist);
* str.
* \see cfs_match_nid
*
- * \retval 1 on success
- * \retval 0 otherwise
+ * \retval 0 on success
+ * \retval -errno otherwise (-ENOMEM or -EINVAL)
*/
int
-cfs_parse_nidlist(char *str, int len, struct list_head *nidlist)
+cfs_parse_nidlist(char *orig, struct list_head *nidlist)
{
- struct cfs_lstr src;
- struct cfs_lstr res;
- int rc;
+ int rc = 0;
+ char *str;
+
+ orig = kstrdup(orig, GFP_KERNEL);
+ if (!orig)
+ return -ENOMEM;
- src.ls_str = str;
- src.ls_len = len;
INIT_LIST_HEAD(nidlist);
- while (src.ls_str) {
- rc = cfs_gettok(&src, ' ', &res);
- if (rc == 0) {
- cfs_free_nidlist(nidlist);
- return 0;
- }
- rc = parse_nidrange(&res, nidlist);
- if (rc == 0) {
- cfs_free_nidlist(nidlist);
- return 0;
- }
+ str = orig;
+ while (rc == 0 && str) {
+ char *tok = strsep(&str, " ");
+
+ if (*tok)
+ rc = parse_nidrange(tok, nidlist);
}
- return 1;
+ kfree(orig);
+ if (rc)
+ cfs_free_nidlist(nidlist);
+ else if (list_empty(nidlist))
+ rc = -EINVAL;
+ return rc;
}
EXPORT_SYMBOL(cfs_parse_nidlist);
* \retval 1 on match
* \retval 0 otherwises
*/
-int cfs_match_nid(lnet_nid_t nid, struct list_head *nidlist)
+int cfs_match_nid(struct lnet_nid *nid, struct list_head *nidlist)
{
struct nidrange *nr;
struct addrrange *ar;
+ if (!nid_is_nid4(nid))
+ return 0;
list_for_each_entry(nr, nidlist, nr_link) {
- if (nr->nr_netstrfns->nf_type != LNET_NETTYP(LNET_NIDNET(nid)))
+ if (nr->nr_netstrfns->nf_type != nid->nid_type)
continue;
- if (nr->nr_netnum != LNET_NETNUM(LNET_NIDNET(nid)))
+ if (nr->nr_netnum != be16_to_cpu(nid->nid_num))
continue;
if (nr->nr_all)
return 1;
list_for_each_entry(ar, &nr->nr_addrranges, ar_link)
- if (nr->nr_netstrfns->nf_match_addr(LNET_NIDADDR(nid),
- &ar->ar_numaddr_ranges))
+ if (nr->nr_netstrfns->nf_match_addr(
+ be32_to_cpu(nid->nid_addr[0]),
+ &ar->ar_numaddr_ranges))
return 1;
}
return 0;
}
EXPORT_SYMBOL(cfs_print_nidlist);
-/**
- * Determines minimum and maximum addresses for a single
- * numeric address range
- *
- * \param ar
- * \param[out] *min_nid __u32 representation of min NID
- * \param[out] *max_nid __u32 representation of max NID
- * \retval -EINVAL unsupported LNET range
- * \retval -ERANGE non-contiguous LNET range
- */
-static int cfs_ip_ar_min_max(struct addrrange *ar, __u32 *min_nid,
- __u32 *max_nid)
-{
- struct cfs_expr_list *expr_list;
- struct cfs_range_expr *range;
- unsigned int min_ip[4] = {0};
- unsigned int max_ip[4] = {0};
- int cur_octet = 0;
- bool expect_full_octet = false;
-
- list_for_each_entry(expr_list, &ar->ar_numaddr_ranges, el_link) {
- int re_count = 0;
-
- list_for_each_entry(range, &expr_list->el_exprs, re_link) {
- /* XXX: add support for multiple & non-contig. re's */
- if (re_count > 0)
- return -EINVAL;
-
- /* if a previous octet was ranged, then all remaining
- * octets must be full for contiguous range */
- if (expect_full_octet && (range->re_lo != 0 ||
- range->re_hi != 255))
- return -ERANGE;
-
- if (range->re_stride != 1)
- return -ERANGE;
-
- if (range->re_lo > range->re_hi)
- return -EINVAL;
-
- if (range->re_lo != range->re_hi)
- expect_full_octet = true;
-
- min_ip[cur_octet] = range->re_lo;
- max_ip[cur_octet] = range->re_hi;
-
- re_count++;
- }
-
- cur_octet++;
- }
-
- if (min_nid != NULL)
- *min_nid = ((min_ip[0] << 24) | (min_ip[1] << 16) |
- (min_ip[2] << 8) | min_ip[3]);
-
- if (max_nid != NULL)
- *max_nid = ((max_ip[0] << 24) | (max_ip[1] << 16) |
- (max_ip[2] << 8) | max_ip[3]);
-
- return 0;
-}
-
-/**
- * Determines minimum and maximum addresses for a single
- * numeric address range
- *
- * \param ar
- * \param[out] *min_nid __u32 representation of min NID
- * \param[out] *max_nid __u32 representation of max NID
- * \retval -EINVAL unsupported LNET range
- */
-static int cfs_num_ar_min_max(struct addrrange *ar, __u32 *min_nid,
- __u32 *max_nid)
-{
- struct cfs_expr_list *el;
- struct cfs_range_expr *re;
- unsigned int min_addr = 0;
- unsigned int max_addr = 0;
-
- list_for_each_entry(el, &ar->ar_numaddr_ranges, el_link) {
- int re_count = 0;
-
- list_for_each_entry(re, &el->el_exprs, re_link) {
- if (re_count > 0)
- return -EINVAL;
- if (re->re_lo > re->re_hi)
- return -EINVAL;
-
- if (re->re_lo < min_addr || min_addr == 0)
- min_addr = re->re_lo;
- if (re->re_hi > max_addr)
- max_addr = re->re_hi;
-
- re_count++;
- }
- }
-
- if (min_nid != NULL)
- *min_nid = min_addr;
- if (max_nid != NULL)
- *max_nid = max_addr;
-
- return 0;
-}
-
-/**
- * Takes a linked list of nidrange expressions, determines the minimum
- * and maximum nid and creates appropriate nid structures
- *
- * \param[out] *min_nid string representation of min NID
- * \param[out] *max_nid string representation of max NID
- * \retval -EINVAL unsupported LNET range
- * \retval -ERANGE non-contiguous LNET range
- */
-int cfs_nidrange_find_min_max(struct list_head *nidlist, char *min_nid,
- char *max_nid, size_t nidstr_length)
-{
- struct nidrange *first_nidrange;
- int netnum;
- struct netstrfns *nf;
- char *lndname;
- __u32 min_addr;
- __u32 max_addr;
- char min_addr_str[IPSTRING_LENGTH];
- char max_addr_str[IPSTRING_LENGTH];
- int rc;
-
- first_nidrange = list_entry(nidlist->next, struct nidrange, nr_link);
-
- netnum = first_nidrange->nr_netnum;
- nf = first_nidrange->nr_netstrfns;
- lndname = nf->nf_name;
-
- rc = nf->nf_min_max(nidlist, &min_addr, &max_addr);
- if (rc < 0)
- return rc;
-
- nf->nf_addr2str(min_addr, min_addr_str, sizeof(min_addr_str));
- nf->nf_addr2str(max_addr, max_addr_str, sizeof(max_addr_str));
-
- snprintf(min_nid, nidstr_length, "%s@%s%d", min_addr_str, lndname,
- netnum);
- snprintf(max_nid, nidstr_length, "%s@%s%d", max_addr_str, lndname,
- netnum);
-
- return 0;
-}
-EXPORT_SYMBOL(cfs_nidrange_find_min_max);
-
-/**
- * Determines the min and max NID values for num LNDs
- *
- * \param *nidlist
- * \param[out] *min_nid if provided, returns string representation of min NID
- * \param[out] *max_nid if provided, returns string representation of max NID
- * \retval -EINVAL unsupported LNET range
- * \retval -ERANGE non-contiguous LNET range
- */
-static int cfs_num_min_max(struct list_head *nidlist, __u32 *min_nid,
- __u32 *max_nid)
-{
- struct nidrange *nr;
- struct addrrange *ar;
- unsigned int tmp_min_addr = 0;
- unsigned int tmp_max_addr = 0;
- unsigned int min_addr = 0;
- unsigned int max_addr = 0;
- int nidlist_count = 0;
- int rc;
-
- list_for_each_entry(nr, nidlist, nr_link) {
- if (nidlist_count > 0)
- return -EINVAL;
-
- list_for_each_entry(ar, &nr->nr_addrranges, ar_link) {
- rc = cfs_num_ar_min_max(ar, &tmp_min_addr,
- &tmp_max_addr);
- if (rc < 0)
- return rc;
-
- if (tmp_min_addr < min_addr || min_addr == 0)
- min_addr = tmp_min_addr;
- if (tmp_max_addr > max_addr)
- max_addr = tmp_min_addr;
- }
- }
- if (max_nid != NULL)
- *max_nid = max_addr;
- if (min_nid != NULL)
- *min_nid = min_addr;
-
- return 0;
-}
-
-/**
- * Takes an nidlist and determines the minimum and maximum
- * ip addresses.
- *
- * \param *nidlist
- * \param[out] *min_nid if provided, returns string representation of min NID
- * \param[out] *max_nid if provided, returns string representation of max NID
- * \retval -EINVAL unsupported LNET range
- * \retval -ERANGE non-contiguous LNET range
- */
-static int cfs_ip_min_max(struct list_head *nidlist, __u32 *min_nid,
- __u32 *max_nid)
-{
- struct nidrange *nr;
- struct addrrange *ar;
- __u32 tmp_min_ip_addr = 0;
- __u32 tmp_max_ip_addr = 0;
- __u32 min_ip_addr = 0;
- __u32 max_ip_addr = 0;
- int nidlist_count = 0;
- int rc;
-
- list_for_each_entry(nr, nidlist, nr_link) {
- if (nidlist_count > 0)
- return -EINVAL;
-
- if (nr->nr_all) {
- min_ip_addr = 0;
- max_ip_addr = 0xffffffff;
- break;
- }
-
- list_for_each_entry(ar, &nr->nr_addrranges, ar_link) {
- rc = cfs_ip_ar_min_max(ar, &tmp_min_ip_addr,
- &tmp_max_ip_addr);
- if (rc < 0)
- return rc;
-
- if (tmp_min_ip_addr < min_ip_addr || min_ip_addr == 0)
- min_ip_addr = tmp_min_ip_addr;
- if (tmp_max_ip_addr > max_ip_addr)
- max_ip_addr = tmp_max_ip_addr;
- }
-
- nidlist_count++;
- }
-
- if (max_nid != NULL)
- *max_nid = max_ip_addr;
- if (min_nid != NULL)
- *min_nid = min_ip_addr;
-
- return 0;
-}
-
static int
libcfs_lo_str2addr(const char *str, int nob, __u32 *addr)
{
(addr >> 8) & 0xff, addr & 0xff);
}
+static void
+libcfs_ip_addr2str_size(const __be32 *addr, size_t asize,
+ char *str, size_t size)
+{
+ struct sockaddr_storage sa = {};
+
+ switch (asize) {
+ case 4:
+ sa.ss_family = AF_INET;
+ memcpy(&((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
+ addr, asize);
+ break;
+ case 16:
+ sa.ss_family = AF_INET6;
+ memcpy(&((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
+ addr, asize);
+ break;
+ default:
+ return;
+ }
+
+ rpc_ntop((struct sockaddr *)&sa, str, size);
+}
+
/* CAVEAT EMPTOR XscanfX
* I use "%n" at the end of a sscanf format to detect trailing junk. However
* sscanf may return immediately if it sees the terminating '0' in a string, so
return 0;
}
+static int
+libcfs_ip_str2addr_size(const char *str, int nob,
+ __be32 *addr, size_t *alen)
+{
+ struct sockaddr_storage sa;
+
+ /* Note: 'net' arg to rpc_pton is only needed for link-local
+ * addresses. Such addresses would not work with LNet routing,
+ * so we can assume they aren't used. So it doesn't matter
+ * which net namespace is passed.
+ */
+ if (rpc_pton(&init_net, str, nob,
+ (struct sockaddr *)&sa, sizeof(sa)) == 0)
+ return 0;
+ if (sa.ss_family == AF_INET6) {
+ memcpy(addr,
+ &((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
+ 16);
+ *alen = 16;
+ return 1;
+ }
+ if (sa.ss_family == AF_INET) {
+ memcpy(addr,
+ &((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
+ 4);
+ *alen = 4;
+ return 1;
+ }
+ return 0;
+}
+
+
/* Used by lnet/config.c so it can't be static */
int
-cfs_ip_addr_parse(char *str, int len, struct list_head *list)
+cfs_ip_addr_parse(char *str, int len_ignored, struct list_head *list)
{
struct cfs_expr_list *el;
- struct cfs_lstr src;
- int rc;
- int i;
-
- src.ls_str = str;
- src.ls_len = len;
- i = 0;
+ int rc = 0;
+ int i = 0;
- while (src.ls_str != NULL) {
- struct cfs_lstr res;
+ str = strim(str);
+ while (rc == 0 && str) {
+ char *res;
- if (!cfs_gettok(&src, '.', &res)) {
+ res = strsep(&str, ".");
+ res = strim(res);
+ if (!*res) {
rc = -EINVAL;
- goto out;
+ } else if ((rc = cfs_expr_list_parse(res, strlen(res),
+ 0, 255, &el)) == 0) {
+ list_add_tail(&el->el_link, list);
+ i++;
}
+ }
- rc = cfs_expr_list_parse(res.ls_str, res.ls_len, 0, 255, &el);
- if (rc != 0)
- goto out;
+ if (rc == 0 && i == 4)
+ return 0;
+ cfs_expr_list_free_list(list);
- list_add_tail(&el->el_link, list);
- i++;
- }
+ return rc ?: -EINVAL;
+}
- if (i == 4)
+/**
+ * Print the range expression \a re into specified \a buffer.
+ * If \a bracketed is true, expression does not need additional
+ * brackets.
+ *
+ * \retval number of characters written
+ */
+static int
+cfs_range_expr_print(char *buffer, int count, struct cfs_range_expr *expr,
+ bool bracketed)
+{
+ int i;
+ char s[] = "[";
+ char e[] = "]";
+
+ if (bracketed)
+ s[0] = e[0] = '\0';
+
+ if (expr->re_lo == expr->re_hi)
+ i = scnprintf(buffer, count, "%u", expr->re_lo);
+ else if (expr->re_stride == 1)
+ i = scnprintf(buffer, count, "%s%u-%u%s",
+ s, expr->re_lo, expr->re_hi, e);
+ else
+ i = scnprintf(buffer, count, "%s%u-%u/%u%s",
+ s, expr->re_lo, expr->re_hi,
+ expr->re_stride, e);
+ return i;
+}
+
+/**
+ * Print a list of range expressions (\a expr_list) into specified \a buffer.
+ * If the list contains several expressions, separate them with comma
+ * and surround the list with brackets.
+ *
+ * \retval number of characters written
+ */
+static int
+cfs_expr_list_print(char *buffer, int count, struct cfs_expr_list *expr_list)
+{
+ struct cfs_range_expr *expr;
+ int i = 0, j = 0;
+ int numexprs = 0;
+
+ if (count <= 0)
return 0;
- rc = -EINVAL;
-out:
- cfs_expr_list_free_list(list);
+ list_for_each_entry(expr, &expr_list->el_exprs, re_link)
+ numexprs++;
- return rc;
+ if (numexprs > 1)
+ i += scnprintf(buffer + i, count - i, "[");
+
+ list_for_each_entry(expr, &expr_list->el_exprs, re_link) {
+ if (j++ != 0)
+ i += scnprintf(buffer + i, count - i, ",");
+ i += cfs_range_expr_print(buffer + i, count - i, expr,
+ numexprs > 1);
+ }
+
+ if (numexprs > 1)
+ i += scnprintf(buffer + i, count - i, "]");
+
+ return i;
}
static int
* \retval 0 if \a str parsed to numeric address
* \retval errno otherwise
*/
-static int
+int
libcfs_num_parse(char *str, int len, struct list_head *list)
{
struct cfs_expr_list *el;
struct cfs_expr_list *el;
LASSERT(!list_empty(numaddr));
- el = list_entry(numaddr->next, struct cfs_expr_list, el_link);
+ el = list_first_entry(numaddr, struct cfs_expr_list, el_link);
return cfs_expr_list_match(addr, el);
}
.nf_str2addr = libcfs_lo_str2addr,
.nf_parse_addrlist = libcfs_num_parse,
.nf_print_addrlist = libcfs_num_addr_range_print,
- .nf_match_addr = libcfs_num_match,
- .nf_min_max = cfs_num_min_max },
+ .nf_match_addr = libcfs_num_match
+ },
{ .nf_type = SOCKLND,
.nf_name = "tcp",
.nf_modname = "ksocklnd",
.nf_addr2str = libcfs_ip_addr2str,
+ .nf_addr2str_size = libcfs_ip_addr2str_size,
.nf_str2addr = libcfs_ip_str2addr,
+ .nf_str2addr_size = libcfs_ip_str2addr_size,
.nf_parse_addrlist = cfs_ip_addr_parse,
.nf_print_addrlist = libcfs_ip_addr_range_print,
- .nf_match_addr = cfs_ip_addr_match,
- .nf_min_max = cfs_ip_min_max },
+ .nf_match_addr = cfs_ip_addr_match
+ },
{ .nf_type = O2IBLND,
.nf_name = "o2ib",
.nf_modname = "ko2iblnd",
.nf_str2addr = libcfs_ip_str2addr,
.nf_parse_addrlist = cfs_ip_addr_parse,
.nf_print_addrlist = libcfs_ip_addr_range_print,
- .nf_match_addr = cfs_ip_addr_match,
- .nf_min_max = cfs_ip_min_max },
+ .nf_match_addr = cfs_ip_addr_match
+ },
{ .nf_type = GNILND,
.nf_name = "gni",
.nf_modname = "kgnilnd",
.nf_str2addr = libcfs_num_str2addr,
.nf_parse_addrlist = libcfs_num_parse,
.nf_print_addrlist = libcfs_num_addr_range_print,
- .nf_match_addr = libcfs_num_match,
- .nf_min_max = cfs_num_min_max },
+ .nf_match_addr = libcfs_num_match
+ },
{ .nf_type = GNIIPLND,
.nf_name = "gip",
.nf_modname = "kgnilnd",
.nf_str2addr = libcfs_ip_str2addr,
.nf_parse_addrlist = cfs_ip_addr_parse,
.nf_print_addrlist = libcfs_ip_addr_range_print,
- .nf_match_addr = cfs_ip_addr_match,
- .nf_min_max = cfs_ip_min_max },
+ .nf_match_addr = cfs_ip_addr_match
+ },
{ .nf_type = PTL4LND,
.nf_name = "ptlf",
.nf_modname = "kptl4lnd",
.nf_str2addr = libcfs_num_str2addr,
.nf_parse_addrlist = libcfs_num_parse,
.nf_print_addrlist = libcfs_num_addr_range_print,
- .nf_match_addr = libcfs_num_match,
- .nf_min_max = cfs_num_min_max},
+ .nf_match_addr = libcfs_num_match
+ },
+ {
+ .nf_type = KFILND,
+ .nf_name = "kfi",
+ .nf_modname = "kkfilnd",
+ .nf_addr2str = libcfs_decnum_addr2str,
+ .nf_str2addr = libcfs_num_str2addr,
+ .nf_parse_addrlist = libcfs_num_parse,
+ .nf_print_addrlist = libcfs_num_addr_range_print,
+ .nf_match_addr = libcfs_num_match
+ },
};
static const size_t libcfs_nnetstrfns = ARRAY_SIZE(libcfs_netstrfns);
static struct netstrfns *
+type2net_info(__u32 net_type)
+{
+ int i;
+
+ for (i = 0; i < libcfs_nnetstrfns; i++) {
+ if (libcfs_netstrfns[i].nf_type == net_type)
+ return &libcfs_netstrfns[i];
+ }
+
+ return NULL;
+}
+
+int
+cfs_match_net(__u32 net_id, __u32 net_type, struct list_head *net_num_list)
+{
+ __u32 net_num;
+
+ if (!net_num_list)
+ return 0;
+
+ if (net_type != LNET_NETTYP(net_id))
+ return 0;
+
+ net_num = LNET_NETNUM(net_id);
+
+ /* if there is a net number but the list passed in is empty, then
+ * there is no match.
+ */
+ if (!net_num && list_empty(net_num_list))
+ return 1;
+ else if (list_empty(net_num_list))
+ return 0;
+
+ if (!libcfs_num_match(net_num, net_num_list))
+ return 0;
+
+ return 1;
+}
+
+int
+cfs_match_nid_net(struct lnet_nid *nid, __u32 net_type,
+ struct list_head *net_num_list,
+ struct list_head *addr)
+{
+ __u32 address;
+ struct netstrfns *nf;
+
+ if (!addr || list_empty(addr) || !net_num_list)
+ return 0;
+
+ nf = type2net_info(LNET_NETTYP(LNET_NID_NET(nid)));
+ if (!nf)
+ return 0;
+
+ /* FIXME handle long-addr nid */
+ address = LNET_NIDADDR(lnet_nid_to_nid4(nid));
+
+ /* if either the address or net number don't match then no match */
+ if (!nf->nf_match_addr(address, addr) ||
+ !cfs_match_net(LNET_NID_NET(nid), net_type, net_num_list))
+ return 0;
+
+ return 1;
+}
+EXPORT_SYMBOL(cfs_match_nid_net);
+
+static struct netstrfns *
libcfs_lnd2netstrfns(__u32 lnd)
{
int i;
}
EXPORT_SYMBOL(libcfs_nid2str_r);
+char *
+libcfs_nidstr_r(const struct lnet_nid *nid, char *buf, size_t buf_size)
+{
+ __u32 nnum;
+ __u32 lnd;
+ struct netstrfns *nf;
+
+ if (LNET_NID_IS_ANY(nid)) {
+ strncpy(buf, "<?>", buf_size);
+ buf[buf_size - 1] = '\0';
+ return buf;
+ }
+
+ nnum = be16_to_cpu(nid->nid_num);
+ lnd = nid->nid_type;
+ nf = libcfs_lnd2netstrfns(lnd);
+ if (nf) {
+ size_t addr_len;
+
+ if (nf->nf_addr2str_size)
+ nf->nf_addr2str_size(nid->nid_addr, NID_ADDR_BYTES(nid),
+ buf, buf_size);
+ else
+ nf->nf_addr2str(ntohl(nid->nid_addr[0]), buf, buf_size);
+ addr_len = strlen(buf);
+ if (nnum == 0)
+ snprintf(buf + addr_len, buf_size - addr_len, "@%s",
+ nf->nf_name);
+ else
+ snprintf(buf + addr_len, buf_size - addr_len, "@%s%u",
+ nf->nf_name, nnum);
+ } else {
+ int l = 0;
+ int words = DIV_ROUND_UP(NID_ADDR_BYTES(nid), 4);
+ int i;
+
+ for (i = 0; i < words && i < 4; i++)
+ l = snprintf(buf+l, buf_size-l, "%s%x",
+ i ? ":" : "", ntohl(nid->nid_addr[i]));
+ snprintf(buf+l, buf_size-l, "@<%u:%u>", lnd, nnum);
+ }
+
+ return buf;
+}
+EXPORT_SYMBOL(libcfs_nidstr_r);
+
static struct netstrfns *
libcfs_str2net_internal(const char *str, __u32 *net)
{
if (libcfs_str2net_internal(str, &net) != NULL)
return net;
- return LNET_NIDNET(LNET_NID_ANY);
+ return LNET_NET_ANY;
}
EXPORT_SYMBOL(libcfs_str2net);
}
EXPORT_SYMBOL(libcfs_str2nid);
+int
+libcfs_strnid(struct lnet_nid *nid, const char *str)
+{
+ const char *sep = strchr(str, '@');
+ struct netstrfns *nf;
+ __u32 net;
+
+ if (sep != NULL) {
+ nf = libcfs_str2net_internal(sep + 1, &net);
+ if (nf == NULL)
+ return -EINVAL;
+ } else {
+ if (strcmp(str, "<?>") == 0) {
+ memcpy(nid, &LNET_ANY_NID, sizeof(*nid));
+ return 0;
+ }
+ sep = str + strlen(str);
+ net = LNET_MKNET(SOCKLND, 0);
+ nf = libcfs_lnd2netstrfns(SOCKLND);
+ LASSERT(nf != NULL);
+ }
+
+ memset(nid, 0, sizeof(*nid));
+ nid->nid_type = LNET_NETTYP(net);
+ nid->nid_num = htons(LNET_NETNUM(net));
+ if (nf->nf_str2addr_size) {
+ size_t asize = 0;
+
+ if (!nf->nf_str2addr_size(str, (int)(sep - str),
+ nid->nid_addr, &asize))
+ return -EINVAL;
+ nid->nid_size = asize - 4;
+ } else {
+ __u32 addr;
+
+ if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
+ return -EINVAL;
+ nid->nid_addr[0] = htonl(addr);
+ nid->nid_size = 0;
+ }
+ return 0;
+}
+EXPORT_SYMBOL(libcfs_strnid);
+
char *
libcfs_id2str(struct lnet_process_id id)
{
}
EXPORT_SYMBOL(libcfs_id2str);
+char *
+libcfs_idstr(struct lnet_processid *id)
+{
+ char *str = libcfs_next_nidstring();
+
+ if (id->pid == LNET_PID_ANY) {
+ snprintf(str, LNET_NIDSTR_SIZE,
+ "LNET_PID_ANY-%s", libcfs_nidstr(&id->nid));
+ return str;
+ }
+
+ snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
+ ((id->pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
+ (id->pid & ~LNET_PID_USERFLAG), libcfs_nidstr(&id->nid));
+ return str;
+}
+EXPORT_SYMBOL(libcfs_idstr);
+
+int
+libcfs_strid(struct lnet_processid *id, const char *str)
+{
+ char *tmp = strchr(str, '-');
+
+ id->pid = LNET_PID_LUSTRE;
+ if (tmp &&
+ strncmp("LNET_PID_ANY-", str, tmp - str) != 0) {
+ char pid[LNET_NIDSTR_SIZE];
+ int rc;
+
+ strscpy(pid, str, tmp - str);
+ rc = kstrtou32(pid, 10, &id->pid);
+ if (rc < 0)
+ return rc;
+ tmp++;
+ } else {
+ tmp = (char *)str;
+ }
+
+ return libcfs_strnid(&id->nid, tmp);
+}
+EXPORT_SYMBOL(libcfs_strid);
+
int
libcfs_str2anynid(lnet_nid_t *nidp, const char *str)
{
git://git.whamcloud.com / fs / lustre-release.git / blobdiff