Commit 6812baab authored by Thomas Richter's avatar Thomas Richter Committed by David S. Miller
Browse files

smc: establish pnet table management 



Connection creation with SMC-R starts through an internal
TCP-connection. The Ethernet interface for this TCP-connection is not
restricted to the Ethernet interface of a RoCE device. Any existing
Ethernet interface belonging to the same physical net can be used, as
long as there is a defined relation between the Ethernet interface and
some RoCE devices. This relation is defined with the help of an
identification string called "Physical Net ID" or short "pnet ID".
Information about defined pnet IDs and their related Ethernet
interfaces and RoCE devices is stored in the SMC-R pnet table.

A pnet table entry consists of the identifying pnet ID and the
associated network and IB device.
This patch adds pnet table configuration support using the
generic netlink message interface referring to network and IB device
by their names. Commands exist to add, delete, and display pnet table
entries, and to flush or display the entire pnet table.

There are cross-checks to verify whether the ethernet interfaces
or infiniband devices really exist in the system. If either device
is not available, the pnet ID entry is not created.
Loss of network devices and IB devices is also monitored;
a pnet ID entry is removed when an associated network or
IB device is removed.

Signed-off-by: default avatarThomas Richter <tmricht@linux.vnet.ibm.com>
Signed-off-by: default avatarUrsula Braun <ubraun@linux.vnet.ibm.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent a4cf0443

include/uapi/linux/smc.h

0 → 100644
+35 −0
Original line number Diff line number Diff line 
/*

 *  Shared Memory Communications over RDMA (SMC-R) and RoCE

 *

 *  Definitions for generic netlink based configuration of an SMC-R PNET table

 *

 *  Copyright IBM Corp. 2016

 *

 *  Author(s):  Thomas Richter <tmricht@linux.vnet.ibm.com>

 */



#ifndef _UAPI_LINUX_SMC_H_

#define _UAPI_LINUX_SMC_H_



/* Netlink SMC_PNETID attributes */

enum {

	SMC_PNETID_UNSPEC,

	SMC_PNETID_NAME,

	SMC_PNETID_ETHNAME,

	SMC_PNETID_IBNAME,

	SMC_PNETID_IBPORT,

	__SMC_PNETID_MAX,

	SMC_PNETID_MAX = __SMC_PNETID_MAX - 1

};



enum {				/* SMC PNET Table commands */

	SMC_PNETID_GET = 1,

	SMC_PNETID_ADD,

	SMC_PNETID_DEL,

	SMC_PNETID_FLUSH

};



#define SMCR_GENL_FAMILY_NAME		"SMC_PNETID"

#define SMCR_GENL_FAMILY_VERSION	1



#endif /* _UAPI_LINUX_SMC_H */

net/smc/Makefile

+1 −1
Original line number Diff line number Diff line 
obj-$(CONFIG_SMC)	+= smc.o

smc-y := af_smc.o smc_ib.o
 
smc-y := af_smc.o smc_pnet.o smc_ib.o

net/smc/af_smc.c

+9 −2
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 


#include "smc.h"

#include "smc_ib.h"

#include "smc_pnet.h"



static void smc_set_keepalive(struct sock *sk, int val)

{
@@ -586,10 +587,14 @@ static int __init smc_init(void) 
{

	int rc;



	rc = smc_pnet_init();

	if (rc)

		return rc;



	rc = proto_register(&smc_proto, 1);

	if (rc) {

		pr_err("%s: proto_register fails with %d\n", __func__, rc);

		goto out;

		goto out_pnet;

	}



	rc = sock_register(&smc_sock_family_ops);
@@ -610,7 +615,8 @@ out_sock: 
	sock_unregister(PF_SMC);

out_proto:

	proto_unregister(&smc_proto);

out:

out_pnet:

	smc_pnet_exit();

	return rc;

}
@@ -619,6 +625,7 @@ static void __exit smc_exit(void) 
	smc_ib_unregister_client();

	sock_unregister(PF_SMC);

	proto_unregister(&smc_proto);

	smc_pnet_exit();

}



module_init(smc_init);

net/smc/smc_ib.c

+2 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
#include <linux/random.h>

#include <rdma/ib_verbs.h>



#include "smc_pnet.h"

#include "smc_ib.h"

#include "smc.h"
@@ -123,6 +124,7 @@ static void smc_ib_remove_dev(struct ib_device *ibdev, void *client_data) 
	spin_lock(&smc_ib_devices.lock);

	list_del_init(&smcibdev->list); /* remove from smc_ib_devices */

	spin_unlock(&smc_ib_devices.lock);

	smc_pnet_remove_by_ibdev(smcibdev);

	kfree(smcibdev);

}

net/smc/smc_pnet.c

0 → 100644
+534 −0
Original line number Diff line number Diff line 
/*

 *  Shared Memory Communications over RDMA (SMC-R) and RoCE

 *

 *  Generic netlink support functions to configure an SMC-R PNET table

 *

 *  Copyright IBM Corp. 2016

 *

 *  Author(s):  Thomas Richter <tmricht@linux.vnet.ibm.com>

 */



#include <linux/module.h>

#include <linux/list.h>

#include <linux/ctype.h>

#include <net/netlink.h>

#include <net/genetlink.h>



#include <uapi/linux/if.h>

#include <uapi/linux/smc.h>



#include <rdma/ib_verbs.h>



#include "smc_pnet.h"

#include "smc_ib.h"



#define SMC_MAX_PNET_ID_LEN	16	/* Max. length of PNET id */



static struct nla_policy smc_pnet_policy[SMC_PNETID_MAX + 1] = {

	[SMC_PNETID_NAME] = {

		.type = NLA_NUL_STRING,

		.len = SMC_MAX_PNET_ID_LEN - 1

	},

	[SMC_PNETID_ETHNAME] = {

		.type = NLA_NUL_STRING,

		.len = IFNAMSIZ - 1

	},

	[SMC_PNETID_IBNAME] = {

		.type = NLA_NUL_STRING,

		.len = IB_DEVICE_NAME_MAX - 1

	},

	[SMC_PNETID_IBPORT] = { .type = NLA_U8 }

};



static struct genl_family smc_pnet_nl_family;



/**

 * struct smc_pnettable - SMC PNET table anchor

 * @lock: Lock for list action

 * @pnetlist: List of PNETIDs

 */

static struct smc_pnettable {

	rwlock_t lock;

	struct list_head pnetlist;

} smc_pnettable = {

	.pnetlist = LIST_HEAD_INIT(smc_pnettable.pnetlist),

	.lock = __RW_LOCK_UNLOCKED(smc_pnettable.lock)

};



/**

 * struct smc_pnetentry - pnet identifier name entry

 * @list: List node.

 * @pnet_name: Pnet identifier name

 * @ndev: pointer to network device.

 * @smcibdev: Pointer to IB device.

 */

struct smc_pnetentry {

	struct list_head list;

	char pnet_name[SMC_MAX_PNET_ID_LEN + 1];

	struct net_device *ndev;

	struct smc_ib_device *smcibdev;

	u8 ib_port;

};



/* Check if two RDMA device entries are identical. Use device name and port

 * number for comparison.

 */

static bool smc_pnet_same_ibname(struct smc_pnetentry *pnetelem, char *ibname,

				 u8 ibport)

{

	return pnetelem->ib_port == ibport &&

	       !strncmp(pnetelem->smcibdev->ibdev->name, ibname,

			sizeof(pnetelem->smcibdev->ibdev->name));

}



/* Find a pnetid in the pnet table.

 */

static struct smc_pnetentry *smc_pnet_find_pnetid(char *pnet_name)

{

	struct smc_pnetentry *pnetelem, *found_pnetelem = NULL;



	read_lock(&smc_pnettable.lock);

	list_for_each_entry(pnetelem, &smc_pnettable.pnetlist, list) {

		if (!strncmp(pnetelem->pnet_name, pnet_name,

			     sizeof(pnetelem->pnet_name))) {

			found_pnetelem = pnetelem;

			break;

		}

	}

	read_unlock(&smc_pnettable.lock);

	return found_pnetelem;

}



/* Remove a pnetid from the pnet table.

 */

static int smc_pnet_remove_by_pnetid(char *pnet_name)

{

	struct smc_pnetentry *pnetelem, *tmp_pe;

	int rc = -ENOENT;



	write_lock(&smc_pnettable.lock);

	list_for_each_entry_safe(pnetelem, tmp_pe, &smc_pnettable.pnetlist,

				 list) {

		if (!strncmp(pnetelem->pnet_name, pnet_name,

			     sizeof(pnetelem->pnet_name))) {

			list_del(&pnetelem->list);

			dev_put(pnetelem->ndev);

			kfree(pnetelem);

			rc = 0;

			break;

		}

	}

	write_unlock(&smc_pnettable.lock);

	return rc;

}



/* Remove a pnet entry mentioning a given network device from the pnet table.

 */

static int smc_pnet_remove_by_ndev(struct net_device *ndev)

{

	struct smc_pnetentry *pnetelem, *tmp_pe;

	int rc = -ENOENT;



	write_lock(&smc_pnettable.lock);

	list_for_each_entry_safe(pnetelem, tmp_pe, &smc_pnettable.pnetlist,

				 list) {

		if (pnetelem->ndev == ndev) {

			list_del(&pnetelem->list);

			dev_put(pnetelem->ndev);

			kfree(pnetelem);

			rc = 0;

			break;

		}

	}

	write_unlock(&smc_pnettable.lock);

	return rc;

}



/* Remove a pnet entry mentioning a given ib device from the pnet table.

 */

int smc_pnet_remove_by_ibdev(struct smc_ib_device *ibdev)

{

	struct smc_pnetentry *pnetelem, *tmp_pe;

	int rc = -ENOENT;



	write_lock(&smc_pnettable.lock);

	list_for_each_entry_safe(pnetelem, tmp_pe, &smc_pnettable.pnetlist,

				 list) {

		if (pnetelem->smcibdev == ibdev) {

			list_del(&pnetelem->list);

			dev_put(pnetelem->ndev);

			kfree(pnetelem);

			rc = 0;

			break;

		}

	}

	write_unlock(&smc_pnettable.lock);

	return rc;

}



/* Append a pnetid to the end of the pnet table if not already on this list.

 */

static int smc_pnet_enter(struct smc_pnetentry *new_pnetelem)

{

	struct smc_pnetentry *pnetelem;

	int rc = -EEXIST;



	write_lock(&smc_pnettable.lock);

	list_for_each_entry(pnetelem, &smc_pnettable.pnetlist, list) {

		if (!strncmp(pnetelem->pnet_name, new_pnetelem->pnet_name,

			     sizeof(new_pnetelem->pnet_name)) ||

		    !strncmp(pnetelem->ndev->name, new_pnetelem->ndev->name,

			     sizeof(new_pnetelem->ndev->name)) ||

		    smc_pnet_same_ibname(pnetelem,

					 new_pnetelem->smcibdev->ibdev->name,

					 new_pnetelem->ib_port))

			goto found;

	}

	list_add_tail(&new_pnetelem->list, &smc_pnettable.pnetlist);

	rc = 0;

found:

	write_unlock(&smc_pnettable.lock);

	return rc;

}



/* The limit for pnetid is 16 characters.

 * Valid characters should be (single-byte character set) a-z, A-Z, 0-9.

 * Lower case letters are converted to upper case.

 * Interior blanks should not be used.

 */

static bool smc_pnetid_valid(const char *pnet_name, char *pnetid)

{

	char *bf = skip_spaces(pnet_name);

	size_t len = strlen(bf);

	char *end = bf + len;



	if (!len)

		return false;

	while (--end >= bf && isspace(*end))

		;

	if (end - bf >= SMC_MAX_PNET_ID_LEN)

		return false;

	while (bf <= end) {

		if (!isalnum(*bf))

			return false;

		*pnetid++ = islower(*bf) ? toupper(*bf) : *bf;

		bf++;

	}

	*pnetid = '\0';

	return true;

}



/* Find an infiniband device by a given name. The device might not exist. */

struct smc_ib_device *smc_pnet_find_ib(char *ib_name)

{

	struct smc_ib_device *ibdev;



	spin_lock(&smc_ib_devices.lock);

	list_for_each_entry(ibdev, &smc_ib_devices.list, list) {

		if (!strncmp(ibdev->ibdev->name, ib_name,

			     sizeof(ibdev->ibdev->name))) {

			goto out;

		}

	}

	ibdev = NULL;

out:

	spin_unlock(&smc_ib_devices.lock);

	return ibdev;

}



/* Parse the supplied netlink attributes and fill a pnetentry structure.

 * For ethernet and infiniband device names verify that the devices exist.

 */

static int smc_pnet_fill_entry(struct net *net, struct smc_pnetentry *pnetelem,

			       struct nlattr *tb[])

{

	char *string, *ibname = NULL;

	int rc = 0;



	memset(pnetelem, 0, sizeof(*pnetelem));

	INIT_LIST_HEAD(&pnetelem->list);

	if (tb[SMC_PNETID_NAME]) {

		string = (char *)nla_data(tb[SMC_PNETID_NAME]);

		if (!smc_pnetid_valid(string, pnetelem->pnet_name)) {

			rc = -EINVAL;

			goto error;

		}

	}

	if (tb[SMC_PNETID_ETHNAME]) {

		string = (char *)nla_data(tb[SMC_PNETID_ETHNAME]);

		pnetelem->ndev = dev_get_by_name(net, string);

		if (!pnetelem->ndev)

			return -ENOENT;

	}

	if (tb[SMC_PNETID_IBNAME]) {

		ibname = (char *)nla_data(tb[SMC_PNETID_IBNAME]);

		ibname = strim(ibname);

		pnetelem->smcibdev = smc_pnet_find_ib(ibname);

		if (!pnetelem->smcibdev) {

			rc = -ENOENT;

			goto error;

		}

	}

	if (tb[SMC_PNETID_IBPORT]) {

		pnetelem->ib_port = nla_get_u8(tb[SMC_PNETID_IBPORT]);

		if (pnetelem->ib_port > SMC_MAX_PORTS) {

			rc = -EINVAL;

			goto error;

		}

	}

	return 0;



error:

	if (pnetelem->ndev)

		dev_put(pnetelem->ndev);

	return rc;

}



/* Convert an smc_pnetentry to a netlink attribute sequence */

static int smc_pnet_set_nla(struct sk_buff *msg, struct smc_pnetentry *pnetelem)

{

	if (nla_put_string(msg, SMC_PNETID_NAME, pnetelem->pnet_name) ||

	    nla_put_string(msg, SMC_PNETID_ETHNAME, pnetelem->ndev->name) ||

	    nla_put_string(msg, SMC_PNETID_IBNAME,

			   pnetelem->smcibdev->ibdev->name) ||

	    nla_put_u8(msg, SMC_PNETID_IBPORT, pnetelem->ib_port))

		return -1;

	return 0;

}



/* Retrieve one PNETID entry */

static int smc_pnet_get(struct sk_buff *skb, struct genl_info *info)

{

	struct smc_pnetentry *pnetelem;

	struct sk_buff *msg;

	void *hdr;

	int rc;



	pnetelem = smc_pnet_find_pnetid(

				(char *)nla_data(info->attrs[SMC_PNETID_NAME]));

	if (!pnetelem)

		return -ENOENT;

	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);

	if (!msg)

		return -ENOMEM;



	hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,

			  &smc_pnet_nl_family, 0, SMC_PNETID_GET);

	if (!hdr) {

		rc = -EMSGSIZE;

		goto err_out;

	}



	if (smc_pnet_set_nla(msg, pnetelem)) {

		rc = -ENOBUFS;

		goto err_out;

	}



	genlmsg_end(msg, hdr);

	return genlmsg_reply(msg, info);



err_out:

	nlmsg_free(msg);

	return rc;

}



static int smc_pnet_add(struct sk_buff *skb, struct genl_info *info)

{

	struct net *net = genl_info_net(info);

	struct smc_pnetentry *pnetelem;

	int rc;



	pnetelem = kzalloc(sizeof(*pnetelem), GFP_KERNEL);

	if (!pnetelem)

		return -ENOMEM;

	rc = smc_pnet_fill_entry(net, pnetelem, info->attrs);

	if (!rc)

		rc = smc_pnet_enter(pnetelem);

	if (rc) {

		kfree(pnetelem);

		return rc;

	}

	rc = smc_ib_remember_port_attr(pnetelem->smcibdev, pnetelem->ib_port);

	if (rc)

		smc_pnet_remove_by_pnetid(pnetelem->pnet_name);

	return rc;

}



static int smc_pnet_del(struct sk_buff *skb, struct genl_info *info)

{

	return smc_pnet_remove_by_pnetid(

				(char *)nla_data(info->attrs[SMC_PNETID_NAME]));

}



static int smc_pnet_dump_start(struct netlink_callback *cb)

{

	cb->args[0] = 0;

	return 0;

}



static int smc_pnet_dumpinfo(struct sk_buff *skb,

			     u32 portid, u32 seq, u32 flags,

			     struct smc_pnetentry *pnetelem)

{

	void *hdr;



	hdr = genlmsg_put(skb, portid, seq, &smc_pnet_nl_family,

			  flags, SMC_PNETID_GET);

	if (!hdr)

		return -ENOMEM;

	if (smc_pnet_set_nla(skb, pnetelem) < 0) {

		genlmsg_cancel(skb, hdr);

		return -EMSGSIZE;

	}

	genlmsg_end(skb, hdr);

	return 0;

}



static int smc_pnet_dump(struct sk_buff *skb, struct netlink_callback *cb)

{

	struct smc_pnetentry *pnetelem;

	int idx = 0;



	read_lock(&smc_pnettable.lock);

	list_for_each_entry(pnetelem, &smc_pnettable.pnetlist, list) {

		if (idx++ < cb->args[0])

			continue;

		if (smc_pnet_dumpinfo(skb, NETLINK_CB(cb->skb).portid,

				      cb->nlh->nlmsg_seq, NLM_F_MULTI,

				      pnetelem)) {

			--idx;

			break;

		}

	}

	cb->args[0] = idx;

	read_unlock(&smc_pnettable.lock);

	return skb->len;

}



/* Remove and delete all pnetids from pnet table.

 */

static int smc_pnet_flush(struct sk_buff *skb, struct genl_info *info)

{

	struct smc_pnetentry *pnetelem, *tmp_pe;



	write_lock(&smc_pnettable.lock);

	list_for_each_entry_safe(pnetelem, tmp_pe, &smc_pnettable.pnetlist,

				 list) {

		list_del(&pnetelem->list);

		dev_put(pnetelem->ndev);

		kfree(pnetelem);

	}

	write_unlock(&smc_pnettable.lock);

	return 0;

}



/* SMC_PNETID generic netlink operation definition */

static const struct genl_ops smc_pnet_ops[] = {

	{

		.cmd = SMC_PNETID_GET,

		.flags = GENL_ADMIN_PERM,

		.policy = smc_pnet_policy,

		.doit = smc_pnet_get,

		.dumpit = smc_pnet_dump,

		.start = smc_pnet_dump_start

	},

	{

		.cmd = SMC_PNETID_ADD,

		.flags = GENL_ADMIN_PERM,

		.policy = smc_pnet_policy,

		.doit = smc_pnet_add

	},

	{

		.cmd = SMC_PNETID_DEL,

		.flags = GENL_ADMIN_PERM,

		.policy = smc_pnet_policy,

		.doit = smc_pnet_del

	},

	{

		.cmd = SMC_PNETID_FLUSH,

		.flags = GENL_ADMIN_PERM,

		.policy = smc_pnet_policy,

		.doit = smc_pnet_flush

	}

};



/* SMC_PNETID family definition */

static struct genl_family smc_pnet_nl_family = {

	.hdrsize = 0,

	.name = SMCR_GENL_FAMILY_NAME,

	.version = SMCR_GENL_FAMILY_VERSION,

	.maxattr = SMC_PNETID_MAX,

	.netnsok = true,

	.module = THIS_MODULE,

	.ops = smc_pnet_ops,

	.n_ops =  ARRAY_SIZE(smc_pnet_ops)

};



static int smc_pnet_netdev_event(struct notifier_block *this,

				 unsigned long event, void *ptr)

{

	struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);



	switch (event) {

	case NETDEV_REBOOT:

	case NETDEV_UNREGISTER:

		smc_pnet_remove_by_ndev(event_dev);

	default:

		break;

	}

	return NOTIFY_DONE;

}



static struct notifier_block smc_netdev_notifier = {

	.notifier_call = smc_pnet_netdev_event

};



int __init smc_pnet_init(void)

{

	int rc;



	rc = genl_register_family(&smc_pnet_nl_family);

	if (rc)

		return rc;

	rc = register_netdevice_notifier(&smc_netdev_notifier);

	if (rc)

		genl_unregister_family(&smc_pnet_nl_family);

	return rc;

}



void smc_pnet_exit(void)

{

	smc_pnet_flush(NULL, NULL);

	unregister_netdevice_notifier(&smc_netdev_notifier);

	genl_unregister_family(&smc_pnet_nl_family);

}



/* PNET table analysis for a given sock:

 * determine ib_device and port belonging to used internal TCP socket

 * ethernet interface.

 */

void smc_pnet_find_roce_resource(struct sock *sk,

				 struct smc_ib_device **smcibdev, u8 *ibport)

{

	struct dst_entry *dst = sk_dst_get(sk);

	struct smc_pnetentry *pnetelem;



	*smcibdev = NULL;

	*ibport = 0;



	if (!dst)

		return;

	if (!dst->dev)

		goto out_rel;

	read_lock(&smc_pnettable.lock);

	list_for_each_entry(pnetelem, &smc_pnettable.pnetlist, list) {

		if (dst->dev == pnetelem->ndev) {

			*smcibdev = pnetelem->smcibdev;

			*ibport = pnetelem->ib_port;

			break;

		}

	}

	read_unlock(&smc_pnettable.lock);

out_rel:

	dst_release(dst);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE