nidstrings.c

lustre 1.6.5 source code

                return 1;

        n = nob;
        if (sscanf(str, "%u%n", addr, &n) >= 1 && n == nob)
                return 1;

        return 0;
}

struct netstrfns *
libcfs_lnd2netstrfns(int lnd)
{
        int    i;

        if (lnd >= 0)
                for (i = 0; i < libcfs_nnetstrfns; i++)
                        if (lnd == libcfs_netstrfns[i].nf_type)
                                return &libcfs_netstrfns[i];

        return NULL;
}

struct netstrfns *
libcfs_name2netstrfns(const char *name)
{
        int    i;

        for (i = 0; i < libcfs_nnetstrfns; i++)
                if (libcfs_netstrfns[i].nf_type >= 0 &&
                    !strcmp(libcfs_netstrfns[i].nf_name, name))
                        return &libcfs_netstrfns[i];

        return NULL;
}

int
libcfs_isknown_lnd(int type)
{
        return libcfs_lnd2netstrfns(type) != NULL;
}

char *
libcfs_lnd2modname(int lnd)
{
        struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);

        return (nf == NULL) ? NULL : nf->nf_modname;
}

char *
libcfs_lnd2str(int lnd)
{
        char           *str;
        struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);

        if (nf != NULL)
                return nf->nf_name;

        str = libcfs_next_nidstring();
        snprintf(str, LNET_NIDSTR_SIZE, "?%u?", lnd);
        return str;
}

int
libcfs_str2lnd(const char *str)
{
        struct netstrfns *nf = libcfs_name2netstrfns(str);

        if (nf != NULL)
                return nf->nf_type;

        return -1;
}

char *
libcfs_net2str(__u32 net)
{
        int               lnd = LNET_NETTYP(net);
        int               num = LNET_NETNUM(net);
        struct netstrfns *nf  = libcfs_lnd2netstrfns(lnd);
        char             *str = libcfs_next_nidstring();

        if (nf == NULL)
                snprintf(str, LNET_NIDSTR_SIZE, "<%u:%u>", lnd, num);
        else if (num == 0)
                snprintf(str, LNET_NIDSTR_SIZE, "%s", nf->nf_name);
        else
                snprintf(str, LNET_NIDSTR_SIZE, "%s%u", nf->nf_name, num);

        return str;
}

char *
libcfs_nid2str(lnet_nid_t nid)
{
        __u32             addr = LNET_NIDADDR(nid);
        __u32             net = LNET_NIDNET(nid);
        int               lnd = LNET_NETTYP(net);
        int               nnum = LNET_NETNUM(net);
        struct netstrfns *nf;
        char             *str;
        int               nob;

        if (nid == LNET_NID_ANY)
                return "LNET_NID_ANY";

        nf = libcfs_lnd2netstrfns(lnd);
        str = libcfs_next_nidstring();

        if (nf == NULL)
                snprintf(str, LNET_NIDSTR_SIZE, "%x@<%u:%u>", addr, lnd, nnum);
        else {
                nf->nf_addr2str(addr, str);
                nob = strlen(str);
                if (nnum == 0)
                        snprintf(str + nob, LNET_NIDSTR_SIZE - nob, "@%s",
                                 nf->nf_name);
                else
                        snprintf(str + nob, LNET_NIDSTR_SIZE - nob, "@%s%u",
                                 nf->nf_name, nnum);
        }

        return str;
}

static struct netstrfns *
libcfs_str2net_internal(const char *str, __u32 *net)
{
        struct netstrfns *nf;
        int               nob;
        int               netnum;
        int               i;

        for (i = 0; i < libcfs_nnetstrfns; i++) {
                nf = &libcfs_netstrfns[i];
                if (nf->nf_type >= 0 &&
                    !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_NIDNET(LNET_NID_ANY);
}

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, sep - str, &addr))
                return LNET_NID_ANY;

        return LNET_MKNID(net, addr);
}

char *
libcfs_id2str(lnet_process_id_t 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;
}

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;
}

#ifdef __KERNEL__
void
libcfs_setnet0alias(int lnd)
{
        struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
        struct netstrfns *nf0 = &libcfs_netstrfns[libcfs_nnetstrfns - 1];

        /* Ghastly hack to allow LNET to inter-operate with portals.
         * NET type 0 becomes an alias for whatever local network we have, and
         * this assignment here means we can parse and print its NIDs */

        LASSERT (nf != NULL);
        LASSERT (nf0->nf_type < 0);

        nf0->nf_name = "zero";//nf->nf_name;
        nf0->nf_modname = nf->nf_modname;
        nf0->nf_addr2str = nf->nf_addr2str;
        nf0->nf_str2addr = nf->nf_str2addr;
        mb();
        nf0->nf_type = 0;
}

EXPORT_SYMBOL(libcfs_isknown_lnd);
EXPORT_SYMBOL(libcfs_lnd2modname);
EXPORT_SYMBOL(libcfs_lnd2str);
EXPORT_SYMBOL(libcfs_str2lnd);
EXPORT_SYMBOL(libcfs_net2str);
EXPORT_SYMBOL(libcfs_nid2str);
EXPORT_SYMBOL(libcfs_str2net);
EXPORT_SYMBOL(libcfs_str2nid);
EXPORT_SYMBOL(libcfs_id2str);
EXPORT_SYMBOL(libcfs_str2anynid);
EXPORT_SYMBOL(libcfs_setnet0alias);
#else  /* __KERNEL__ */
void
libcfs_setnet0alias(int lnd)
{
        LCONSOLE_ERROR_MSG(0x125, "Liblustre cannot interoperate with old "
                           "Portals.\nportals_compatibility must be set to "
                           "'none'.\n");
}
#endif