~hc/RK356X_SDK_RELEASE.git

..	..	@@ -14,6 +14,8 @@
14	14	#include <linux/inetdevice.h>
15	15	#include <linux/if_ether.h>
16	16	#include <linux/sched/signal.h>
	17	+#include <linux/utsname.h>
	18	+#include <linux/ctype.h>
17	19
18	20	#include <net/addrconf.h>
19	21	#include <net/sock.h>
..	..	@@ -27,19 +29,96 @@
27	29
28	30	#define SMCR_CLC_ACCEPT_CONFIRM_LEN 68
29	31	#define SMCD_CLC_ACCEPT_CONFIRM_LEN 48
	32	+#define SMCD_CLC_ACCEPT_CONFIRM_LEN_V2 78
	33	+#define SMC_CLC_RECV_BUF_LEN 100
30	34
31	35	/* eye catcher "SMCR" EBCDIC for CLC messages */
32	36	static const char SMC_EYECATCHER[4] = {'\xe2', '\xd4', '\xc3', '\xd9'};
33	37	/* eye catcher "SMCD" EBCDIC for CLC messages */
34	38	static const char SMCD_EYECATCHER[4] = {'\xe2', '\xd4', '\xc3', '\xc4'};
35	39
	40	+static u8 smc_hostname[SMC_MAX_HOSTNAME_LEN];
	41	+
	42	+/* check arriving CLC proposal */
	43	+static bool smc_clc_msg_prop_valid(struct smc_clc_msg_proposal *pclc)
	44	+{
	45	+ struct smc_clc_msg_proposal_prefix *pclc_prfx;
	46	+ struct smc_clc_smcd_v2_extension *smcd_v2_ext;
	47	+ struct smc_clc_msg_hdr *hdr = &pclc->hdr;
	48	+ struct smc_clc_v2_extension *v2_ext;
	49	+
	50	+ v2_ext = smc_get_clc_v2_ext(pclc);
	51	+ pclc_prfx = smc_clc_proposal_get_prefix(pclc);
	52	+ if (hdr->version == SMC_V1) {
	53	+ if (hdr->typev1 == SMC_TYPE_N)
	54	+ return false;
	55	+ if (ntohs(hdr->length) !=
	56	+ sizeof(*pclc) + ntohs(pclc->iparea_offset) +
	57	+ sizeof(*pclc_prfx) +
	58	+ pclc_prfx->ipv6_prefixes_cnt *
	59	+ sizeof(struct smc_clc_ipv6_prefix) +
	60	+ sizeof(struct smc_clc_msg_trail))
	61	+ return false;
	62	+ } else {
	63	+ if (ntohs(hdr->length) !=
	64	+ sizeof(*pclc) +
	65	+ sizeof(struct smc_clc_msg_smcd) +
	66	+ (hdr->typev1 != SMC_TYPE_N ?
	67	+ sizeof(*pclc_prfx) +
	68	+ pclc_prfx->ipv6_prefixes_cnt *
	69	+ sizeof(struct smc_clc_ipv6_prefix) : 0) +
	70	+ (hdr->typev2 != SMC_TYPE_N ?
	71	+ sizeof(*v2_ext) +
	72	+ v2_ext->hdr.eid_cnt * SMC_MAX_EID_LEN : 0) +
	73	+ (smcd_indicated(hdr->typev2) ?
	74	+ sizeof(smcd_v2_ext) + v2_ext->hdr.ism_gid_cnt
	75	+ sizeof(struct smc_clc_smcd_gid_chid) :
	76	+ 0) +
	77	+ sizeof(struct smc_clc_msg_trail))
	78	+ return false;
	79	+ }
	80	+ return true;
	81	+}
	82	+
	83	+/* check arriving CLC accept or confirm */
	84	+static bool
	85	+smc_clc_msg_acc_conf_valid(struct smc_clc_msg_accept_confirm_v2 *clc_v2)
	86	+{
	87	+ struct smc_clc_msg_hdr *hdr = &clc_v2->hdr;
	88	+
	89	+ if (hdr->typev1 != SMC_TYPE_R && hdr->typev1 != SMC_TYPE_D)
	90	+ return false;
	91	+ if (hdr->version == SMC_V1) {
	92	+ if ((hdr->typev1 == SMC_TYPE_R &&
	93	+ ntohs(hdr->length) != SMCR_CLC_ACCEPT_CONFIRM_LEN) \|\|
	94	+ (hdr->typev1 == SMC_TYPE_D &&
	95	+ ntohs(hdr->length) != SMCD_CLC_ACCEPT_CONFIRM_LEN))
	96	+ return false;
	97	+ } else {
	98	+ if (hdr->typev1 == SMC_TYPE_D &&
	99	+ ntohs(hdr->length) != SMCD_CLC_ACCEPT_CONFIRM_LEN_V2 &&
	100	+ (ntohs(hdr->length) != SMCD_CLC_ACCEPT_CONFIRM_LEN_V2 +
	101	+ sizeof(struct smc_clc_first_contact_ext)))
	102	+ return false;
	103	+ }
	104	+ return true;
	105	+}
	106	+
	107	+static void smc_clc_fill_fce(struct smc_clc_first_contact_ext fce, int len)
	108	+{
	109	+ memset(fce, 0, sizeof(*fce));
	110	+ fce->os_type = SMC_CLC_OS_LINUX;
	111	+ fce->release = SMC_RELEASE;
	112	+ memcpy(fce->hostname, smc_hostname, sizeof(smc_hostname));
	113	+ (len) += sizeof(fce);
	114	+}
	115	+
36	116	/* check if received message has a correct header length and contains valid
37	117	* heading and trailing eyecatchers
38	118	*/
39		-static bool smc_clc_msg_hdr_valid(struct smc_clc_msg_hdr *clcm)
	119	+static bool smc_clc_msg_hdr_valid(struct smc_clc_msg_hdr *clcm, bool check_trl)
40	120	{
41		- struct smc_clc_msg_proposal_prefix *pclc_prfx;
42		- struct smc_clc_msg_accept_confirm *clc;
	121	+ struct smc_clc_msg_accept_confirm_v2 *clc_v2;
43	122	struct smc_clc_msg_proposal *pclc;
44	123	struct smc_clc_msg_decline *dclc;
45	124	struct smc_clc_msg_trail *trl;
..	..	@@ -49,33 +128,20 @@
49	128	return false;
50	129	switch (clcm->type) {
51	130	case SMC_CLC_PROPOSAL:
52		- if (clcm->path != SMC_TYPE_R && clcm->path != SMC_TYPE_D &&
53		- clcm->path != SMC_TYPE_B)
54		- return false;
55	131	pclc = (struct smc_clc_msg_proposal *)clcm;
56		- pclc_prfx = smc_clc_proposal_get_prefix(pclc);
57		- if (ntohs(pclc->hdr.length) !=
58		- sizeof(*pclc) + ntohs(pclc->iparea_offset) +
59		- sizeof(*pclc_prfx) +
60		- pclc_prfx->ipv6_prefixes_cnt *
61		- sizeof(struct smc_clc_ipv6_prefix) +
62		- sizeof(*trl))
	132	+ if (!smc_clc_msg_prop_valid(pclc))
63	133	return false;
64	134	trl = (struct smc_clc_msg_trail *)
65	135	((u8 )pclc + ntohs(pclc->hdr.length) - sizeof(trl));
66	136	break;
67	137	case SMC_CLC_ACCEPT:
68	138	case SMC_CLC_CONFIRM:
69		- if (clcm->path != SMC_TYPE_R && clcm->path != SMC_TYPE_D)
70		- return false;
71		- clc = (struct smc_clc_msg_accept_confirm *)clcm;
72		- if ((clcm->path == SMC_TYPE_R &&
73		- ntohs(clc->hdr.length) != SMCR_CLC_ACCEPT_CONFIRM_LEN) \|\|
74		- (clcm->path == SMC_TYPE_D &&
75		- ntohs(clc->hdr.length) != SMCD_CLC_ACCEPT_CONFIRM_LEN))
	139	+ clc_v2 = (struct smc_clc_msg_accept_confirm_v2 *)clcm;
	140	+ if (!smc_clc_msg_acc_conf_valid(clc_v2))
76	141	return false;
77	142	trl = (struct smc_clc_msg_trail *)
78		- ((u8 )clc + ntohs(clc->hdr.length) - sizeof(trl));
	143	+ ((u8 *)clc_v2 + ntohs(clc_v2->hdr.length) -
	144	+ sizeof(*trl));
79	145	break;
80	146	case SMC_CLC_DECLINE:
81	147	dclc = (struct smc_clc_msg_decline *)clcm;
..	..	@@ -86,7 +152,8 @@
86	152	default:
87	153	return false;
88	154	}
89		- if (memcmp(trl->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER)) &&
	155	+ if (check_trl &&
	156	+ memcmp(trl->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER)) &&
90	157	memcmp(trl->eyecatcher, SMCD_EYECATCHER, sizeof(SMCD_EYECATCHER)))
91	158	return false;
92	159	return true;
..	..	@@ -97,17 +164,19 @@
97	164	struct smc_clc_msg_proposal_prefix *prop)
98	165	{
99	166	struct in_device *in_dev = __in_dev_get_rcu(dst->dev);
	167	+ const struct in_ifaddr *ifa;
100	168
101	169	if (!in_dev)
102	170	return -ENODEV;
103		- for_ifa(in_dev) {
	171	+
	172	+ in_dev_for_each_ifa_rcu(ifa, in_dev) {
104	173	if (!inet_ifa_match(ipv4, ifa))
105	174	continue;
106	175	prop->prefix_len = inet_mask_len(ifa->ifa_mask);
107	176	prop->outgoing_subnet = ifa->ifa_address & ifa->ifa_mask;
108	177	/* prop->ipv6_prefixes_cnt = 0; already done by memset before */
109	178	return 0;
110		- } endfor_ifa(in_dev);
	179	+ }
111	180	return -ENOENT;
112	181	}
113	182
..	..	@@ -152,7 +221,6 @@
152	221	struct sockaddr_in *addr;
153	222	int rc = -ENOENT;
154	223
155		- memset(prop, 0, sizeof(*prop));
156	224	if (!dst) {
157	225	rc = -ENOTCONN;
158	226	goto out;
..	..	@@ -191,14 +259,15 @@
191	259	struct smc_clc_msg_proposal_prefix *prop)
192	260	{
193	261	struct in_device *in_dev = __in_dev_get_rcu(dev);
	262	+ const struct in_ifaddr *ifa;
194	263
195	264	if (!in_dev)
196	265	return -ENODEV;
197		- for_ifa(in_dev) {
	266	+ in_dev_for_each_ifa_rcu(ifa, in_dev) {
198	267	if (prop->prefix_len == inet_mask_len(ifa->ifa_mask) &&
199	268	inet_ifa_match(prop->outgoing_subnet, ifa))
200	269	return 0;
201		- } endfor_ifa(in_dev);
	270	+ }
202	271
203	272	return -ENOENT;
204	273	}
..	..	@@ -266,7 +335,7 @@
266	335	* clcsock error, -EINTR, -ECONNRESET, -EPROTO otherwise.
267	336	*/
268	337	int smc_clc_wait_msg(struct smc_sock smc, void buf, int buflen,
269		- u8 expected_type)
	338	+ u8 expected_type, unsigned long timeout)
270	339	{
271	340	long rcvtimeo = smc->clcsock->sk->sk_rcvtimeo;
272	341	struct sock *clc_sk = smc->clcsock->sk;
..	..	@@ -274,7 +343,8 @@
274	343	struct msghdr msg = {NULL, 0};
275	344	int reason_code = 0;
276	345	struct kvec vec = {buf, buflen};
277		- int len, datlen;
	346	+ int len, datlen, recvlen;
	347	+ bool check_trl = true;
278	348	int krflags;
279	349
280	350	/* peek the first few bytes to determine length of data to receive
..	..	@@ -286,8 +356,8 @@
286	356	* sizeof(struct smc_clc_msg_hdr)
287	357	*/
288	358	krflags = MSG_PEEK \| MSG_WAITALL;
289		- smc->clcsock->sk->sk_rcvtimeo = CLC_WAIT_TIME;
290		- iov_iter_kvec(&msg.msg_iter, READ \| ITER_KVEC, &vec, 1,
	359	+ clc_sk->sk_rcvtimeo = timeout;
	360	+ iov_iter_kvec(&msg.msg_iter, READ, &vec, 1,
291	361	sizeof(struct smc_clc_msg_hdr));
292	362	len = sock_recvmsg(smc->clcsock, &msg, krflags);
293	363	if (signal_pending(current)) {
..	..	@@ -298,7 +368,11 @@
298	368	}
299	369	if (clc_sk->sk_err) {
300	370	reason_code = -clc_sk->sk_err;
301		- smc->sk.sk_err = clc_sk->sk_err;
	371	+ if (clc_sk->sk_err == EAGAIN &&
	372	+ expected_type == SMC_CLC_DECLINE)
	373	+ clc_sk->sk_err = 0; /* reset for fallback usage */
	374	+ else
	375	+ smc->sk.sk_err = clc_sk->sk_err;
302	376	goto out;
303	377	}
304	378	if (!len) { /* peer has performed orderly shutdown */
..	..	@@ -307,16 +381,14 @@
307	381	goto out;
308	382	}
309	383	if (len < 0) {
310		- smc->sk.sk_err = -len;
	384	+ if (len != -EAGAIN \|\| expected_type != SMC_CLC_DECLINE)
	385	+ smc->sk.sk_err = -len;
311	386	reason_code = len;
312	387	goto out;
313	388	}
314	389	datlen = ntohs(clcm->length);
315	390	if ((len < sizeof(struct smc_clc_msg_hdr)) \|\|
316		- (datlen > buflen) \|\|
317		- (clcm->version != SMC_CLC_V1) \|\|
318		- (clcm->path != SMC_TYPE_R && clcm->path != SMC_TYPE_D &&
319		- clcm->path != SMC_TYPE_B) \|\|
	391	+ (clcm->version < SMC_V1) \|\|
320	392	((clcm->type != SMC_CLC_DECLINE) &&
321	393	(clcm->type != expected_type))) {
322	394	smc->sk.sk_err = EPROTO;
..	..	@@ -326,13 +398,32 @@
326	398
327	399	/* receive the complete CLC message */
328	400	memset(&msg, 0, sizeof(struct msghdr));
329		- iov_iter_kvec(&msg.msg_iter, READ \| ITER_KVEC, &vec, 1, datlen);
	401	+ if (datlen > buflen) {
	402	+ check_trl = false;
	403	+ recvlen = buflen;
	404	+ } else {
	405	+ recvlen = datlen;
	406	+ }
	407	+ iov_iter_kvec(&msg.msg_iter, READ, &vec, 1, recvlen);
330	408	krflags = MSG_WAITALL;
331	409	len = sock_recvmsg(smc->clcsock, &msg, krflags);
332		- if (len < datlen \|\| !smc_clc_msg_hdr_valid(clcm)) {
	410	+ if (len < recvlen \|\| !smc_clc_msg_hdr_valid(clcm, check_trl)) {
333	411	smc->sk.sk_err = EPROTO;
334	412	reason_code = -EPROTO;
335	413	goto out;
	414	+ }
	415	+ datlen -= len;
	416	+ while (datlen) {
	417	+ u8 tmp[SMC_CLC_RECV_BUF_LEN];
	418	+
	419	+ vec.iov_base = &tmp;
	420	+ vec.iov_len = SMC_CLC_RECV_BUF_LEN;
	421	+ /* receive remaining proposal message */
	422	+ recvlen = datlen > SMC_CLC_RECV_BUF_LEN ?
	423	+ SMC_CLC_RECV_BUF_LEN : datlen;
	424	+ iov_iter_kvec(&msg.msg_iter, READ, &vec, 1, recvlen);
	425	+ len = sock_recvmsg(smc->clcsock, &msg, krflags);
	426	+ datlen -= len;
336	427	}
337	428	if (clcm->type == SMC_CLC_DECLINE) {
338	429	struct smc_clc_msg_decline *dclc;
..	..	@@ -340,19 +431,20 @@
340	431	dclc = (struct smc_clc_msg_decline *)clcm;
341	432	reason_code = SMC_CLC_DECL_PEERDECL;
342	433	smc->peer_diagnosis = ntohl(dclc->peer_diagnosis);
343		- if (((struct smc_clc_msg_decline *)buf)->hdr.flag) {
	434	+ if (((struct smc_clc_msg_decline *)buf)->hdr.typev2 &
	435	+ SMC_FIRST_CONTACT_MASK) {
344	436	smc->conn.lgr->sync_err = 1;
345		- smc_lgr_terminate(smc->conn.lgr);
	437	+ smc_lgr_terminate_sched(smc->conn.lgr);
346	438	}
347	439	}
348	440
349	441	out:
350		- smc->clcsock->sk->sk_rcvtimeo = rcvtimeo;
	442	+ clc_sk->sk_rcvtimeo = rcvtimeo;
351	443	return reason_code;
352	444	}
353	445
354	446	/* send CLC DECLINE message across internal TCP socket */
355		-int smc_clc_send_decline(struct smc_sock *smc, u32 peer_diag_info)
	447	+int smc_clc_send_decline(struct smc_sock *smc, u32 peer_diag_info, u8 version)
356	448	{
357	449	struct smc_clc_msg_decline dclc;
358	450	struct msghdr msg;
..	..	@@ -363,9 +455,12 @@
363	455	memcpy(dclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
364	456	dclc.hdr.type = SMC_CLC_DECLINE;
365	457	dclc.hdr.length = htons(sizeof(struct smc_clc_msg_decline));
366		- dclc.hdr.version = SMC_CLC_V1;
367		- dclc.hdr.flag = (peer_diag_info == SMC_CLC_DECL_SYNCERR) ? 1 : 0;
368		- if (smc->conn.lgr && !smc->conn.lgr->is_smcd)
	458	+ dclc.hdr.version = version;
	459	+ dclc.os_type = version == SMC_V1 ? 0 : SMC_CLC_OS_LINUX;
	460	+ dclc.hdr.typev2 = (peer_diag_info == SMC_CLC_DECL_SYNCERR) ?
	461	+ SMC_FIRST_CONTACT_MASK : 0;
	462	+ if ((!smc->conn.lgr \|\| !smc->conn.lgr->is_smcd) &&
	463	+ smc_ib_is_valid_local_systemid())
369	464	memcpy(dclc.id_for_peer, local_systemid,
370	465	sizeof(local_systemid));
371	466	dclc.peer_diagnosis = htonl(peer_diag_info);
..	..	@@ -376,150 +471,280 @@
376	471	vec.iov_len = sizeof(struct smc_clc_msg_decline);
377	472	len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1,
378	473	sizeof(struct smc_clc_msg_decline));
379		- if (len < sizeof(struct smc_clc_msg_decline))
380		- smc->sk.sk_err = EPROTO;
381		- if (len < 0)
382		- smc->sk.sk_err = -len;
383		- return sock_error(&smc->sk);
	474	+ if (len < 0 \|\| len < sizeof(struct smc_clc_msg_decline))
	475	+ len = -EPROTO;
	476	+ return len > 0 ? 0 : len;
384	477	}
385	478
386	479	/* send CLC PROPOSAL message across internal TCP socket */
387		-int smc_clc_send_proposal(struct smc_sock *smc, int smc_type,
388		- struct smc_ib_device *ibdev, u8 ibport, u8 gid[],
389		- struct smcd_dev *ismdev)
	480	+int smc_clc_send_proposal(struct smc_sock smc, struct smc_init_info ini)
390	481	{
391		- struct smc_clc_ipv6_prefix ipv6_prfx[SMC_CLC_MAX_V6_PREFIX];
392		- struct smc_clc_msg_proposal_prefix pclc_prfx;
393		- struct smc_clc_msg_smcd pclc_smcd;
394		- struct smc_clc_msg_proposal pclc;
395		- struct smc_clc_msg_trail trl;
	482	+ struct smc_clc_smcd_v2_extension *smcd_v2_ext;
	483	+ struct smc_clc_msg_proposal_prefix *pclc_prfx;
	484	+ struct smc_clc_msg_proposal *pclc_base;
	485	+ struct smc_clc_smcd_gid_chid *gidchids;
	486	+ struct smc_clc_msg_proposal_area *pclc;
	487	+ struct smc_clc_ipv6_prefix *ipv6_prfx;
	488	+ struct smc_clc_v2_extension *v2_ext;
	489	+ struct smc_clc_msg_smcd *pclc_smcd;
	490	+ struct smc_clc_msg_trail *trl;
396	491	int len, i, plen, rc;
397	492	int reason_code = 0;
398		- struct kvec vec[5];
	493	+ struct kvec vec[8];
399	494	struct msghdr msg;
400	495
	496	+ pclc = kzalloc(sizeof(*pclc), GFP_KERNEL);
	497	+ if (!pclc)
	498	+ return -ENOMEM;
	499	+
	500	+ pclc_base = &pclc->pclc_base;
	501	+ pclc_smcd = &pclc->pclc_smcd;
	502	+ pclc_prfx = &pclc->pclc_prfx;
	503	+ ipv6_prfx = pclc->pclc_prfx_ipv6;
	504	+ v2_ext = &pclc->pclc_v2_ext;
	505	+ smcd_v2_ext = &pclc->pclc_smcd_v2_ext;
	506	+ gidchids = pclc->pclc_gidchids;
	507	+ trl = &pclc->pclc_trl;
	508	+
	509	+ pclc_base->hdr.version = SMC_V2;
	510	+ pclc_base->hdr.typev1 = ini->smc_type_v1;
	511	+ pclc_base->hdr.typev2 = ini->smc_type_v2;
	512	+ plen = sizeof(pclc_base) + sizeof(pclc_smcd) + sizeof(*trl);
	513	+
401	514	/* retrieve ip prefixes for CLC proposal msg */
402		- rc = smc_clc_prfx_set(smc->clcsock, &pclc_prfx, ipv6_prfx);
403		- if (rc)
404		- return SMC_CLC_DECL_CNFERR; /* configuration error */
	515	+ if (ini->smc_type_v1 != SMC_TYPE_N) {
	516	+ rc = smc_clc_prfx_set(smc->clcsock, pclc_prfx, ipv6_prfx);
	517	+ if (rc) {
	518	+ if (ini->smc_type_v2 == SMC_TYPE_N) {
	519	+ kfree(pclc);
	520	+ return SMC_CLC_DECL_CNFERR;
	521	+ }
	522	+ pclc_base->hdr.typev1 = SMC_TYPE_N;
	523	+ } else {
	524	+ pclc_base->iparea_offset = htons(sizeof(*pclc_smcd));
	525	+ plen += sizeof(*pclc_prfx) +
	526	+ pclc_prfx->ipv6_prefixes_cnt *
	527	+ sizeof(ipv6_prfx[0]);
	528	+ }
	529	+ }
	530	+
	531	+ /* build SMC Proposal CLC message */
	532	+ memcpy(pclc_base->hdr.eyecatcher, SMC_EYECATCHER,
	533	+ sizeof(SMC_EYECATCHER));
	534	+ pclc_base->hdr.type = SMC_CLC_PROPOSAL;
	535	+ if (smcr_indicated(ini->smc_type_v1)) {
	536	+ /* add SMC-R specifics */
	537	+ memcpy(pclc_base->lcl.id_for_peer, local_systemid,
	538	+ sizeof(local_systemid));
	539	+ memcpy(pclc_base->lcl.gid, ini->ib_gid, SMC_GID_SIZE);
	540	+ memcpy(pclc_base->lcl.mac, &ini->ib_dev->mac[ini->ib_port - 1],
	541	+ ETH_ALEN);
	542	+ }
	543	+ if (smcd_indicated(ini->smc_type_v1)) {
	544	+ /* add SMC-D specifics */
	545	+ if (ini->ism_dev[0]) {
	546	+ pclc_smcd->ism.gid = htonll(ini->ism_dev[0]->local_gid);
	547	+ pclc_smcd->ism.chid =
	548	+ htons(smc_ism_get_chid(ini->ism_dev[0]));
	549	+ }
	550	+ }
	551	+ if (ini->smc_type_v2 == SMC_TYPE_N) {
	552	+ pclc_smcd->v2_ext_offset = 0;
	553	+ } else {
	554	+ u16 v2_ext_offset;
	555	+ u8 *eid = NULL;
	556	+
	557	+ v2_ext_offset = sizeof(*pclc_smcd) -
	558	+ offsetofend(struct smc_clc_msg_smcd, v2_ext_offset);
	559	+ if (ini->smc_type_v1 != SMC_TYPE_N)
	560	+ v2_ext_offset += sizeof(*pclc_prfx) +
	561	+ pclc_prfx->ipv6_prefixes_cnt *
	562	+ sizeof(ipv6_prfx[0]);
	563	+ pclc_smcd->v2_ext_offset = htons(v2_ext_offset);
	564	+ v2_ext->hdr.eid_cnt = 0;
	565	+ v2_ext->hdr.ism_gid_cnt = ini->ism_offered_cnt;
	566	+ v2_ext->hdr.flag.release = SMC_RELEASE;
	567	+ v2_ext->hdr.flag.seid = 1;
	568	+ v2_ext->hdr.smcd_v2_ext_offset = htons(sizeof(*v2_ext) -
	569	+ offsetofend(struct smc_clnt_opts_area_hdr,
	570	+ smcd_v2_ext_offset) +
	571	+ v2_ext->hdr.eid_cnt * SMC_MAX_EID_LEN);
	572	+ if (ini->ism_dev[0])
	573	+ smc_ism_get_system_eid(ini->ism_dev[0], &eid);
	574	+ else
	575	+ smc_ism_get_system_eid(ini->ism_dev[1], &eid);
	576	+ if (eid)
	577	+ memcpy(smcd_v2_ext->system_eid, eid, SMC_MAX_EID_LEN);
	578	+ plen += sizeof(v2_ext) + sizeof(smcd_v2_ext);
	579	+ if (ini->ism_offered_cnt) {
	580	+ for (i = 1; i <= ini->ism_offered_cnt; i++) {
	581	+ gidchids[i - 1].gid =
	582	+ htonll(ini->ism_dev[i]->local_gid);
	583	+ gidchids[i - 1].chid =
	584	+ htons(smc_ism_get_chid(ini->ism_dev[i]));
	585	+ }
	586	+ plen += ini->ism_offered_cnt *
	587	+ sizeof(struct smc_clc_smcd_gid_chid);
	588	+ }
	589	+ }
	590	+ pclc_base->hdr.length = htons(plen);
	591	+ memcpy(trl->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
405	592
406	593	/* send SMC Proposal CLC message */
407		- plen = sizeof(pclc) + sizeof(pclc_prfx) +
408		- (pclc_prfx.ipv6_prefixes_cnt * sizeof(ipv6_prfx[0])) +
409		- sizeof(trl);
410		- memset(&pclc, 0, sizeof(pclc));
411		- memcpy(pclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
412		- pclc.hdr.type = SMC_CLC_PROPOSAL;
413		- pclc.hdr.version = SMC_CLC_V1; /* SMC version */
414		- pclc.hdr.path = smc_type;
415		- if (smc_type == SMC_TYPE_R \|\| smc_type == SMC_TYPE_B) {
416		- /* add SMC-R specifics */
417		- memcpy(pclc.lcl.id_for_peer, local_systemid,
418		- sizeof(local_systemid));
419		- memcpy(&pclc.lcl.gid, gid, SMC_GID_SIZE);
420		- memcpy(&pclc.lcl.mac, &ibdev->mac[ibport - 1], ETH_ALEN);
421		- pclc.iparea_offset = htons(0);
422		- }
423		- if (smc_type == SMC_TYPE_D \|\| smc_type == SMC_TYPE_B) {
424		- /* add SMC-D specifics */
425		- memset(&pclc_smcd, 0, sizeof(pclc_smcd));
426		- plen += sizeof(pclc_smcd);
427		- pclc.iparea_offset = htons(SMC_CLC_PROPOSAL_MAX_OFFSET);
428		- pclc_smcd.gid = ismdev->local_gid;
429		- }
430		- pclc.hdr.length = htons(plen);
431		-
432		- memcpy(trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
433	594	memset(&msg, 0, sizeof(msg));
434	595	i = 0;
435		- vec[i].iov_base = &pclc;
436		- vec[i++].iov_len = sizeof(pclc);
437		- if (smc_type == SMC_TYPE_D \|\| smc_type == SMC_TYPE_B) {
438		- vec[i].iov_base = &pclc_smcd;
439		- vec[i++].iov_len = sizeof(pclc_smcd);
	596	+ vec[i].iov_base = pclc_base;
	597	+ vec[i++].iov_len = sizeof(*pclc_base);
	598	+ vec[i].iov_base = pclc_smcd;
	599	+ vec[i++].iov_len = sizeof(*pclc_smcd);
	600	+ if (ini->smc_type_v1 != SMC_TYPE_N) {
	601	+ vec[i].iov_base = pclc_prfx;
	602	+ vec[i++].iov_len = sizeof(*pclc_prfx);
	603	+ if (pclc_prfx->ipv6_prefixes_cnt > 0) {
	604	+ vec[i].iov_base = ipv6_prfx;
	605	+ vec[i++].iov_len = pclc_prfx->ipv6_prefixes_cnt *
	606	+ sizeof(ipv6_prfx[0]);
	607	+ }
440	608	}
441		- vec[i].iov_base = &pclc_prfx;
442		- vec[i++].iov_len = sizeof(pclc_prfx);
443		- if (pclc_prfx.ipv6_prefixes_cnt > 0) {
444		- vec[i].iov_base = &ipv6_prfx[0];
445		- vec[i++].iov_len = pclc_prfx.ipv6_prefixes_cnt *
446		- sizeof(ipv6_prfx[0]);
	609	+ if (ini->smc_type_v2 != SMC_TYPE_N) {
	610	+ vec[i].iov_base = v2_ext;
	611	+ vec[i++].iov_len = sizeof(*v2_ext);
	612	+ vec[i].iov_base = smcd_v2_ext;
	613	+ vec[i++].iov_len = sizeof(*smcd_v2_ext);
	614	+ if (ini->ism_offered_cnt) {
	615	+ vec[i].iov_base = gidchids;
	616	+ vec[i++].iov_len = ini->ism_offered_cnt *
	617	+ sizeof(struct smc_clc_smcd_gid_chid);
	618	+ }
447	619	}
448		- vec[i].iov_base = &trl;
449		- vec[i++].iov_len = sizeof(trl);
	620	+ vec[i].iov_base = trl;
	621	+ vec[i++].iov_len = sizeof(*trl);
450	622	/* due to the few bytes needed for clc-handshake this cannot block */
451	623	len = kernel_sendmsg(smc->clcsock, &msg, vec, i, plen);
452	624	if (len < 0) {
453	625	smc->sk.sk_err = smc->clcsock->sk->sk_err;
454	626	reason_code = -smc->sk.sk_err;
455		- } else if (len < (int)sizeof(pclc)) {
	627	+ } else if (len < ntohs(pclc_base->hdr.length)) {
456	628	reason_code = -ENETUNREACH;
457	629	smc->sk.sk_err = -reason_code;
458	630	}
459	631
	632	+ kfree(pclc);
460	633	return reason_code;
461	634	}
462	635
463		-/* send CLC CONFIRM message across internal TCP socket */
464		-int smc_clc_send_confirm(struct smc_sock *smc)
	636	+/* build and send CLC CONFIRM / ACCEPT message */
	637	+static int smc_clc_send_confirm_accept(struct smc_sock *smc,
	638	+ struct smc_clc_msg_accept_confirm_v2 *clc_v2,
	639	+ int first_contact, u8 version)
465	640	{
466	641	struct smc_connection *conn = &smc->conn;
467		- struct smc_clc_msg_accept_confirm cclc;
468		- struct smc_link *link;
469		- int reason_code = 0;
	642	+ struct smc_clc_msg_accept_confirm *clc;
	643	+ struct smc_clc_first_contact_ext fce;
	644	+ struct smc_clc_msg_trail trl;
	645	+ struct kvec vec[3];
470	646	struct msghdr msg;
471		- struct kvec vec;
472		- int len;
	647	+ int i, len;
473	648
474	649	/* send SMC Confirm CLC msg */
475		- memset(&cclc, 0, sizeof(cclc));
476		- cclc.hdr.type = SMC_CLC_CONFIRM;
477		- cclc.hdr.version = SMC_CLC_V1; /* SMC version */
478		- if (smc->conn.lgr->is_smcd) {
	650	+ clc = (struct smc_clc_msg_accept_confirm *)clc_v2;
	651	+ clc->hdr.version = version; /* SMC version */
	652	+ if (first_contact)
	653	+ clc->hdr.typev2 \|= SMC_FIRST_CONTACT_MASK;
	654	+ if (conn->lgr->is_smcd) {
479	655	/* SMC-D specific settings */
480		- memcpy(cclc.hdr.eyecatcher, SMCD_EYECATCHER,
	656	+ memcpy(clc->hdr.eyecatcher, SMCD_EYECATCHER,
481	657	sizeof(SMCD_EYECATCHER));
482		- cclc.hdr.path = SMC_TYPE_D;
483		- cclc.hdr.length = htons(SMCD_CLC_ACCEPT_CONFIRM_LEN);
484		- cclc.gid = conn->lgr->smcd->local_gid;
485		- cclc.token = conn->rmb_desc->token;
486		- cclc.dmbe_size = conn->rmbe_size_short;
487		- cclc.dmbe_idx = 0;
488		- memcpy(&cclc.linkid, conn->lgr->id, SMC_LGR_ID_SIZE);
489		- memcpy(cclc.smcd_trl.eyecatcher, SMCD_EYECATCHER,
	658	+ clc->hdr.typev1 = SMC_TYPE_D;
	659	+ clc->d0.gid = conn->lgr->smcd->local_gid;
	660	+ clc->d0.token = conn->rmb_desc->token;
	661	+ clc->d0.dmbe_size = conn->rmbe_size_short;
	662	+ clc->d0.dmbe_idx = 0;
	663	+ memcpy(&clc->d0.linkid, conn->lgr->id, SMC_LGR_ID_SIZE);
	664	+ if (version == SMC_V1) {
	665	+ clc->hdr.length = htons(SMCD_CLC_ACCEPT_CONFIRM_LEN);
	666	+ } else {
	667	+ u8 *eid = NULL;
	668	+
	669	+ clc_v2->chid = htons(smc_ism_get_chid(conn->lgr->smcd));
	670	+ smc_ism_get_system_eid(conn->lgr->smcd, &eid);
	671	+ if (eid)
	672	+ memcpy(clc_v2->eid, eid, SMC_MAX_EID_LEN);
	673	+ len = SMCD_CLC_ACCEPT_CONFIRM_LEN_V2;
	674	+ if (first_contact)
	675	+ smc_clc_fill_fce(&fce, &len);
	676	+ clc_v2->hdr.length = htons(len);
	677	+ }
	678	+ memcpy(trl.eyecatcher, SMCD_EYECATCHER,
490	679	sizeof(SMCD_EYECATCHER));
491	680	} else {
	681	+ struct smc_link *link = conn->lnk;
	682	+
492	683	/* SMC-R specific settings */
493		- link = &conn->lgr->lnk[SMC_SINGLE_LINK];
494		- memcpy(cclc.hdr.eyecatcher, SMC_EYECATCHER,
	684	+ link = conn->lnk;
	685	+ memcpy(clc->hdr.eyecatcher, SMC_EYECATCHER,
495	686	sizeof(SMC_EYECATCHER));
496		- cclc.hdr.path = SMC_TYPE_R;
497		- cclc.hdr.length = htons(SMCR_CLC_ACCEPT_CONFIRM_LEN);
498		- memcpy(cclc.lcl.id_for_peer, local_systemid,
	687	+ clc->hdr.typev1 = SMC_TYPE_R;
	688	+ clc->hdr.length = htons(SMCR_CLC_ACCEPT_CONFIRM_LEN);
	689	+ memcpy(clc->r0.lcl.id_for_peer, local_systemid,
499	690	sizeof(local_systemid));
500		- memcpy(&cclc.lcl.gid, link->gid, SMC_GID_SIZE);
501		- memcpy(&cclc.lcl.mac, &link->smcibdev->mac[link->ibport - 1],
	691	+ memcpy(&clc->r0.lcl.gid, link->gid, SMC_GID_SIZE);
	692	+ memcpy(&clc->r0.lcl.mac, &link->smcibdev->mac[link->ibport - 1],
502	693	ETH_ALEN);
503		- hton24(cclc.qpn, link->roce_qp->qp_num);
504		- cclc.rmb_rkey =
505		- htonl(conn->rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey);
506		- cclc.rmbe_idx = 1; /* for now: 1 RMB = 1 RMBE */
507		- cclc.rmbe_alert_token = htonl(conn->alert_token_local);
508		- cclc.qp_mtu = min(link->path_mtu, link->peer_mtu);
509		- cclc.rmbe_size = conn->rmbe_size_short;
510		- cclc.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address
511		- (conn->rmb_desc->sgt[SMC_SINGLE_LINK].sgl));
512		- hton24(cclc.psn, link->psn_initial);
513		- memcpy(cclc.smcr_trl.eyecatcher, SMC_EYECATCHER,
514		- sizeof(SMC_EYECATCHER));
	694	+ hton24(clc->r0.qpn, link->roce_qp->qp_num);
	695	+ clc->r0.rmb_rkey =
	696	+ htonl(conn->rmb_desc->mr_rx[link->link_idx]->rkey);
	697	+ clc->r0.rmbe_idx = 1; /* for now: 1 RMB = 1 RMBE */
	698	+ clc->r0.rmbe_alert_token = htonl(conn->alert_token_local);
	699	+ switch (clc->hdr.type) {
	700	+ case SMC_CLC_ACCEPT:
	701	+ clc->r0.qp_mtu = link->path_mtu;
	702	+ break;
	703	+ case SMC_CLC_CONFIRM:
	704	+ clc->r0.qp_mtu = min(link->path_mtu, link->peer_mtu);
	705	+ break;
	706	+ }
	707	+ clc->r0.rmbe_size = conn->rmbe_size_short;
	708	+ clc->r0.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address
	709	+ (conn->rmb_desc->sgt[link->link_idx].sgl));
	710	+ hton24(clc->r0.psn, link->psn_initial);
	711	+ memcpy(trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
515	712	}
516	713
517	714	memset(&msg, 0, sizeof(msg));
518		- vec.iov_base = &cclc;
519		- vec.iov_len = ntohs(cclc.hdr.length);
520		- len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1,
521		- ntohs(cclc.hdr.length));
522		- if (len < ntohs(cclc.hdr.length)) {
	715	+ i = 0;
	716	+ vec[i].iov_base = clc_v2;
	717	+ if (version > SMC_V1)
	718	+ vec[i++].iov_len = SMCD_CLC_ACCEPT_CONFIRM_LEN_V2 - sizeof(trl);
	719	+ else
	720	+ vec[i++].iov_len = (clc->hdr.typev1 == SMC_TYPE_D ?
	721	+ SMCD_CLC_ACCEPT_CONFIRM_LEN :
	722	+ SMCR_CLC_ACCEPT_CONFIRM_LEN) -
	723	+ sizeof(trl);
	724	+ if (version > SMC_V1 && first_contact) {
	725	+ vec[i].iov_base = &fce;
	726	+ vec[i++].iov_len = sizeof(fce);
	727	+ }
	728	+ vec[i].iov_base = &trl;
	729	+ vec[i++].iov_len = sizeof(trl);
	730	+ return kernel_sendmsg(smc->clcsock, &msg, vec, 1,
	731	+ ntohs(clc->hdr.length));
	732	+}
	733	+
	734	+/* send CLC CONFIRM message across internal TCP socket */
	735	+int smc_clc_send_confirm(struct smc_sock *smc, bool clnt_first_contact,
	736	+ u8 version)
	737	+{
	738	+ struct smc_clc_msg_accept_confirm_v2 cclc_v2;
	739	+ int reason_code = 0;
	740	+ int len;
	741	+
	742	+ /* send SMC Confirm CLC msg */
	743	+ memset(&cclc_v2, 0, sizeof(cclc_v2));
	744	+ cclc_v2.hdr.type = SMC_CLC_CONFIRM;
	745	+ len = smc_clc_send_confirm_accept(smc, &cclc_v2, clnt_first_contact,
	746	+ version);
	747	+ if (len < ntohs(cclc_v2.hdr.length)) {
523	748	if (len >= 0) {
524	749	reason_code = -ENETUNREACH;
525	750	smc->sk.sk_err = -reason_code;
..	..	@@ -532,73 +757,28 @@
532	757	}
533	758
534	759	/* send CLC ACCEPT message across internal TCP socket */
535		-int smc_clc_send_accept(struct smc_sock *new_smc, int srv_first_contact)
	760	+int smc_clc_send_accept(struct smc_sock *new_smc, bool srv_first_contact,
	761	+ u8 version)
536	762	{
537		- struct smc_connection *conn = &new_smc->conn;
538		- struct smc_clc_msg_accept_confirm aclc;
539		- struct smc_link *link;
540		- struct msghdr msg;
541		- struct kvec vec;
542		- int rc = 0;
	763	+ struct smc_clc_msg_accept_confirm_v2 aclc_v2;
543	764	int len;
544	765
545		- memset(&aclc, 0, sizeof(aclc));
546		- aclc.hdr.type = SMC_CLC_ACCEPT;
547		- aclc.hdr.version = SMC_CLC_V1; /* SMC version */
548		- if (srv_first_contact)
549		- aclc.hdr.flag = 1;
	766	+ memset(&aclc_v2, 0, sizeof(aclc_v2));
	767	+ aclc_v2.hdr.type = SMC_CLC_ACCEPT;
	768	+ len = smc_clc_send_confirm_accept(new_smc, &aclc_v2, srv_first_contact,
	769	+ version);
	770	+ if (len < ntohs(aclc_v2.hdr.length))
	771	+ len = len >= 0 ? -EPROTO : -new_smc->clcsock->sk->sk_err;
550	772
551		- if (new_smc->conn.lgr->is_smcd) {
552		- /* SMC-D specific settings */
553		- aclc.hdr.length = htons(SMCD_CLC_ACCEPT_CONFIRM_LEN);
554		- memcpy(aclc.hdr.eyecatcher, SMCD_EYECATCHER,
555		- sizeof(SMCD_EYECATCHER));
556		- aclc.hdr.path = SMC_TYPE_D;
557		- aclc.gid = conn->lgr->smcd->local_gid;
558		- aclc.token = conn->rmb_desc->token;
559		- aclc.dmbe_size = conn->rmbe_size_short;
560		- aclc.dmbe_idx = 0;
561		- memcpy(&aclc.linkid, conn->lgr->id, SMC_LGR_ID_SIZE);
562		- memcpy(aclc.smcd_trl.eyecatcher, SMCD_EYECATCHER,
563		- sizeof(SMCD_EYECATCHER));
564		- } else {
565		- /* SMC-R specific settings */
566		- aclc.hdr.length = htons(SMCR_CLC_ACCEPT_CONFIRM_LEN);
567		- memcpy(aclc.hdr.eyecatcher, SMC_EYECATCHER,
568		- sizeof(SMC_EYECATCHER));
569		- aclc.hdr.path = SMC_TYPE_R;
570		- link = &conn->lgr->lnk[SMC_SINGLE_LINK];
571		- memcpy(aclc.lcl.id_for_peer, local_systemid,
572		- sizeof(local_systemid));
573		- memcpy(&aclc.lcl.gid, link->gid, SMC_GID_SIZE);
574		- memcpy(&aclc.lcl.mac, link->smcibdev->mac[link->ibport - 1],
575		- ETH_ALEN);
576		- hton24(aclc.qpn, link->roce_qp->qp_num);
577		- aclc.rmb_rkey =
578		- htonl(conn->rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey);
579		- aclc.rmbe_idx = 1; /* as long as 1 RMB = 1 RMBE */
580		- aclc.rmbe_alert_token = htonl(conn->alert_token_local);
581		- aclc.qp_mtu = link->path_mtu;
582		- aclc.rmbe_size = conn->rmbe_size_short,
583		- aclc.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address
584		- (conn->rmb_desc->sgt[SMC_SINGLE_LINK].sgl));
585		- hton24(aclc.psn, link->psn_initial);
586		- memcpy(aclc.smcr_trl.eyecatcher, SMC_EYECATCHER,
587		- sizeof(SMC_EYECATCHER));
588		- }
	773	+ return len > 0 ? 0 : len;
	774	+}
589	775
590		- memset(&msg, 0, sizeof(msg));
591		- vec.iov_base = &aclc;
592		- vec.iov_len = ntohs(aclc.hdr.length);
593		- len = kernel_sendmsg(new_smc->clcsock, &msg, &vec, 1,
594		- ntohs(aclc.hdr.length));
595		- if (len < ntohs(aclc.hdr.length)) {
596		- if (len >= 0)
597		- new_smc->sk.sk_err = EPROTO;
598		- else
599		- new_smc->sk.sk_err = new_smc->clcsock->sk->sk_err;
600		- rc = sock_error(&new_smc->sk);
601		- }
	776	+void __init smc_clc_init(void)
	777	+{
	778	+ struct new_utsname *u;
602	779
603		- return rc;
	780	+ memset(smc_hostname, _S, sizeof(smc_hostname)); /* ASCII blanks */
	781	+ u = utsname();
	782	+ memcpy(smc_hostname, u->nodename,
	783	+ min_t(size_t, strlen(u->nodename), sizeof(smc_hostname)));
604	784	}