Viewing: nidstrings.c
// 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/
*
* Author: Phil Schwan <phil@clusterfs.com>
*/
#define DEBUG_SUBSYSTEM S_LNET
#include <linux/sunrpc/addr.h>
#include <linux/libcfs/libcfs.h>
#include <uapi/linux/lnet/nidstr.h>
#include <linux/lnet/lib-types.h>
#include <linux/ctype.h>
#include <linux/inet.h>
#include <linux/inetdevice.h>
/* max value for numeric network address */
#define MAX_NUMERIC_VALUE 0xffffffff
#define IPSTRING_LENGTH 16
/* CAVEAT VENDITOR! Keep the canonical string representation of nets/nids
* consistent in all conversion functions. Some code fragments are copied
* around for the sake of clarity...
*/
/* CAVEAT EMPTOR! Racey temporary buffer allocation!
* Choose the number of nidstrings to support the MAXIMUM expected number of
* concurrent users. If there are more, the returned string will be volatile.
* NB this number must allow for a process to be descheduled for a timeslice
* between getting its string and using it.
*/
static char libcfs_nidstrings[LNET_NIDSTR_COUNT][LNET_NIDSTR_SIZE];
static int libcfs_nidstring_idx;
static DEFINE_SPINLOCK(libcfs_nidstring_lock);
static struct netstrfns *libcfs_namenum2netstrfns(const char *name);
char *
libcfs_next_nidstring(void)
{
char *str;
unsigned long flags;
spin_lock_irqsave(&libcfs_nidstring_lock, flags);
str = libcfs_nidstrings[libcfs_nidstring_idx++];
if (libcfs_nidstring_idx == ARRAY_SIZE(libcfs_nidstrings))
libcfs_nidstring_idx = 0;
spin_unlock_irqrestore(&libcfs_nidstring_lock, flags);
return str;
}
EXPORT_SYMBOL(libcfs_next_nidstring);
/* NID range list syntax.
* \verbatim
*
* <nidlist> :== <nidrange> [ ' ' <nidrange> ]
* <nidrange> :== <addrrange> '@' <net>
* <addrrange> :== '*' |
* <netmask> |
* <ipv6_addr> |
* <ipv4_addr_range> |
* <numaddr_range>
* <netmask> :== An IPv4 or IPv6 network mask in CIDR notation.
* e.g. 192.168.1.0/24 or 2001:0db8::/32
* <ipv6_addr> :== A single IPv6 address
* <ipv4_addr_range> :==
* <numaddr_range>.<numaddr_range>.<numaddr_range>.<numaddr_range>
* <numaddr_range> :== <number> |
* <expr_list>
* <expr_list> :== '[' <range_expr> [ ',' <range_expr>] ']'
* <range_expr> :== <number> |
* <number> '-' <number> |
* <number> '-' <number> '/' <number>
* <net> :== <netname> | <netname><number>
* <netname> :== "lo" | "tcp" | "o2ib" | "gni" | "gip" | "ptlf" | "kfi"
* \endverbatim
*/
/*
* Structure to represent \<nidrange\> token of the syntax.
*
* One of this is created for each \<net\> parsed.
*/
struct nidrange {
/**
* Link to list of this structures which is built on nid range
* list parsing.
*/
struct list_head nr_link;
/* List head for addrrange::ar_link. */
struct list_head nr_addrranges;
/* List head for nidmask::nm_link. */
struct list_head nr_nidmasks;
/* Flag indicating that *@<net> is found. */
int nr_all;
/* Pointer to corresponding element of libcfs_netstrfns. */
struct netstrfns *nr_netstrfns;
/* Number of network. E.g. 5 if \<net\> is "elan5". */
int nr_netnum;
};
struct nidmask {
/* Link to nidrange::nr_nidmasks */
struct list_head nm_link;
/* This is the base address that was parsed */
union {
struct in_addr ipv4;
struct in6_addr ipv6;
} nm_addr;
/* Netmask derived from the prefix length */
union {
struct in_addr ipv4;
struct in6_addr ipv6;
} nm_netmask;
/* Network address derived from the base address and the netmask */
union {
struct in_addr ipv4;
struct in6_addr ipv6;
} nm_netaddr;
/* Address family */
sa_family_t nm_family;
/* Prefix length */
u8 nm_prefix_len;
};
/*
* Structure to represent \<addrrange\> token of the syntax.
*/
struct addrrange {
/**
* Link to nidrange::nr_addrranges.
*/
struct list_head ar_link;
/**
* List head for cfs_expr_list::el_list.
*/
struct list_head ar_numaddr_ranges;
};
/**
* cfs_range_expr_parse() - Parses \<range_expr\> token of the syntax.
* @src: contains range expression to be parsed
* @min: Min value
* @max: Max value
* @bracketed: If %False @src must have only single number/range
* @expr: After successful parsing this will be populated [out]
*
* Parses \<range_expr\> token of the syntax. If @bracketed is false,
* @src should only have a single token which can be \<number\> or \*
*
* \retval pointer to allocated range_expr and initialized
* range_expr::re_lo, range_expr::re_hi & range_expr:re_stride if @src parses to
* \<number\> |
* \<number\> '-' \<number\> |
* \<number\> '-' \<number\> '/' \<number\>
*
* Returns %0 will be returned if it can be parsed, otherwise %-EINVAL or
* %-ENOMEM will be returned.
*/
static int
cfs_range_expr_parse(char *src, unsigned int min, unsigned int max,
int bracketed, struct cfs_range_expr **expr)
{
struct cfs_range_expr *re;
char *tok;
unsigned int num;
LIBCFS_ALLOC(re, sizeof(*re));
if (!re)
return -ENOMEM;
src = strim(src);
if (strcmp(src, "*") == 0) {
re->re_lo = min;
re->re_hi = max;
re->re_stride = 1;
goto out;
}
if (kstrtouint(src, 0, &num) == 0) {
if (num < min || num > max)
goto failed;
/* <number> is parsed */
re->re_lo = num;
re->re_hi = re->re_lo;
re->re_stride = 1;
goto out;
}
if (!bracketed)
goto failed;
tok = strim(strsep(&src, "-"));
if (!src)
goto failed;
if (kstrtouint(tok, 0, &num) != 0 ||
num < min || num > max)
goto failed;
re->re_lo = num;
/* <number> - */
if (kstrtouint(strim(src), 0, &num) == 0) {
if (num < min || num > max)
goto failed;
re->re_hi = num;
/* <number> - <number> is parsed */
re->re_stride = 1;
goto out;
}
/* go to check <number> '-' <number> '/' <number> */
tok = strim(strsep(&src, "/"));
if (!src)
goto failed;
if (kstrtouint(tok, 0, &num) != 0 ||
num < min || num > max)
goto failed;
re->re_hi = num;
if (kstrtouint(strim(src), 0, &num) != 0 ||
num < min || num > max)
goto failed;
re->re_stride = num;
out:
if (re->re_lo > re->re_hi)
goto failed;
*expr = re;
return 0;
failed:
LIBCFS_FREE(re, sizeof(*re));
return -EINVAL;
}
/**
* cfs_expr_list_match() - Matches value (@value) against ranges expression
* list @expr_list.
* @value: Value to be checked against the range
* @expr_list: list of (struct cfs_range_expr) it defines range
*
* Return:
* * %1 if @value matches
* * %0 otherwise
*/
int
cfs_expr_list_match(u32 value, struct cfs_expr_list *expr_list)
{
struct cfs_range_expr *expr;
list_for_each_entry(expr, &expr_list->el_exprs, re_link) {
if (value >= expr->re_lo && value <= expr->re_hi &&
((value - expr->re_lo) % expr->re_stride) == 0)
return 1;
}
return 0;
}
/**
* cfs_expr_list_values() - Convert express list (@expr_list) to an array of
* all matched values
* @expr_list: list of (struct cfs_range_expr) it defines range
* @max: Max array size
* @valpp: Array of all matched values [out]
*
* Return:
* * %N N is total number of all matched values
* * %0 if expression list is empty
* * %negative for failure
*/
int
cfs_expr_list_values(struct cfs_expr_list *expr_list, int max, u32 **valpp)
{
struct cfs_range_expr *expr;
int count = 0;
u32 *val;
int i;
list_for_each_entry(expr, &expr_list->el_exprs, re_link) {
for (i = expr->re_lo; i <= expr->re_hi; i++) {
if (((i - expr->re_lo) % expr->re_stride) == 0)
count++;
}
}
if (count == 0) /* empty expression list */
return 0;
if (count > max) {
CERROR("Number of values %d exceeds max allowed %d\n",
max, count);
return -EINVAL;
}
CFS_ALLOC_PTR_ARRAY(val, count);
if (!val)
return -ENOMEM;
count = 0;
list_for_each_entry(expr, &expr_list->el_exprs, re_link) {
for (i = expr->re_lo; i <= expr->re_hi; i++) {
if (((i - expr->re_lo) % expr->re_stride) == 0)
val[count++] = i;
}
}
*valpp = val;
return count;
}
EXPORT_SYMBOL(cfs_expr_list_values);
/**
* cfs_expr_list_free() - Frees cfs_range_expr structures of @expr_list.
* @expr_list: Struct cfs_range_expr to free
*/
void
cfs_expr_list_free(struct cfs_expr_list *expr_list)
{
while (!list_empty(&expr_list->el_exprs)) {
struct cfs_range_expr *expr;
expr = list_entry(expr_list->el_exprs.next,
struct cfs_range_expr, re_link);
list_del(&expr->re_link);
LIBCFS_FREE(expr, sizeof(*expr));
}
LIBCFS_FREE(expr_list, sizeof(*expr_list));
}
EXPORT_SYMBOL(cfs_expr_list_free);
/**
* cfs_expr_list_parse() - Parses \<cfs_expr_list\> token of the syntax.
* @str: Expression to be parsed
* @len: length of @str
* @min: Min value of parsed range
* @max: Max value of parsed range
* @elpp: Parsed range expression [out]
*
* Return:
* * %0 if @str parses to \<number\> | \<expr_list\>
* * %-errno otherwise
*/
int
cfs_expr_list_parse(char *str, int len, unsigned int min, unsigned int max,
struct cfs_expr_list **elpp)
{
struct cfs_expr_list *expr_list;
struct cfs_range_expr *expr;
char *src;
int rc;
CFS_ALLOC_PTR(expr_list);
if (!expr_list)
return -ENOMEM;
str = kstrndup(str, len, GFP_KERNEL);
if (!str) {
CFS_FREE_PTR(expr_list);
return -ENOMEM;
}
src = str;
INIT_LIST_HEAD(&expr_list->el_exprs);
if (src[0] == '[' &&
src[strlen(src) - 1] == ']') {
src++;
src[strlen(src)-1] = '\0';
rc = -EINVAL;
while (src) {
char *tok = strsep(&src, ",");
if (!*tok) {
rc = -EINVAL;
break;
}
tok = strim(tok);
rc = cfs_range_expr_parse(tok, min, max, 1, &expr);
if (rc != 0)
break;
list_add_tail(&expr->re_link, &expr_list->el_exprs);
}
} else {
rc = cfs_range_expr_parse(src, min, max, 0, &expr);
if (rc == 0)
list_add_tail(&expr->re_link, &expr_list->el_exprs);
}
kfree(str);
if (rc != 0)
cfs_expr_list_free(expr_list);
else
*elpp = expr_list;
return rc;
}
EXPORT_SYMBOL(cfs_expr_list_parse);
/**
* cfs_expr_list_free_list() - Frees cfs_expr_list structures of @list.
* @list: List to free (struct cfs_expr_list)
*
* For each struct cfs_expr_list structure found on @list it frees
* range_expr list attached to it and frees the cfs_expr_list itself.
*/
void
cfs_expr_list_free_list(struct list_head *list)
{
struct cfs_expr_list *el;
while (!list_empty(list)) {
el = list_first_entry(list,
struct cfs_expr_list, el_link);
list_del(&el->el_link);
cfs_expr_list_free(el);
}
}
/**
* parse_addrange() - Parses \<addrrange\> token on the syntax.
* @str: address range
* @nidrange: pointer to the struct nidrange
*
* Allocates struct addrrange and links to @nidrange via
* (nidrange::nr_addrranges)
*
* Return:
* * %0 if @src parses to '*' | \<ipaddr_range\> | \<cfs_expr_list\>
* * %-errno otherwise
*/
static int
parse_addrange(char *str, struct nidrange *nidrange)
{
struct addrrange *addrrange;
if (strcmp(str, "*") == 0) {
nidrange->nr_all = 1;
return 0;
}
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(str, strlen(str),
&addrrange->ar_numaddr_ranges);
}
static void
init_ipv4_nidmask(struct sockaddr_in *sa, struct nidmask *nm)
{
memcpy(&nm->nm_addr.ipv4, &sa->sin_addr.s_addr, sizeof(struct in_addr));
nm->nm_netmask.ipv4.s_addr = inet_make_mask(nm->nm_prefix_len);
nm->nm_netaddr.ipv4.s_addr = sa->sin_addr.s_addr &
nm->nm_netmask.ipv4.s_addr;
}
/* Note: The memory of struct nidmask is allocated via CFS_ALLOC_PTR, so it has
* been set to zero as required by this function.
*/
static void
init_ipv6_nidmask(struct sockaddr_in6 *sa, struct nidmask *nm)
{
int i, j;
memcpy(&nm->nm_addr.ipv6, &sa->sin6_addr.s6_addr,
sizeof(struct in6_addr));
for (i = nm->nm_prefix_len, j = 0; i > 0; i -= 8, j++) {
if (i >= 8)
nm->nm_netmask.ipv6.s6_addr[j] = 0xff;
else
nm->nm_netmask.ipv6.s6_addr[j] =
(unsigned long)(0xffU << (8 - i));
}
for (i = 0; i < sizeof(struct in6_addr); i++)
nm->nm_netaddr.ipv6.s6_addr[i] = sa->sin6_addr.s6_addr[i] &
nm->nm_netmask.ipv6.s6_addr[i];
}
static u8
parse_prefix_len(char *str)
{
unsigned int max;
unsigned int prefix_len;
char *slash = strchr(str, '/');
/* IPv4 netmask must include an explicit prefix length */
if (!(slash || strchr(str, ':')))
return 0;
/* We treat an IPv6 address without a prefix length as having /128 */
if (!slash)
return 128;
if (strchr(str, ':'))
max = 128;
else
max = 32;
if (kstrtouint(slash + 1, 10, &prefix_len))
return 0;
if (prefix_len < 1 || prefix_len > max)
return 0;
return (u8)prefix_len;
}
static int
parse_nidmask(char *str, struct nidrange *nr)
{
struct nidmask *nm;
struct sockaddr_storage sa;
char *addrstr;
CFS_ALLOC_PTR(nm);
if (!nm)
return -ENOMEM;
/* Add to nr_nidmasks so that our caller can free us on error */
list_add_tail(&nm->nm_link, &nr->nr_nidmasks);
nm->nm_prefix_len = parse_prefix_len(str);
if (!nm->nm_prefix_len)
return -EINVAL;
addrstr = strsep(&str, "/");
if (rpc_pton(&init_net, addrstr, strlen(addrstr),
(struct sockaddr *)&sa, sizeof(sa)) == 0)
return -EINVAL;
nm->nm_family = sa.ss_family;
if (nm->nm_family == AF_INET6)
init_ipv6_nidmask((struct sockaddr_in6 *)&sa, nm);
else if (nm->nm_family == AF_INET)
init_ipv4_nidmask((struct sockaddr_in *)&sa, nm);
else
return -EINVAL;
return 0;
}
/**
* add_nidrange() - Finds or creates struct nidrange.
* @str: Input string
* @nidlist: list of nidranges
*
* Checks if @str is a valid network name, looks for corresponding
* nidrange on the list of nidranges (@nidlist), creates new struct
* nidrange if it is not found.
*
* Return:
* * %pointer to struct nidrange matching network specified via @str
* * %NULL if @str does not match any network
*/
static struct nidrange *
add_nidrange(char *str, struct list_head *nidlist)
{
struct netstrfns *nf;
struct nidrange *nr;
char *end;
unsigned int netnum;
nf = libcfs_namenum2netstrfns(str);
if (nf == NULL)
return NULL;
end = str + strlen(nf->nf_name);
if (!*end) {
/* network name only, e.g. "elan" or "tcp" */
netnum = 0;
} else {
/* e.g. "elan25" or "tcp23", refuse to parse if
* network name is not appended with decimal or
* hexadecimal number
*/
if (kstrtouint(end, 0, &netnum) != 0)
return NULL;
}
list_for_each_entry(nr, nidlist, nr_link) {
if (nr->nr_netstrfns != nf)
continue;
if (nr->nr_netnum != netnum)
continue;
return nr;
}
CFS_ALLOC_PTR(nr);
if (nr == NULL)
return NULL;
list_add_tail(&nr->nr_link, nidlist);
INIT_LIST_HEAD(&nr->nr_addrranges);
INIT_LIST_HEAD(&nr->nr_nidmasks);
nr->nr_netstrfns = nf;
nr->nr_all = 0;
nr->nr_netnum = netnum;
return nr;
}
/**
* parse_nidrange() - Parses \<nidrange\> token of the syntax.
* @str: Input string
* @nidlist: list of nidranges
*
* Return:
* * %0 if @src parses to \<addrrange\> '@' \<net\>
* * %-EINVAL otherwise
*/
static int
parse_nidrange(char *str, struct list_head *nidlist)
{
char *addrrange;
char *net;
char *slash;
struct nidrange *nr;
int rc;
addrrange = strim(strsep(&str, "@"));
if (!str)
return -EINVAL;
net = strim(str);
if (strchr(net, '@') || !*net)
return -EINVAL;
nr = add_nidrange(net, nidlist);
if (!nr)
return -EINVAL;
/* Check for a '/' that does not appear inside '[]' */
slash = strchr(addrrange, '/');
if (strchr(addrrange, ':') || (slash && !strchr(slash, ']')))
rc = parse_nidmask(addrrange, nr);
else
rc = parse_addrange(addrrange, nr);
return rc;
}
/**
* free_addrranges() - Frees addrrange structures of @list.
* @list: List to free (struct addrrange)
*
* For each struct addrrange structure found on @list it frees
* cfs_expr_list list attached to it and frees the addrrange itself.
*/
static void
free_addrranges(struct list_head *list)
{
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);
CFS_FREE_PTR(ar);
}
}
static void
free_nidmasks(struct list_head *list)
{
struct nidmask *nm;
while ((nm = list_first_entry_or_null(list,
struct nidmask,
nm_link)) != NULL) {
list_del(&nm->nm_link);
CFS_FREE_PTR(nm);
}
}
/**
* cfs_free_nidlist() - Frees nidrange strutures of @list.
* @list: List fo free (struct nidrange)
*
* For each struct nidrange structure found on @list it frees
* addrrange list attached to it and frees the nidrange itself.
*/
void
cfs_free_nidlist(struct list_head *list)
{
struct list_head *pos, *next;
struct nidrange *nr;
list_for_each_safe(pos, next, list) {
nr = list_entry(pos, struct nidrange, nr_link);
free_addrranges(&nr->nr_addrranges);
free_nidmasks(&nr->nr_nidmasks);
list_del(pos);
CFS_FREE_PTR(nr);
}
}
EXPORT_SYMBOL(cfs_free_nidlist);
/**
* cfs_parse_nidlist() - Parses nid range list.
* @orig: Original string (NID)
* @len: length of @orig
* @nidlist: Populate after success parse (list of struct nidrange) [out]
*
* Parses with rigorous syntax and overflow checking @orig into
* \<nidrange\> [ ' ' \<nidrange\> ], compiles @orig into set of
* structures and links that structure to @nidlist. The resulting
* list can be used to match a NID againts set of NIDS defined by @orig.
* \see cfs_match_nid
*
* Return:
* * %0 on success
* * %-errno otherwise (-ENOMEM or -EINVAL)
*/
int
cfs_parse_nidlist(char *orig, int len, struct list_head *nidlist)
{
int rc = 0;
char *str;
orig = kstrndup(orig, len, GFP_KERNEL);
if (!orig)
return -ENOMEM;
INIT_LIST_HEAD(nidlist);
str = orig;
while (rc == 0 && str) {
char *tok = strsep(&str, " ");
if (*tok)
rc = parse_nidrange(tok, nidlist);
}
kfree(orig);
if (rc)
cfs_free_nidlist(nidlist);
else if (list_empty(nidlist))
rc = -EINVAL;
return rc;
}
EXPORT_SYMBOL(cfs_parse_nidlist);
static int
match_nidmask(const struct lnet_nid *nid, struct nidmask *nm,
struct netstrfns *nf)
{
__be32 addr[4] = { nid->nid_addr[0], nid->nid_addr[1],
nid->nid_addr[2], nid->nid_addr[3] };
__be32 *netmask, *netaddr;
if (!nf->nf_match_netmask)
return 0;
if (nid_is_nid4(nid) && nm->nm_family == AF_INET) {
netmask = (__be32 *)&nm->nm_netmask.ipv4.s_addr;
netaddr = (__be32 *)&nm->nm_netaddr.ipv4.s_addr;
} else if (!nid_is_nid4(nid) && nm->nm_family == AF_INET6) {
netmask = (__be32 *)&nm->nm_netmask.ipv6.s6_addr;
netaddr = (__be32 *)&nm->nm_netaddr.ipv6.s6_addr;
} else {
return 0;
}
return nf->nf_match_netmask(addr, NID_ADDR_BYTES(nid), netmask,
netaddr);
}
/**
* cfs_match_nid() - Matches a nid (@nid) against the compiled list of
* nidranges (@nidlist).
* @nid: NID to match
* @nidlist: Compiled list of nidranges
*
* see cfs_parse_nidlist()
*
* Return:
* * %1 on match
* * %0 otherwises
*/
int cfs_match_nid(const struct lnet_nid *nid, struct list_head *nidlist)
{
struct nidrange *nr;
struct nidmask *nm;
struct addrrange *ar;
list_for_each_entry(nr, nidlist, nr_link) {
if (nr->nr_netstrfns->nf_type != nid->nid_type)
continue;
if (nr->nr_netnum != be16_to_cpu(nid->nid_num))
continue;
if (nr->nr_all)
return 1;
list_for_each_entry(nm, &nr->nr_nidmasks, nm_link)
if (match_nidmask(nid, nm, nr->nr_netstrfns))
return 1;
list_for_each_entry(ar, &nr->nr_addrranges, ar_link)
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_match_nid);
/**
* cfs_print_network() - Print the network part of the nidrange @nr into the
* specified @buffer.
* @buffer: Buffer holding network part of nidrange [out]
* @count: Max lenght to print
* @nr: nidrange
*
* Return number of characters written
*/
static int
cfs_print_network(char *buffer, int count, struct nidrange *nr)
{
struct netstrfns *nf = nr->nr_netstrfns;
if (nr->nr_netnum == 0)
return scnprintf(buffer, count, "@%s", nf->nf_name);
else
return scnprintf(buffer, count, "@%s%u",
nf->nf_name, nr->nr_netnum);
}
/**
* cfs_print_addrranges() - Print a list of addrrange (@addrranges) into the
* specified @buffer.
* @buffer: Buffer holding the addrrange
* @count: Max length to print
* @addrranges: list of addrrange
* @nr: nidrange
*
* Print a list of addrrange (@addrranges) into the specified @buffer.
* At max @count characters can be printed into @buffer.
*
* Return number of characters written
*/
static int
cfs_print_addrranges(char *buffer, int count, struct list_head *addrranges,
struct nidrange *nr)
{
int i = 0;
struct addrrange *ar;
struct netstrfns *nf = nr->nr_netstrfns;
list_for_each_entry(ar, addrranges, ar_link) {
if (i != 0)
i += scnprintf(buffer + i, count - i, " ");
i += nf->nf_print_addrlist(buffer + i, count - i,
&ar->ar_numaddr_ranges);
i += cfs_print_network(buffer + i, count - i, nr);
}
return i;
}
static int
print_nidmask(char *buffer, int count, struct nidmask *nm, struct nidrange *nr,
bool omit_prefix)
{
int i = 0;
struct sockaddr_storage sa = {};
u8 max;
/* parse_nidmask() ensures nm_family is set to either AF_INET
* or AF_INET6
*/
sa.ss_family = nm->nm_family;
if (nm->nm_family == AF_INET) {
memcpy(&((struct sockaddr_in *)(&sa))->sin_addr.s_addr,
&nm->nm_addr.ipv4, sizeof(struct in_addr));
max = 32;
} else {
memcpy(&((struct sockaddr_in6 *)(&sa))->sin6_addr.s6_addr,
&nm->nm_addr.ipv6, sizeof(struct in6_addr));
max = 128;
}
i += rpc_ntop((struct sockaddr *)&sa, buffer + i, count - i);
if (nm->nm_prefix_len < max && !omit_prefix)
i += scnprintf(buffer + i, count - i, "/%u",
nm->nm_prefix_len);
i += cfs_print_network(buffer + i, count - i, nr);
return i;
}
static int
cfs_print_nidmasks(char *buffer, int count, struct list_head *nidmasks,
struct nidrange *nr)
{
int i = 0;
struct nidmask *nm;
list_for_each_entry(nm, nidmasks, nm_link) {
if (i != 0)
i += scnprintf(buffer + i, count - i, " ");
i += print_nidmask(buffer + i, count - i, nm, nr, false);
}
return i;
}
/**
* cfs_print_nidlist() - Print list of @nidranges into the specified @buffer.
* @buffer: buffer holding list of @nidranges
* @count: Max characters can be printed into @buffer.
* @nidlist: Nidranges are separated by a space character.
*
* Return number of characters written
*/
int cfs_print_nidlist(char *buffer, int count, struct list_head *nidlist)
{
int i = 0;
struct nidrange *nr;
bool need_space = false;
if (count <= 0)
return 0;
list_for_each_entry(nr, nidlist, nr_link) {
if (i != 0)
i += scnprintf(buffer + i, count - i, " ");
if (nr->nr_all) {
LASSERT(list_empty(&nr->nr_addrranges));
LASSERT(list_empty(&nr->nr_nidmasks));
i += scnprintf(buffer + i, count - i, "*");
i += cfs_print_network(buffer + i, count - i, nr);
continue;
}
if (!list_empty(&nr->nr_nidmasks)) {
i += cfs_print_nidmasks(buffer + i, count - i,
&nr->nr_nidmasks, nr);
need_space = true;
}
if (!list_empty(&nr->nr_addrranges)) {
if (need_space)
i += scnprintf(buffer + i, count - i, " ");
i += cfs_print_addrranges(buffer + i, count - i,
&nr->nr_addrranges, nr);
}
need_space = false;
}
return i;
}
EXPORT_SYMBOL(cfs_print_nidlist);
/* Caller should provide a nidlist with a single nidmask */
u8
cfs_nidmask_get_length(struct list_head *nidlist)
{
struct nidrange *nr;
struct nidmask *nm;
u8 len = 0;
list_for_each_entry(nr, nidlist, nr_link) {
list_for_each_entry(nm, &nr->nr_nidmasks, nm_link) {
if (len)
return 0;
len = nm->nm_prefix_len;
}
}
return len;
}
EXPORT_SYMBOL(cfs_nidmask_get_length);
/* Caller should provide a nidlist with a single nidmask */
int
cfs_nidmask_get_base_nidstr(char *buf, int count, struct list_head *nidlist)
{
struct nidrange *nr;
struct nidmask *nm;
bool found = false;
list_for_each_entry(nr, nidlist, nr_link) {
list_for_each_entry(nm, &nr->nr_nidmasks, nm_link) {
if (found)
return -EINVAL;
print_nidmask(buf, count, nm, nr, true);
found = true;
}
}
return 0;
}
EXPORT_SYMBOL(cfs_nidmask_get_base_nidstr);
static int
libcfs_lo_str2addr(const char *str, int nob, __u32 *addr)
{
*addr = 0;
return 1;
}
static void
libcfs_ip_addr2str(__u32 addr, char *str, size_t size)
{
snprintf(str, size, "%u.%u.%u.%u",
(addr >> 24) & 0xff, (addr >> 16) & 0xff,
(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
* I initialise the %n variable to the expected length. If sscanf sets it;
* fine, if it doesn't, then the scan ended at the end of the string, which is
* fine too :) */
static int
libcfs_ip_str2addr(const char *str, int nob, __u32 *addr)
{
unsigned int a;
unsigned int b;
unsigned int c;
unsigned int d;
int n = nob; /* XscanfX */
/* numeric IP? */
if (sscanf(str, "%u.%u.%u.%u%n", &a, &b, &c, &d, &n) >= 4 &&
n == nob &&
(a & ~0xff) == 0 && (b & ~0xff) == 0 &&
(c & ~0xff) == 0 && (d & ~0xff) == 0) {
*addr = ((a<<24)|(b<<16)|(c<<8)|d);
return 1;
}
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_ignored, struct list_head *list)
{
struct cfs_expr_list *el;
int rc = 0;
int i = 0;
str = strim(str);
while (rc == 0 && str) {
char *res;
res = strsep(&str, ".");
res = strim(res);
if (!*res) {
rc = -EINVAL;
} else if ((rc = cfs_expr_list_parse(res, strlen(res),
0, 255, &el)) == 0) {
list_add_tail(&el->el_link, list);
i++;
}
}
if (rc == 0 && i == 4)
return 0;
cfs_expr_list_free_list(list);
return rc ?: -EINVAL;
}
/**
* cfs_range_expr_print() - Print range expression @expr into specified @buffer
* @buffer: buffer holding list of @expr
* @count: Max characters can be printed into @buffer.
* @expr: range expression list
* @bracketed: if %true, expression does not need additional brackets.
*
* Return 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;
}
/**
* cfs_expr_list_print() - Print a list of range expressions
* @buffer: Buffer holding range expression for print
* @count: Max length to print
* @expr_list: Range expression
*
* Print a list of range expressions (@expr_list) into specified @buffer.
* If the list contains several expressions, separate them with comma
* and surround the list with brackets.
*
* Returns 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;
list_for_each_entry(expr, &expr_list->el_exprs, re_link)
numexprs++;
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
libcfs_ip_addr_range_print(char *buffer, int count, struct list_head *list)
{
int i = 0, j = 0;
struct cfs_expr_list *el;
list_for_each_entry(el, list, el_link) {
LASSERT(j++ < 4);
if (i != 0)
i += scnprintf(buffer + i, count - i, ".");
i += cfs_expr_list_print(buffer + i, count - i, el);
}
return i;
}
/**
* cfs_ip_addr_match() - Matches address (@addr) against address set encoded
* in @list.
* @addr: IP address to be checked
* @list: List contains parsed IP address
*
* Return:
* * %1 if @addr matches
* * %0 otherwise
*/
int
cfs_ip_addr_match(__u32 addr, struct list_head *list)
{
struct cfs_expr_list *el;
int i = 0;
list_for_each_entry_reverse(el, list, el_link) {
if (!cfs_expr_list_match(addr & 0xff, el))
return 0;
addr >>= 8;
i++;
}
return i == 4;
}
/**
* libcfs_ip_in_netmask() - Matches address (@addr) against the netmask encoded
* in @netmask and @netaddr.
* @addr: IP address to be checked
* @asize: Size of @addr
* @netmask: Netmask
* @netaddr: Network address
*
* Return:
* * %1 if @addr matches
* * %0 otherwise
*/
int
libcfs_ip_in_netmask(const __be32 *addr, size_t asize, const __be32 *netmask,
const __be32 *netaddr)
{
if (asize == 4) {
struct in_addr nid_addr, masked_addr;
memcpy(&nid_addr.s_addr, addr, asize);
masked_addr.s_addr = nid_addr.s_addr &
(*(struct in_addr *)netmask).s_addr;
return memcmp(&masked_addr, netaddr, sizeof(masked_addr)) == 0;
} else if (asize == 16) {
struct in6_addr nid_addr, masked_addr;
int i;
memcpy(&nid_addr.s6_addr, addr, asize);
for (i = 0; i < 16; i++)
masked_addr.s6_addr[i] =
nid_addr.s6_addr[i] &
(*(struct in6_addr *)netmask).s6_addr[i];
return memcmp(&masked_addr, netaddr, sizeof(masked_addr)) == 0;
}
return 0;
}
/**
* libcfs_decnum_addr2str() - Print the network part of the nidrange @nr into
* the specified buffer(@str)
* @addr: numeric address to be converted
* @str: Converted decimial string will be stored [out]
* @size: length of @str
*
* Returns number of characters written
*/
static void
libcfs_decnum_addr2str(__u32 addr, char *str, size_t size)
{
snprintf(str, size, "%u", addr);
}
static int
libcfs_num_str2addr(const char *str, int nob, __u32 *addr)
{
int n;
n = nob;
if (sscanf(str, "0x%x%n", addr, &n) >= 1 && n == nob)
return 1;
n = nob;
if (sscanf(str, "0X%x%n", addr, &n) >= 1 && n == nob)
return 1;
n = nob;
if (sscanf(str, "%u%n", addr, &n) >= 1 && n == nob)
return 1;
return 0;
}
/**
* libcfs_num_parse() - Nf_parse_addrlist method for networks using numeric
* addresses.
* @str: numeric address information
* @len: length of @str
* @list: Parsed to numeric address will be added [out]
*
* Examples of such networks are gm and elan.
*
* Return:
* * %0 if @str parsed to numeric address on success
* * %errno otherwise
*/
int
libcfs_num_parse(char *str, int len, struct list_head *list)
{
struct cfs_expr_list *el;
int rc;
rc = cfs_expr_list_parse(str, len, 0, MAX_NUMERIC_VALUE, &el);
if (rc == 0)
list_add_tail(&el->el_link, list);
return rc;
}
static int
libcfs_num_addr_range_print(char *buffer, int count, struct list_head *list)
{
int i = 0, j = 0;
struct cfs_expr_list *el;
list_for_each_entry(el, list, el_link) {
LASSERT(j++ < 1);
i += cfs_expr_list_print(buffer + i, count - i, el);
}
return i;
}
/*
* Nf_match_addr method for networks using numeric addresses
*
* \retval 1 on match
* \retval 0 otherwise
*/
static int
libcfs_num_match(__u32 addr, struct list_head *numaddr)
{
struct cfs_expr_list *el;
LASSERT(!list_empty(numaddr));
el = list_first_entry(numaddr, struct cfs_expr_list, el_link);
return cfs_expr_list_match(addr, el);
}
static struct netstrfns libcfs_netstrfns[] = {
{
.nf_type = LOLND,
.nf_name = "lo",
.nf_modname = "klolnd",
.nf_addr2str = libcfs_decnum_addr2str,
.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_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_match_netmask = libcfs_ip_in_netmask
},
{ .nf_type = O2IBLND,
.nf_name = "o2ib",
.nf_modname = "ko2iblnd",
.nf_addr2str = libcfs_ip_addr2str,
.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_match_netmask = libcfs_ip_in_netmask
},
{
.nf_type = GNILND,
.nf_name = "gni",
.nf_modname = "kgnilnd",
.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
},
{
.nf_type = GNIIPLND,
.nf_name = "gip",
.nf_modname = "kgnilnd",
.nf_addr2str = libcfs_ip_addr2str,
.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_type = PTL4LND,
.nf_name = "ptlf",
.nf_modname = "kptl4lnd",
.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
},
{
.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
},
{
.nf_type = EFALND,
.nf_name = "efa",
.nf_modname = "kefalnd",
.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_type = BXI3LND,
.nf_name = "bxi3f",
.nf_modname = "kbxi3lnd",
.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;
for (i = 0; i < libcfs_nnetstrfns; i++)
if (lnd == libcfs_netstrfns[i].nf_type)
return &libcfs_netstrfns[i];
return NULL;
}
static struct netstrfns *
libcfs_namenum2netstrfns(const char *name)
{
struct netstrfns *nf;
int i;
for (i = 0; i < libcfs_nnetstrfns; i++) {
nf = &libcfs_netstrfns[i];
if (!strncmp(name, nf->nf_name, strlen(nf->nf_name)))
return nf;
}
return NULL;
}
static struct netstrfns *
libcfs_name2netstrfns(const char *name)
{
int i;
for (i = 0; i < libcfs_nnetstrfns; i++)
if (!strcmp(libcfs_netstrfns[i].nf_name, name))
return &libcfs_netstrfns[i];
return NULL;
}
int
libcfs_isknown_lnd(__u32 lnd)
{
return libcfs_lnd2netstrfns(lnd) != NULL;
}
EXPORT_SYMBOL(libcfs_isknown_lnd);
char *
libcfs_lnd2modname(__u32 lnd)
{
struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
return (nf == NULL) ? NULL : nf->nf_modname;
}
EXPORT_SYMBOL(libcfs_lnd2modname);
int
libcfs_str2lnd(const char *str)
{
struct netstrfns *nf = libcfs_name2netstrfns(str);
if (nf != NULL)
return nf->nf_type;
return -ENXIO;
}
EXPORT_SYMBOL(libcfs_str2lnd);
char *
libcfs_lnd2str_r(__u32 lnd, char *buf, size_t buf_size)
{
struct netstrfns *nf;
nf = libcfs_lnd2netstrfns(lnd);
if (nf == NULL)
snprintf(buf, buf_size, "?%u?", lnd);
else
snprintf(buf, buf_size, "%s", nf->nf_name);
return buf;
}
EXPORT_SYMBOL(libcfs_lnd2str_r);
char *
libcfs_net2str_r(__u32 net, char *buf, size_t buf_size)
{
__u32 nnum = LNET_NETNUM(net);
__u32 lnd = LNET_NETTYP(net);
struct netstrfns *nf;
nf = libcfs_lnd2netstrfns(lnd);
if (nf == NULL)
snprintf(buf, buf_size, "<%u:%u>", lnd, nnum);
else if (nnum == 0)
snprintf(buf, buf_size, "%s", nf->nf_name);
else
snprintf(buf, buf_size, "%s%u", nf->nf_name, nnum);
return buf;
}
EXPORT_SYMBOL(libcfs_net2str_r);
char *
libcfs_nid2str_r(lnet_nid_t nid, char *buf, size_t buf_size)
{
__u32 addr = LNET_NIDADDR(nid);
__u32 net = LNET_NIDNET(nid);
__u32 nnum = LNET_NETNUM(net);
__u32 lnd = LNET_NETTYP(net);
struct netstrfns *nf;
if (nid == LNET_NID_ANY) {
strncpy(buf, "<?>", buf_size);
buf[buf_size - 1] = '\0';
return buf;
}
nf = libcfs_lnd2netstrfns(lnd);
if (nf == NULL) {
snprintf(buf, buf_size, "%x@<%u:%u>", addr, lnd, nnum);
} else {
size_t addr_len;
nf->nf_addr2str(addr, 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);
}
return buf;
}
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)
{
struct netstrfns *nf = NULL;
int nob;
unsigned int netnum;
int i;
for (i = 0; i < libcfs_nnetstrfns; i++) {
nf = &libcfs_netstrfns[i];
if (!strncmp(str, nf->nf_name, strlen(nf->nf_name)))
break;
}
if (i == libcfs_nnetstrfns)
return NULL;
nob = strlen(nf->nf_name);
if (strlen(str) == (unsigned int)nob) {
netnum = 0;
} else {
if (nf->nf_type == LOLND) /* net number not allowed */
return NULL;
str += nob;
i = strlen(str);
if (sscanf(str, "%u%n", &netnum, &i) < 1 ||
i != (int)strlen(str))
return NULL;
}
*net = LNET_MKNET(nf->nf_type, netnum);
return nf;
}
__u32
libcfs_str2net(const char *str)
{
__u32 net;
if (libcfs_str2net_internal(str, &net) != NULL)
return net;
return LNET_NET_ANY;
}
EXPORT_SYMBOL(libcfs_str2net);
lnet_nid_t
libcfs_str2nid(const char *str)
{
const char *sep = strchr(str, '@');
struct netstrfns *nf;
__u32 net;
__u32 addr;
if (sep != NULL) {
nf = libcfs_str2net_internal(sep + 1, &net);
if (nf == NULL)
return LNET_NID_ANY;
} else {
sep = str + strlen(str);
net = LNET_MKNET(SOCKLND, 0);
nf = libcfs_lnd2netstrfns(SOCKLND);
LASSERT(nf != NULL);
}
if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
return LNET_NID_ANY;
return LNET_MKNID(net, addr);
}
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)
{
char *str = libcfs_next_nidstring();
if (id.pid == LNET_PID_ANY) {
snprintf(str, LNET_NIDSTR_SIZE,
"LNET_PID_ANY-%s", libcfs_nid2str(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_nid2str(id.nid));
return str;
}
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)
{
if (!strcmp(str, "*")) {
*nidp = LNET_NID_ANY;
return 1;
}
*nidp = libcfs_str2nid(str);
return *nidp != LNET_NID_ANY;
}
EXPORT_SYMBOL(libcfs_str2anynid);
int
libcfs_stranynid(struct lnet_nid *nid, const char *str)
{
if (!strcmp(str, "*")) {
*nid = LNET_ANY_NID;
return 1;
}
if (libcfs_strnid(nid, str))
*nid = LNET_ANY_NID;
return !LNET_NID_IS_ANY(nid);
}
EXPORT_SYMBOL(libcfs_stranynid);
