smc_clc.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Shared Memory Communications over RDMA (SMC-R) and RoCE
  4. *
  5. * CLC (connection layer control) handshake over initial TCP socket to
  6. * prepare for RDMA traffic
  7. *
  8. * Copyright IBM Corp. 2016, 2018
  9. *
  10. * Author(s): Ursula Braun <ubraun@linux.vnet.ibm.com>
  11. */
  12. #include <linux/in.h>
  13. #include <linux/inetdevice.h>
  14. #include <linux/if_ether.h>
  15. #include <linux/sched/signal.h>
  16. #include <linux/utsname.h>
  17. #include <linux/ctype.h>
  18. #include <net/addrconf.h>
  19. #include <net/sock.h>
  20. #include <net/tcp.h>
  21. #include "smc.h"
  22. #include "smc_core.h"
  23. #include "smc_clc.h"
  24. #include "smc_ib.h"
  25. #include "smc_ism.h"
  26. #define SMCR_CLC_ACCEPT_CONFIRM_LEN 68
  27. #define SMCD_CLC_ACCEPT_CONFIRM_LEN 48
  28. #define SMCD_CLC_ACCEPT_CONFIRM_LEN_V2 78
  29. #define SMC_CLC_RECV_BUF_LEN 100
  30. /* eye catcher "SMCR" EBCDIC for CLC messages */
  31. static const char SMC_EYECATCHER[4] = {'\xe2', '\xd4', '\xc3', '\xd9'};
  32. /* eye catcher "SMCD" EBCDIC for CLC messages */
  33. static const char SMCD_EYECATCHER[4] = {'\xe2', '\xd4', '\xc3', '\xc4'};
  34. static u8 smc_hostname[SMC_MAX_HOSTNAME_LEN];
  35. /* check arriving CLC proposal */
  36. static bool smc_clc_msg_prop_valid(struct smc_clc_msg_proposal *pclc)
  37. {
  38. struct smc_clc_msg_proposal_prefix *pclc_prfx;
  39. struct smc_clc_smcd_v2_extension *smcd_v2_ext;
  40. struct smc_clc_msg_hdr *hdr = &pclc->hdr;
  41. struct smc_clc_v2_extension *v2_ext;
  42. v2_ext = smc_get_clc_v2_ext(pclc);
  43. pclc_prfx = smc_clc_proposal_get_prefix(pclc);
  44. if (hdr->version == SMC_V1) {
  45. if (hdr->typev1 == SMC_TYPE_N)
  46. return false;
  47. if (ntohs(hdr->length) !=
  48. sizeof(*pclc) + ntohs(pclc->iparea_offset) +
  49. sizeof(*pclc_prfx) +
  50. pclc_prfx->ipv6_prefixes_cnt *
  51. sizeof(struct smc_clc_ipv6_prefix) +
  52. sizeof(struct smc_clc_msg_trail))
  53. return false;
  54. } else {
  55. if (ntohs(hdr->length) !=
  56. sizeof(*pclc) +
  57. sizeof(struct smc_clc_msg_smcd) +
  58. (hdr->typev1 != SMC_TYPE_N ?
  59. sizeof(*pclc_prfx) +
  60. pclc_prfx->ipv6_prefixes_cnt *
  61. sizeof(struct smc_clc_ipv6_prefix) : 0) +
  62. (hdr->typev2 != SMC_TYPE_N ?
  63. sizeof(*v2_ext) +
  64. v2_ext->hdr.eid_cnt * SMC_MAX_EID_LEN : 0) +
  65. (smcd_indicated(hdr->typev2) ?
  66. sizeof(*smcd_v2_ext) + v2_ext->hdr.ism_gid_cnt *
  67. sizeof(struct smc_clc_smcd_gid_chid) :
  68. 0) +
  69. sizeof(struct smc_clc_msg_trail))
  70. return false;
  71. }
  72. return true;
  73. }
  74. /* check arriving CLC accept or confirm */
  75. static bool
  76. smc_clc_msg_acc_conf_valid(struct smc_clc_msg_accept_confirm_v2 *clc_v2)
  77. {
  78. struct smc_clc_msg_hdr *hdr = &clc_v2->hdr;
  79. if (hdr->typev1 != SMC_TYPE_R && hdr->typev1 != SMC_TYPE_D)
  80. return false;
  81. if (hdr->version == SMC_V1) {
  82. if ((hdr->typev1 == SMC_TYPE_R &&
  83. ntohs(hdr->length) != SMCR_CLC_ACCEPT_CONFIRM_LEN) ||
  84. (hdr->typev1 == SMC_TYPE_D &&
  85. ntohs(hdr->length) != SMCD_CLC_ACCEPT_CONFIRM_LEN))
  86. return false;
  87. } else {
  88. if (hdr->typev1 == SMC_TYPE_D &&
  89. ntohs(hdr->length) != SMCD_CLC_ACCEPT_CONFIRM_LEN_V2 &&
  90. (ntohs(hdr->length) != SMCD_CLC_ACCEPT_CONFIRM_LEN_V2 +
  91. sizeof(struct smc_clc_first_contact_ext)))
  92. return false;
  93. }
  94. return true;
  95. }
  96. static void smc_clc_fill_fce(struct smc_clc_first_contact_ext *fce, int *len)
  97. {
  98. memset(fce, 0, sizeof(*fce));
  99. fce->os_type = SMC_CLC_OS_LINUX;
  100. fce->release = SMC_RELEASE;
  101. memcpy(fce->hostname, smc_hostname, sizeof(smc_hostname));
  102. (*len) += sizeof(*fce);
  103. }
  104. /* check if received message has a correct header length and contains valid
  105. * heading and trailing eyecatchers
  106. */
  107. static bool smc_clc_msg_hdr_valid(struct smc_clc_msg_hdr *clcm, bool check_trl)
  108. {
  109. struct smc_clc_msg_accept_confirm_v2 *clc_v2;
  110. struct smc_clc_msg_proposal *pclc;
  111. struct smc_clc_msg_decline *dclc;
  112. struct smc_clc_msg_trail *trl;
  113. if (memcmp(clcm->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER)) &&
  114. memcmp(clcm->eyecatcher, SMCD_EYECATCHER, sizeof(SMCD_EYECATCHER)))
  115. return false;
  116. switch (clcm->type) {
  117. case SMC_CLC_PROPOSAL:
  118. pclc = (struct smc_clc_msg_proposal *)clcm;
  119. if (!smc_clc_msg_prop_valid(pclc))
  120. return false;
  121. trl = (struct smc_clc_msg_trail *)
  122. ((u8 *)pclc + ntohs(pclc->hdr.length) - sizeof(*trl));
  123. break;
  124. case SMC_CLC_ACCEPT:
  125. case SMC_CLC_CONFIRM:
  126. clc_v2 = (struct smc_clc_msg_accept_confirm_v2 *)clcm;
  127. if (!smc_clc_msg_acc_conf_valid(clc_v2))
  128. return false;
  129. trl = (struct smc_clc_msg_trail *)
  130. ((u8 *)clc_v2 + ntohs(clc_v2->hdr.length) -
  131. sizeof(*trl));
  132. break;
  133. case SMC_CLC_DECLINE:
  134. dclc = (struct smc_clc_msg_decline *)clcm;
  135. if (ntohs(dclc->hdr.length) != sizeof(*dclc))
  136. return false;
  137. trl = &dclc->trl;
  138. break;
  139. default:
  140. return false;
  141. }
  142. if (check_trl &&
  143. memcmp(trl->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER)) &&
  144. memcmp(trl->eyecatcher, SMCD_EYECATCHER, sizeof(SMCD_EYECATCHER)))
  145. return false;
  146. return true;
  147. }
  148. /* find ipv4 addr on device and get the prefix len, fill CLC proposal msg */
  149. static int smc_clc_prfx_set4_rcu(struct dst_entry *dst, __be32 ipv4,
  150. struct smc_clc_msg_proposal_prefix *prop)
  151. {
  152. struct in_device *in_dev = __in_dev_get_rcu(dst->dev);
  153. const struct in_ifaddr *ifa;
  154. if (!in_dev)
  155. return -ENODEV;
  156. in_dev_for_each_ifa_rcu(ifa, in_dev) {
  157. if (!inet_ifa_match(ipv4, ifa))
  158. continue;
  159. prop->prefix_len = inet_mask_len(ifa->ifa_mask);
  160. prop->outgoing_subnet = ifa->ifa_address & ifa->ifa_mask;
  161. /* prop->ipv6_prefixes_cnt = 0; already done by memset before */
  162. return 0;
  163. }
  164. return -ENOENT;
  165. }
  166. /* fill CLC proposal msg with ipv6 prefixes from device */
  167. static int smc_clc_prfx_set6_rcu(struct dst_entry *dst,
  168. struct smc_clc_msg_proposal_prefix *prop,
  169. struct smc_clc_ipv6_prefix *ipv6_prfx)
  170. {
  171. #if IS_ENABLED(CONFIG_IPV6)
  172. struct inet6_dev *in6_dev = __in6_dev_get(dst->dev);
  173. struct inet6_ifaddr *ifa;
  174. int cnt = 0;
  175. if (!in6_dev)
  176. return -ENODEV;
  177. /* use a maximum of 8 IPv6 prefixes from device */
  178. list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
  179. if (ipv6_addr_type(&ifa->addr) & IPV6_ADDR_LINKLOCAL)
  180. continue;
  181. ipv6_addr_prefix(&ipv6_prfx[cnt].prefix,
  182. &ifa->addr, ifa->prefix_len);
  183. ipv6_prfx[cnt].prefix_len = ifa->prefix_len;
  184. cnt++;
  185. if (cnt == SMC_CLC_MAX_V6_PREFIX)
  186. break;
  187. }
  188. prop->ipv6_prefixes_cnt = cnt;
  189. if (cnt)
  190. return 0;
  191. #endif
  192. return -ENOENT;
  193. }
  194. /* retrieve and set prefixes in CLC proposal msg */
  195. static int smc_clc_prfx_set(struct socket *clcsock,
  196. struct smc_clc_msg_proposal_prefix *prop,
  197. struct smc_clc_ipv6_prefix *ipv6_prfx)
  198. {
  199. struct dst_entry *dst = sk_dst_get(clcsock->sk);
  200. struct sockaddr_storage addrs;
  201. struct sockaddr_in6 *addr6;
  202. struct sockaddr_in *addr;
  203. int rc = -ENOENT;
  204. if (!dst) {
  205. rc = -ENOTCONN;
  206. goto out;
  207. }
  208. if (!dst->dev) {
  209. rc = -ENODEV;
  210. goto out_rel;
  211. }
  212. /* get address to which the internal TCP socket is bound */
  213. if (kernel_getsockname(clcsock, (struct sockaddr *)&addrs) < 0)
  214. goto out_rel;
  215. /* analyze IP specific data of net_device belonging to TCP socket */
  216. addr6 = (struct sockaddr_in6 *)&addrs;
  217. rcu_read_lock();
  218. if (addrs.ss_family == PF_INET) {
  219. /* IPv4 */
  220. addr = (struct sockaddr_in *)&addrs;
  221. rc = smc_clc_prfx_set4_rcu(dst, addr->sin_addr.s_addr, prop);
  222. } else if (ipv6_addr_v4mapped(&addr6->sin6_addr)) {
  223. /* mapped IPv4 address - peer is IPv4 only */
  224. rc = smc_clc_prfx_set4_rcu(dst, addr6->sin6_addr.s6_addr32[3],
  225. prop);
  226. } else {
  227. /* IPv6 */
  228. rc = smc_clc_prfx_set6_rcu(dst, prop, ipv6_prfx);
  229. }
  230. rcu_read_unlock();
  231. out_rel:
  232. dst_release(dst);
  233. out:
  234. return rc;
  235. }
  236. /* match ipv4 addrs of dev against addr in CLC proposal */
  237. static int smc_clc_prfx_match4_rcu(struct net_device *dev,
  238. struct smc_clc_msg_proposal_prefix *prop)
  239. {
  240. struct in_device *in_dev = __in_dev_get_rcu(dev);
  241. const struct in_ifaddr *ifa;
  242. if (!in_dev)
  243. return -ENODEV;
  244. in_dev_for_each_ifa_rcu(ifa, in_dev) {
  245. if (prop->prefix_len == inet_mask_len(ifa->ifa_mask) &&
  246. inet_ifa_match(prop->outgoing_subnet, ifa))
  247. return 0;
  248. }
  249. return -ENOENT;
  250. }
  251. /* match ipv6 addrs of dev against addrs in CLC proposal */
  252. static int smc_clc_prfx_match6_rcu(struct net_device *dev,
  253. struct smc_clc_msg_proposal_prefix *prop)
  254. {
  255. #if IS_ENABLED(CONFIG_IPV6)
  256. struct inet6_dev *in6_dev = __in6_dev_get(dev);
  257. struct smc_clc_ipv6_prefix *ipv6_prfx;
  258. struct inet6_ifaddr *ifa;
  259. int i, max;
  260. if (!in6_dev)
  261. return -ENODEV;
  262. /* ipv6 prefix list starts behind smc_clc_msg_proposal_prefix */
  263. ipv6_prfx = (struct smc_clc_ipv6_prefix *)((u8 *)prop + sizeof(*prop));
  264. max = min_t(u8, prop->ipv6_prefixes_cnt, SMC_CLC_MAX_V6_PREFIX);
  265. list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
  266. if (ipv6_addr_type(&ifa->addr) & IPV6_ADDR_LINKLOCAL)
  267. continue;
  268. for (i = 0; i < max; i++) {
  269. if (ifa->prefix_len == ipv6_prfx[i].prefix_len &&
  270. ipv6_prefix_equal(&ifa->addr, &ipv6_prfx[i].prefix,
  271. ifa->prefix_len))
  272. return 0;
  273. }
  274. }
  275. #endif
  276. return -ENOENT;
  277. }
  278. /* check if proposed prefixes match one of our device prefixes */
  279. int smc_clc_prfx_match(struct socket *clcsock,
  280. struct smc_clc_msg_proposal_prefix *prop)
  281. {
  282. struct dst_entry *dst = sk_dst_get(clcsock->sk);
  283. int rc;
  284. if (!dst) {
  285. rc = -ENOTCONN;
  286. goto out;
  287. }
  288. if (!dst->dev) {
  289. rc = -ENODEV;
  290. goto out_rel;
  291. }
  292. rcu_read_lock();
  293. if (!prop->ipv6_prefixes_cnt)
  294. rc = smc_clc_prfx_match4_rcu(dst->dev, prop);
  295. else
  296. rc = smc_clc_prfx_match6_rcu(dst->dev, prop);
  297. rcu_read_unlock();
  298. out_rel:
  299. dst_release(dst);
  300. out:
  301. return rc;
  302. }
  303. /* Wait for data on the tcp-socket, analyze received data
  304. * Returns:
  305. * 0 if success and it was not a decline that we received.
  306. * SMC_CLC_DECL_REPLY if decline received for fallback w/o another decl send.
  307. * clcsock error, -EINTR, -ECONNRESET, -EPROTO otherwise.
  308. */
  309. int smc_clc_wait_msg(struct smc_sock *smc, void *buf, int buflen,
  310. u8 expected_type, unsigned long timeout)
  311. {
  312. long rcvtimeo = smc->clcsock->sk->sk_rcvtimeo;
  313. struct sock *clc_sk = smc->clcsock->sk;
  314. struct smc_clc_msg_hdr *clcm = buf;
  315. struct msghdr msg = {NULL, 0};
  316. int reason_code = 0;
  317. struct kvec vec = {buf, buflen};
  318. int len, datlen, recvlen;
  319. bool check_trl = true;
  320. int krflags;
  321. /* peek the first few bytes to determine length of data to receive
  322. * so we don't consume any subsequent CLC message or payload data
  323. * in the TCP byte stream
  324. */
  325. /*
  326. * Caller must make sure that buflen is no less than
  327. * sizeof(struct smc_clc_msg_hdr)
  328. */
  329. krflags = MSG_PEEK | MSG_WAITALL;
  330. clc_sk->sk_rcvtimeo = timeout;
  331. iov_iter_kvec(&msg.msg_iter, READ, &vec, 1,
  332. sizeof(struct smc_clc_msg_hdr));
  333. len = sock_recvmsg(smc->clcsock, &msg, krflags);
  334. if (signal_pending(current)) {
  335. reason_code = -EINTR;
  336. clc_sk->sk_err = EINTR;
  337. smc->sk.sk_err = EINTR;
  338. goto out;
  339. }
  340. if (clc_sk->sk_err) {
  341. reason_code = -clc_sk->sk_err;
  342. if (clc_sk->sk_err == EAGAIN &&
  343. expected_type == SMC_CLC_DECLINE)
  344. clc_sk->sk_err = 0; /* reset for fallback usage */
  345. else
  346. smc->sk.sk_err = clc_sk->sk_err;
  347. goto out;
  348. }
  349. if (!len) { /* peer has performed orderly shutdown */
  350. smc->sk.sk_err = ECONNRESET;
  351. reason_code = -ECONNRESET;
  352. goto out;
  353. }
  354. if (len < 0) {
  355. if (len != -EAGAIN || expected_type != SMC_CLC_DECLINE)
  356. smc->sk.sk_err = -len;
  357. reason_code = len;
  358. goto out;
  359. }
  360. datlen = ntohs(clcm->length);
  361. if ((len < sizeof(struct smc_clc_msg_hdr)) ||
  362. (clcm->version < SMC_V1) ||
  363. ((clcm->type != SMC_CLC_DECLINE) &&
  364. (clcm->type != expected_type))) {
  365. smc->sk.sk_err = EPROTO;
  366. reason_code = -EPROTO;
  367. goto out;
  368. }
  369. /* receive the complete CLC message */
  370. memset(&msg, 0, sizeof(struct msghdr));
  371. if (datlen > buflen) {
  372. check_trl = false;
  373. recvlen = buflen;
  374. } else {
  375. recvlen = datlen;
  376. }
  377. iov_iter_kvec(&msg.msg_iter, READ, &vec, 1, recvlen);
  378. krflags = MSG_WAITALL;
  379. len = sock_recvmsg(smc->clcsock, &msg, krflags);
  380. if (len < recvlen || !smc_clc_msg_hdr_valid(clcm, check_trl)) {
  381. smc->sk.sk_err = EPROTO;
  382. reason_code = -EPROTO;
  383. goto out;
  384. }
  385. datlen -= len;
  386. while (datlen) {
  387. u8 tmp[SMC_CLC_RECV_BUF_LEN];
  388. vec.iov_base = &tmp;
  389. vec.iov_len = SMC_CLC_RECV_BUF_LEN;
  390. /* receive remaining proposal message */
  391. recvlen = datlen > SMC_CLC_RECV_BUF_LEN ?
  392. SMC_CLC_RECV_BUF_LEN : datlen;
  393. iov_iter_kvec(&msg.msg_iter, READ, &vec, 1, recvlen);
  394. len = sock_recvmsg(smc->clcsock, &msg, krflags);
  395. datlen -= len;
  396. }
  397. if (clcm->type == SMC_CLC_DECLINE) {
  398. struct smc_clc_msg_decline *dclc;
  399. dclc = (struct smc_clc_msg_decline *)clcm;
  400. reason_code = SMC_CLC_DECL_PEERDECL;
  401. smc->peer_diagnosis = ntohl(dclc->peer_diagnosis);
  402. if (((struct smc_clc_msg_decline *)buf)->hdr.typev2 &
  403. SMC_FIRST_CONTACT_MASK) {
  404. smc->conn.lgr->sync_err = 1;
  405. smc_lgr_terminate_sched(smc->conn.lgr);
  406. }
  407. }
  408. out:
  409. clc_sk->sk_rcvtimeo = rcvtimeo;
  410. return reason_code;
  411. }
  412. /* send CLC DECLINE message across internal TCP socket */
  413. int smc_clc_send_decline(struct smc_sock *smc, u32 peer_diag_info, u8 version)
  414. {
  415. struct smc_clc_msg_decline dclc;
  416. struct msghdr msg;
  417. struct kvec vec;
  418. int len;
  419. memset(&dclc, 0, sizeof(dclc));
  420. memcpy(dclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
  421. dclc.hdr.type = SMC_CLC_DECLINE;
  422. dclc.hdr.length = htons(sizeof(struct smc_clc_msg_decline));
  423. dclc.hdr.version = version;
  424. dclc.os_type = version == SMC_V1 ? 0 : SMC_CLC_OS_LINUX;
  425. dclc.hdr.typev2 = (peer_diag_info == SMC_CLC_DECL_SYNCERR) ?
  426. SMC_FIRST_CONTACT_MASK : 0;
  427. if ((!smc->conn.lgr || !smc->conn.lgr->is_smcd) &&
  428. smc_ib_is_valid_local_systemid())
  429. memcpy(dclc.id_for_peer, local_systemid,
  430. sizeof(local_systemid));
  431. dclc.peer_diagnosis = htonl(peer_diag_info);
  432. memcpy(dclc.trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
  433. memset(&msg, 0, sizeof(msg));
  434. vec.iov_base = &dclc;
  435. vec.iov_len = sizeof(struct smc_clc_msg_decline);
  436. len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1,
  437. sizeof(struct smc_clc_msg_decline));
  438. if (len < 0 || len < sizeof(struct smc_clc_msg_decline))
  439. len = -EPROTO;
  440. return len > 0 ? 0 : len;
  441. }
  442. /* send CLC PROPOSAL message across internal TCP socket */
  443. int smc_clc_send_proposal(struct smc_sock *smc, struct smc_init_info *ini)
  444. {
  445. struct smc_clc_smcd_v2_extension *smcd_v2_ext;
  446. struct smc_clc_msg_proposal_prefix *pclc_prfx;
  447. struct smc_clc_msg_proposal *pclc_base;
  448. struct smc_clc_smcd_gid_chid *gidchids;
  449. struct smc_clc_msg_proposal_area *pclc;
  450. struct smc_clc_ipv6_prefix *ipv6_prfx;
  451. struct smc_clc_v2_extension *v2_ext;
  452. struct smc_clc_msg_smcd *pclc_smcd;
  453. struct smc_clc_msg_trail *trl;
  454. int len, i, plen, rc;
  455. int reason_code = 0;
  456. struct kvec vec[8];
  457. struct msghdr msg;
  458. pclc = kzalloc(sizeof(*pclc), GFP_KERNEL);
  459. if (!pclc)
  460. return -ENOMEM;
  461. pclc_base = &pclc->pclc_base;
  462. pclc_smcd = &pclc->pclc_smcd;
  463. pclc_prfx = &pclc->pclc_prfx;
  464. ipv6_prfx = pclc->pclc_prfx_ipv6;
  465. v2_ext = &pclc->pclc_v2_ext;
  466. smcd_v2_ext = &pclc->pclc_smcd_v2_ext;
  467. gidchids = pclc->pclc_gidchids;
  468. trl = &pclc->pclc_trl;
  469. pclc_base->hdr.version = SMC_V2;
  470. pclc_base->hdr.typev1 = ini->smc_type_v1;
  471. pclc_base->hdr.typev2 = ini->smc_type_v2;
  472. plen = sizeof(*pclc_base) + sizeof(*pclc_smcd) + sizeof(*trl);
  473. /* retrieve ip prefixes for CLC proposal msg */
  474. if (ini->smc_type_v1 != SMC_TYPE_N) {
  475. rc = smc_clc_prfx_set(smc->clcsock, pclc_prfx, ipv6_prfx);
  476. if (rc) {
  477. if (ini->smc_type_v2 == SMC_TYPE_N) {
  478. kfree(pclc);
  479. return SMC_CLC_DECL_CNFERR;
  480. }
  481. pclc_base->hdr.typev1 = SMC_TYPE_N;
  482. } else {
  483. pclc_base->iparea_offset = htons(sizeof(*pclc_smcd));
  484. plen += sizeof(*pclc_prfx) +
  485. pclc_prfx->ipv6_prefixes_cnt *
  486. sizeof(ipv6_prfx[0]);
  487. }
  488. }
  489. /* build SMC Proposal CLC message */
  490. memcpy(pclc_base->hdr.eyecatcher, SMC_EYECATCHER,
  491. sizeof(SMC_EYECATCHER));
  492. pclc_base->hdr.type = SMC_CLC_PROPOSAL;
  493. if (smcr_indicated(ini->smc_type_v1)) {
  494. /* add SMC-R specifics */
  495. memcpy(pclc_base->lcl.id_for_peer, local_systemid,
  496. sizeof(local_systemid));
  497. memcpy(pclc_base->lcl.gid, ini->ib_gid, SMC_GID_SIZE);
  498. memcpy(pclc_base->lcl.mac, &ini->ib_dev->mac[ini->ib_port - 1],
  499. ETH_ALEN);
  500. }
  501. if (smcd_indicated(ini->smc_type_v1)) {
  502. /* add SMC-D specifics */
  503. if (ini->ism_dev[0]) {
  504. pclc_smcd->ism.gid = htonll(ini->ism_dev[0]->local_gid);
  505. pclc_smcd->ism.chid =
  506. htons(smc_ism_get_chid(ini->ism_dev[0]));
  507. }
  508. }
  509. if (ini->smc_type_v2 == SMC_TYPE_N) {
  510. pclc_smcd->v2_ext_offset = 0;
  511. } else {
  512. u16 v2_ext_offset;
  513. u8 *eid = NULL;
  514. v2_ext_offset = sizeof(*pclc_smcd) -
  515. offsetofend(struct smc_clc_msg_smcd, v2_ext_offset);
  516. if (ini->smc_type_v1 != SMC_TYPE_N)
  517. v2_ext_offset += sizeof(*pclc_prfx) +
  518. pclc_prfx->ipv6_prefixes_cnt *
  519. sizeof(ipv6_prfx[0]);
  520. pclc_smcd->v2_ext_offset = htons(v2_ext_offset);
  521. v2_ext->hdr.eid_cnt = 0;
  522. v2_ext->hdr.ism_gid_cnt = ini->ism_offered_cnt;
  523. v2_ext->hdr.flag.release = SMC_RELEASE;
  524. v2_ext->hdr.flag.seid = 1;
  525. v2_ext->hdr.smcd_v2_ext_offset = htons(sizeof(*v2_ext) -
  526. offsetofend(struct smc_clnt_opts_area_hdr,
  527. smcd_v2_ext_offset) +
  528. v2_ext->hdr.eid_cnt * SMC_MAX_EID_LEN);
  529. if (ini->ism_dev[0])
  530. smc_ism_get_system_eid(ini->ism_dev[0], &eid);
  531. else
  532. smc_ism_get_system_eid(ini->ism_dev[1], &eid);
  533. if (eid)
  534. memcpy(smcd_v2_ext->system_eid, eid, SMC_MAX_EID_LEN);
  535. plen += sizeof(*v2_ext) + sizeof(*smcd_v2_ext);
  536. if (ini->ism_offered_cnt) {
  537. for (i = 1; i <= ini->ism_offered_cnt; i++) {
  538. gidchids[i - 1].gid =
  539. htonll(ini->ism_dev[i]->local_gid);
  540. gidchids[i - 1].chid =
  541. htons(smc_ism_get_chid(ini->ism_dev[i]));
  542. }
  543. plen += ini->ism_offered_cnt *
  544. sizeof(struct smc_clc_smcd_gid_chid);
  545. }
  546. }
  547. pclc_base->hdr.length = htons(plen);
  548. memcpy(trl->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
  549. /* send SMC Proposal CLC message */
  550. memset(&msg, 0, sizeof(msg));
  551. i = 0;
  552. vec[i].iov_base = pclc_base;
  553. vec[i++].iov_len = sizeof(*pclc_base);
  554. vec[i].iov_base = pclc_smcd;
  555. vec[i++].iov_len = sizeof(*pclc_smcd);
  556. if (ini->smc_type_v1 != SMC_TYPE_N) {
  557. vec[i].iov_base = pclc_prfx;
  558. vec[i++].iov_len = sizeof(*pclc_prfx);
  559. if (pclc_prfx->ipv6_prefixes_cnt > 0) {
  560. vec[i].iov_base = ipv6_prfx;
  561. vec[i++].iov_len = pclc_prfx->ipv6_prefixes_cnt *
  562. sizeof(ipv6_prfx[0]);
  563. }
  564. }
  565. if (ini->smc_type_v2 != SMC_TYPE_N) {
  566. vec[i].iov_base = v2_ext;
  567. vec[i++].iov_len = sizeof(*v2_ext);
  568. vec[i].iov_base = smcd_v2_ext;
  569. vec[i++].iov_len = sizeof(*smcd_v2_ext);
  570. if (ini->ism_offered_cnt) {
  571. vec[i].iov_base = gidchids;
  572. vec[i++].iov_len = ini->ism_offered_cnt *
  573. sizeof(struct smc_clc_smcd_gid_chid);
  574. }
  575. }
  576. vec[i].iov_base = trl;
  577. vec[i++].iov_len = sizeof(*trl);
  578. /* due to the few bytes needed for clc-handshake this cannot block */
  579. len = kernel_sendmsg(smc->clcsock, &msg, vec, i, plen);
  580. if (len < 0) {
  581. smc->sk.sk_err = smc->clcsock->sk->sk_err;
  582. reason_code = -smc->sk.sk_err;
  583. } else if (len < ntohs(pclc_base->hdr.length)) {
  584. reason_code = -ENETUNREACH;
  585. smc->sk.sk_err = -reason_code;
  586. }
  587. kfree(pclc);
  588. return reason_code;
  589. }
  590. /* build and send CLC CONFIRM / ACCEPT message */
  591. static int smc_clc_send_confirm_accept(struct smc_sock *smc,
  592. struct smc_clc_msg_accept_confirm_v2 *clc_v2,
  593. int first_contact, u8 version)
  594. {
  595. struct smc_connection *conn = &smc->conn;
  596. struct smc_clc_msg_accept_confirm *clc;
  597. struct smc_clc_first_contact_ext fce;
  598. struct smc_clc_msg_trail trl;
  599. struct kvec vec[3];
  600. struct msghdr msg;
  601. int i, len;
  602. /* send SMC Confirm CLC msg */
  603. clc = (struct smc_clc_msg_accept_confirm *)clc_v2;
  604. clc->hdr.version = version; /* SMC version */
  605. if (first_contact)
  606. clc->hdr.typev2 |= SMC_FIRST_CONTACT_MASK;
  607. if (conn->lgr->is_smcd) {
  608. /* SMC-D specific settings */
  609. memcpy(clc->hdr.eyecatcher, SMCD_EYECATCHER,
  610. sizeof(SMCD_EYECATCHER));
  611. clc->hdr.typev1 = SMC_TYPE_D;
  612. clc->d0.gid = conn->lgr->smcd->local_gid;
  613. clc->d0.token = conn->rmb_desc->token;
  614. clc->d0.dmbe_size = conn->rmbe_size_short;
  615. clc->d0.dmbe_idx = 0;
  616. memcpy(&clc->d0.linkid, conn->lgr->id, SMC_LGR_ID_SIZE);
  617. if (version == SMC_V1) {
  618. clc->hdr.length = htons(SMCD_CLC_ACCEPT_CONFIRM_LEN);
  619. } else {
  620. u8 *eid = NULL;
  621. clc_v2->chid = htons(smc_ism_get_chid(conn->lgr->smcd));
  622. smc_ism_get_system_eid(conn->lgr->smcd, &eid);
  623. if (eid)
  624. memcpy(clc_v2->eid, eid, SMC_MAX_EID_LEN);
  625. len = SMCD_CLC_ACCEPT_CONFIRM_LEN_V2;
  626. if (first_contact)
  627. smc_clc_fill_fce(&fce, &len);
  628. clc_v2->hdr.length = htons(len);
  629. }
  630. memcpy(trl.eyecatcher, SMCD_EYECATCHER,
  631. sizeof(SMCD_EYECATCHER));
  632. } else {
  633. struct smc_link *link = conn->lnk;
  634. /* SMC-R specific settings */
  635. link = conn->lnk;
  636. memcpy(clc->hdr.eyecatcher, SMC_EYECATCHER,
  637. sizeof(SMC_EYECATCHER));
  638. clc->hdr.typev1 = SMC_TYPE_R;
  639. clc->hdr.length = htons(SMCR_CLC_ACCEPT_CONFIRM_LEN);
  640. memcpy(clc->r0.lcl.id_for_peer, local_systemid,
  641. sizeof(local_systemid));
  642. memcpy(&clc->r0.lcl.gid, link->gid, SMC_GID_SIZE);
  643. memcpy(&clc->r0.lcl.mac, &link->smcibdev->mac[link->ibport - 1],
  644. ETH_ALEN);
  645. hton24(clc->r0.qpn, link->roce_qp->qp_num);
  646. clc->r0.rmb_rkey =
  647. htonl(conn->rmb_desc->mr_rx[link->link_idx]->rkey);
  648. clc->r0.rmbe_idx = 1; /* for now: 1 RMB = 1 RMBE */
  649. clc->r0.rmbe_alert_token = htonl(conn->alert_token_local);
  650. switch (clc->hdr.type) {
  651. case SMC_CLC_ACCEPT:
  652. clc->r0.qp_mtu = link->path_mtu;
  653. break;
  654. case SMC_CLC_CONFIRM:
  655. clc->r0.qp_mtu = min(link->path_mtu, link->peer_mtu);
  656. break;
  657. }
  658. clc->r0.rmbe_size = conn->rmbe_size_short;
  659. clc->r0.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address
  660. (conn->rmb_desc->sgt[link->link_idx].sgl));
  661. hton24(clc->r0.psn, link->psn_initial);
  662. memcpy(trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
  663. }
  664. memset(&msg, 0, sizeof(msg));
  665. i = 0;
  666. vec[i].iov_base = clc_v2;
  667. if (version > SMC_V1)
  668. vec[i++].iov_len = SMCD_CLC_ACCEPT_CONFIRM_LEN_V2 - sizeof(trl);
  669. else
  670. vec[i++].iov_len = (clc->hdr.typev1 == SMC_TYPE_D ?
  671. SMCD_CLC_ACCEPT_CONFIRM_LEN :
  672. SMCR_CLC_ACCEPT_CONFIRM_LEN) -
  673. sizeof(trl);
  674. if (version > SMC_V1 && first_contact) {
  675. vec[i].iov_base = &fce;
  676. vec[i++].iov_len = sizeof(fce);
  677. }
  678. vec[i].iov_base = &trl;
  679. vec[i++].iov_len = sizeof(trl);
  680. return kernel_sendmsg(smc->clcsock, &msg, vec, 1,
  681. ntohs(clc->hdr.length));
  682. }
  683. /* send CLC CONFIRM message across internal TCP socket */
  684. int smc_clc_send_confirm(struct smc_sock *smc, bool clnt_first_contact,
  685. u8 version)
  686. {
  687. struct smc_clc_msg_accept_confirm_v2 cclc_v2;
  688. int reason_code = 0;
  689. int len;
  690. /* send SMC Confirm CLC msg */
  691. memset(&cclc_v2, 0, sizeof(cclc_v2));
  692. cclc_v2.hdr.type = SMC_CLC_CONFIRM;
  693. len = smc_clc_send_confirm_accept(smc, &cclc_v2, clnt_first_contact,
  694. version);
  695. if (len < ntohs(cclc_v2.hdr.length)) {
  696. if (len >= 0) {
  697. reason_code = -ENETUNREACH;
  698. smc->sk.sk_err = -reason_code;
  699. } else {
  700. smc->sk.sk_err = smc->clcsock->sk->sk_err;
  701. reason_code = -smc->sk.sk_err;
  702. }
  703. }
  704. return reason_code;
  705. }
  706. /* send CLC ACCEPT message across internal TCP socket */
  707. int smc_clc_send_accept(struct smc_sock *new_smc, bool srv_first_contact,
  708. u8 version)
  709. {
  710. struct smc_clc_msg_accept_confirm_v2 aclc_v2;
  711. int len;
  712. memset(&aclc_v2, 0, sizeof(aclc_v2));
  713. aclc_v2.hdr.type = SMC_CLC_ACCEPT;
  714. len = smc_clc_send_confirm_accept(new_smc, &aclc_v2, srv_first_contact,
  715. version);
  716. if (len < ntohs(aclc_v2.hdr.length))
  717. len = len >= 0 ? -EPROTO : -new_smc->clcsock->sk->sk_err;
  718. return len > 0 ? 0 : len;
  719. }
  720. void __init smc_clc_init(void)
  721. {
  722. struct new_utsname *u;
  723. memset(smc_hostname, _S, sizeof(smc_hostname)); /* ASCII blanks */
  724. u = utsname();
  725. memcpy(smc_hostname, u->nodename,
  726. min_t(size_t, strlen(u->nodename), sizeof(smc_hostname)));
  727. }