Merge branch 'net-smc-small-features' (77ec3a0e) · Commits · 戴 / test

net/smc/af_smc.c

+34 −5

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@
		#include <net/sock.h>
		#include <net/tcp.h>
		#include <net/smc.h>
		#include <asm/ioctls.h>

		#include "smc.h"
		#include "smc_clc.h"
		@@ -294,6 +295,7 @@ static void smc_copy_sock_settings_to_smc(struct smc_sock *smc)

		static int smc_clnt_conf_first_link(struct smc_sock *smc)
		{
		struct net *net = sock_net(smc->clcsock->sk);
		struct smc_link_group *lgr = smc->conn.lgr;
		struct smc_link *link;
		int rest;
		@@ -353,7 +355,7 @@ static int smc_clnt_conf_first_link(struct smc_sock *smc)
		if (rc < 0)
		return SMC_CLC_DECL_TCL;

		link->state = SMC_LNK_ACTIVE;
		smc_llc_link_active(link, net->ipv4.sysctl_tcp_keepalive_time);

		return 0;
		}
		@@ -715,6 +717,7 @@ void smc_close_non_accepted(struct sock *sk)

		static int smc_serv_conf_first_link(struct smc_sock *smc)
		{
		struct net *net = sock_net(smc->clcsock->sk);
		struct smc_link_group *lgr = smc->conn.lgr;
		struct smc_link *link;
		int rest;
		@@ -769,7 +772,7 @@ static int smc_serv_conf_first_link(struct smc_sock *smc)
		return rc;
		}

		link->state = SMC_LNK_ACTIVE;
		smc_llc_link_active(link, net->ipv4.sysctl_tcp_keepalive_time);

		return 0;
		}
		@@ -1387,12 +1390,38 @@ static int smc_ioctl(struct socket *sock, unsigned int cmd,
		unsigned long arg)
		{
		struct smc_sock *smc;
		int answ;

		smc = smc_sk(sock->sk);
		if (smc->use_fallback)
		if (smc->use_fallback) {
		if (!smc->clcsock)
		return -EBADF;
		return smc->clcsock->ops->ioctl(smc->clcsock, cmd, arg);
		else
		return sock_no_ioctl(sock, cmd, arg);
		}
		switch (cmd) {
		case SIOCINQ: /* same as FIONREAD */
		if (smc->sk.sk_state == SMC_LISTEN)
		return -EINVAL;
		answ = atomic_read(&smc->conn.bytes_to_rcv);
		break;
		case SIOCOUTQ:
		/* output queue size (not send + not acked) */
		if (smc->sk.sk_state == SMC_LISTEN)
		return -EINVAL;
		answ = smc->conn.sndbuf_size -
		atomic_read(&smc->conn.sndbuf_space);
		break;
		case SIOCOUTQNSD:
		/* output queue size (not send only) */
		if (smc->sk.sk_state == SMC_LISTEN)
		return -EINVAL;
		answ = smc_tx_prepared_sends(&smc->conn);
		break;
		default:
		return -ENOIOCTLCMD;
		}

		return put_user(answ, (int __user *)arg);
		}

		static ssize_t smc_sendpage(struct socket sock, struct page page,

net/smc/smc_core.c

+25 −3

Original line number	Diff line number	Diff line
		@@ -310,6 +310,7 @@ static void smc_lgr_free_bufs(struct smc_link_group *lgr)
		/* remove a link group */
		void smc_lgr_free(struct smc_link_group *lgr)
		{
		smc_llc_link_flush(&lgr->lnk[SMC_SINGLE_LINK]);
		smc_lgr_free_bufs(lgr);
		smc_link_clear(&lgr->lnk[SMC_SINGLE_LINK]);
		kfree(lgr);
		@@ -332,6 +333,7 @@ void smc_lgr_terminate(struct smc_link_group *lgr)
		struct rb_node *node;

		smc_lgr_forget(lgr);
		smc_llc_link_inactive(&lgr->lnk[SMC_SINGLE_LINK]);

		write_lock_bh(&lgr->conns_lock);
		node = rb_first(&lgr->conns_all);
		@@ -358,7 +360,8 @@ void smc_lgr_terminate(struct smc_link_group *lgr)
		static int smc_vlan_by_tcpsk(struct socket clcsock, unsigned short vlan_id)
		{
		struct dst_entry *dst = sk_dst_get(clcsock->sk);
		int rc = 0;
		struct net_device *ndev;
		int i, nest_lvl, rc = 0;

		*vlan_id = 0;
		if (!dst) {
		@@ -370,8 +373,27 @@ static int smc_vlan_by_tcpsk(struct socket clcsock, unsigned short vlan_id)
		goto out_rel;
		}

		if (is_vlan_dev(dst->dev))
		*vlan_id = vlan_dev_vlan_id(dst->dev);
		ndev = dst->dev;
		if (is_vlan_dev(ndev)) {
		*vlan_id = vlan_dev_vlan_id(ndev);
		goto out_rel;
		}

		rtnl_lock();
		nest_lvl = dev_get_nest_level(ndev);
		for (i = 0; i < nest_lvl; i++) {
		struct list_head *lower = &ndev->adj_list.lower;

		if (list_empty(lower))
		break;
		lower = lower->next;
		ndev = (struct net_device *)netdev_lower_get_next(ndev, &lower);
		if (is_vlan_dev(ndev)) {
		*vlan_id = vlan_dev_vlan_id(ndev);
		break;
		}
		}
		rtnl_unlock();

		out_rel:
		dst_release(dst);

net/smc/smc_core.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -79,6 +79,7 @@ struct smc_link {
		dma_addr_t wr_rx_dma_addr; /* DMA address of wr_rx_bufs */
		u64 wr_rx_id; /* seq # of last recv WR */
		u32 wr_rx_cnt; /* number of WR recv buffers */
		unsigned long wr_rx_tstamp; /* jiffies when last buf rx */

		struct ib_reg_wr wr_reg; /* WR register memory region */
		wait_queue_head_t wr_reg_wait; /* wait for wr_reg result */
		@@ -101,6 +102,9 @@ struct smc_link {
		int llc_confirm_resp_rc; /* rc from conf_resp msg */
		struct completion llc_add; /* wait for rx of add link */
		struct completion llc_add_resp; /* wait for rx of add link rsp*/
		struct delayed_work llc_testlink_wrk; /* testlink worker */
		struct completion llc_testlink_resp; /* wait for rx of testlink */
		int llc_testlink_time; /* testlink interval */
		};

		/* For now we just allow one parallel link per link group. The SMC protocol

net/smc/smc_diag.c

+30 −9

Original line number	Diff line number	Diff line
		@@ -38,17 +38,27 @@ static void smc_diag_msg_common_fill(struct smc_diag_msg r, struct sock sk)
		{
		struct smc_sock *smc = smc_sk(sk);

		r->diag_family = sk->sk_family;
		if (!smc->clcsock)
		return;
		r->id.idiag_sport = htons(smc->clcsock->sk->sk_num);
		r->id.idiag_dport = smc->clcsock->sk->sk_dport;
		r->id.idiag_if = smc->clcsock->sk->sk_bound_dev_if;
		sock_diag_save_cookie(sk, r->id.idiag_cookie);
		if (sk->sk_protocol == SMCPROTO_SMC) {
		r->diag_family = PF_INET;
		memset(&r->id.idiag_src, 0, sizeof(r->id.idiag_src));
		memset(&r->id.idiag_dst, 0, sizeof(r->id.idiag_dst));
		r->id.idiag_src[0] = smc->clcsock->sk->sk_rcv_saddr;
		r->id.idiag_dst[0] = smc->clcsock->sk->sk_daddr;
		#if IS_ENABLED(CONFIG_IPV6)
		} else if (sk->sk_protocol == SMCPROTO_SMC6) {
		r->diag_family = PF_INET6;
		memcpy(&r->id.idiag_src, &smc->clcsock->sk->sk_v6_rcv_saddr,
		sizeof(smc->clcsock->sk->sk_v6_rcv_saddr));
		memcpy(&r->id.idiag_dst, &smc->clcsock->sk->sk_v6_daddr,
		sizeof(smc->clcsock->sk->sk_v6_daddr));
		#endif
		}
		}

		static int smc_diag_msg_attrs_fill(struct sock sk, struct sk_buff skb,
		@@ -153,7 +163,8 @@ errout:
		return -EMSGSIZE;
		}

		static int smc_diag_dump(struct sk_buff skb, struct netlink_callback cb)
		static int smc_diag_dump_proto(struct proto prot, struct sk_buff skb,
		struct netlink_callback *cb)
		{
		struct net *net = sock_net(skb->sk);
		struct nlattr *bc = NULL;
		@@ -161,8 +172,8 @@ static int smc_diag_dump(struct sk_buff skb, struct netlink_callback cb)
		struct sock *sk;
		int rc = 0;

		read_lock(&smc_proto.h.smc_hash->lock);
		head = &smc_proto.h.smc_hash->ht;
		read_lock(&prot->h.smc_hash->lock);
		head = &prot->h.smc_hash->ht;
		if (hlist_empty(head))
		goto out;

		@@ -175,7 +186,17 @@ static int smc_diag_dump(struct sk_buff skb, struct netlink_callback cb)
		}

		out:
		read_unlock(&smc_proto.h.smc_hash->lock);
		read_unlock(&prot->h.smc_hash->lock);
		return rc;
		}

		static int smc_diag_dump(struct sk_buff skb, struct netlink_callback cb)
		{
		int rc = 0;

		rc = smc_diag_dump_proto(&smc_proto, skb, cb);
		if (!rc)
		rc = smc_diag_dump_proto(&smc_proto6, skb, cb);
		return rc;
		}

net/smc/smc_llc.c

+61 −1

Original line number	Diff line number	Diff line
		@@ -397,7 +397,8 @@ static void smc_llc_rx_test_link(struct smc_link *link,
		struct smc_llc_msg_test_link *llc)
		{
		if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
		/* unused as long as we don't send this type of msg */
		if (link->state == SMC_LNK_ACTIVE)
		complete(&link->llc_testlink_resp);
		} else {
		smc_llc_send_test_link(link, llc->user_data, SMC_LLC_RESP);
		}
		@@ -502,6 +503,65 @@ static void smc_llc_rx_handler(struct ib_wc wc, void buf)
		}
		}

		/*************************** worker **************************************/

		static void smc_llc_testlink_work(struct work_struct *work)
		{
		struct smc_link *link = container_of(to_delayed_work(work),
		struct smc_link, llc_testlink_wrk);
		unsigned long next_interval;
		struct smc_link_group *lgr;
		unsigned long expire_time;
		u8 user_data[16] = { 0 };
		int rc;

		lgr = container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
		if (link->state != SMC_LNK_ACTIVE)
		return; /* don't reschedule worker */
		expire_time = link->wr_rx_tstamp + link->llc_testlink_time;
		if (time_is_after_jiffies(expire_time)) {
		next_interval = expire_time - jiffies;
		goto out;
		}
		reinit_completion(&link->llc_testlink_resp);
		smc_llc_send_test_link(link, user_data, SMC_LLC_REQ);
		/* receive TEST LINK response over RoCE fabric */
		rc = wait_for_completion_interruptible_timeout(&link->llc_testlink_resp,
		SMC_LLC_WAIT_TIME);
		if (rc <= 0) {
		smc_lgr_terminate(lgr);
		return;
		}
		next_interval = link->llc_testlink_time;
		out:
		schedule_delayed_work(&link->llc_testlink_wrk, next_interval);
		}

		void smc_llc_link_active(struct smc_link *link, int testlink_time)
		{
		init_completion(&link->llc_testlink_resp);
		INIT_DELAYED_WORK(&link->llc_testlink_wrk, smc_llc_testlink_work);
		link->state = SMC_LNK_ACTIVE;
		if (testlink_time) {
		link->llc_testlink_time = testlink_time * HZ;
		schedule_delayed_work(&link->llc_testlink_wrk,
		link->llc_testlink_time);
		}
		}

		/* called in tasklet context */
		void smc_llc_link_inactive(struct smc_link *link)
		{
		link->state = SMC_LNK_INACTIVE;
		cancel_delayed_work(&link->llc_testlink_wrk);
		}

		/* called in worker context */
		void smc_llc_link_flush(struct smc_link *link)
		{
		cancel_delayed_work_sync(&link->llc_testlink_wrk);
		}

		/*************************** init, exit, misc ****************************/

		static struct smc_wr_rx_handler smc_llc_rx_handlers[] = {

Admin message