Loading...
1/*
2 * Copyright (c) 2014 Intel Corporation. All rights reserved.
3 * Copyright (c) 2014 Chelsio, Inc. All rights reserved.
4 *
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 */
33
34#include "iwpm_util.h"
35
36static const char iwpm_ulib_name[IWPM_ULIBNAME_SIZE] = "iWarpPortMapperUser";
37u16 iwpm_ulib_version = IWPM_UABI_VERSION_MIN;
38static int iwpm_user_pid = IWPM_PID_UNDEFINED;
39static atomic_t echo_nlmsg_seq;
40
41/**
42 * iwpm_valid_pid - Check if the userspace iwarp port mapper pid is valid
43 *
44 * Returns true if the pid is greater than zero, otherwise returns false
45 */
46int iwpm_valid_pid(void)
47{
48 return iwpm_user_pid > 0;
49}
50
51/**
52 * iwpm_register_pid - Send a netlink query to userspace
53 * to get the iwarp port mapper pid
54 * @pm_msg: Contains driver info to send to the userspace port mapper
55 * @nl_client: The index of the netlink client
56 *
57 * nlmsg attributes:
58 * [IWPM_NLA_REG_PID_SEQ]
59 * [IWPM_NLA_REG_IF_NAME]
60 * [IWPM_NLA_REG_IBDEV_NAME]
61 * [IWPM_NLA_REG_ULIB_NAME]
62 */
63int iwpm_register_pid(struct iwpm_dev_data *pm_msg, u8 nl_client)
64{
65 struct sk_buff *skb = NULL;
66 struct iwpm_nlmsg_request *nlmsg_request = NULL;
67 struct nlmsghdr *nlh;
68 u32 msg_seq;
69 const char *err_str = "";
70 int ret = -EINVAL;
71
72 if (iwpm_check_registration(nl_client, IWPM_REG_VALID) ||
73 iwpm_user_pid == IWPM_PID_UNAVAILABLE)
74 return 0;
75 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_REG_PID, &nlh, nl_client);
76 if (!skb) {
77 err_str = "Unable to create a nlmsg";
78 goto pid_query_error;
79 }
80 nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
81 nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq, nl_client, GFP_KERNEL);
82 if (!nlmsg_request) {
83 err_str = "Unable to allocate netlink request";
84 goto pid_query_error;
85 }
86 msg_seq = atomic_read(&echo_nlmsg_seq);
87
88 /* fill in the pid request message */
89 err_str = "Unable to put attribute of the nlmsg";
90 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq, IWPM_NLA_REG_PID_SEQ);
91 if (ret)
92 goto pid_query_error;
93 ret = ibnl_put_attr(skb, nlh, IFNAMSIZ,
94 pm_msg->if_name, IWPM_NLA_REG_IF_NAME);
95 if (ret)
96 goto pid_query_error;
97 ret = ibnl_put_attr(skb, nlh, IWPM_DEVNAME_SIZE,
98 pm_msg->dev_name, IWPM_NLA_REG_IBDEV_NAME);
99 if (ret)
100 goto pid_query_error;
101 ret = ibnl_put_attr(skb, nlh, IWPM_ULIBNAME_SIZE,
102 (char *)iwpm_ulib_name, IWPM_NLA_REG_ULIB_NAME);
103 if (ret)
104 goto pid_query_error;
105
106 nlmsg_end(skb, nlh);
107
108 pr_debug("%s: Multicasting a nlmsg (dev = %s ifname = %s iwpm = %s)\n",
109 __func__, pm_msg->dev_name, pm_msg->if_name, iwpm_ulib_name);
110
111 ret = rdma_nl_multicast(&init_net, skb, RDMA_NL_GROUP_IWPM, GFP_KERNEL);
112 if (ret) {
113 skb = NULL; /* skb is freed in the netlink send-op handling */
114 iwpm_user_pid = IWPM_PID_UNAVAILABLE;
115 err_str = "Unable to send a nlmsg";
116 goto pid_query_error;
117 }
118 nlmsg_request->req_buffer = pm_msg;
119 ret = iwpm_wait_complete_req(nlmsg_request);
120 return ret;
121pid_query_error:
122 pr_info("%s: %s (client = %u)\n", __func__, err_str, nl_client);
123 dev_kfree_skb(skb);
124 if (nlmsg_request)
125 iwpm_free_nlmsg_request(&nlmsg_request->kref);
126 return ret;
127}
128
129/**
130 * iwpm_add_mapping - Send a netlink add mapping request to
131 * the userspace port mapper
132 * @pm_msg: Contains the local ip/tcp address info to send
133 * @nl_client: The index of the netlink client
134 *
135 * nlmsg attributes:
136 * [IWPM_NLA_MANAGE_MAPPING_SEQ]
137 * [IWPM_NLA_MANAGE_ADDR]
138 * [IWPM_NLA_MANAGE_FLAGS]
139 *
140 * If the request is successful, the pm_msg stores
141 * the port mapper response (mapped address info)
142 */
143int iwpm_add_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client)
144{
145 struct sk_buff *skb = NULL;
146 struct iwpm_nlmsg_request *nlmsg_request = NULL;
147 struct nlmsghdr *nlh;
148 u32 msg_seq;
149 const char *err_str = "";
150 int ret = -EINVAL;
151
152 if (!iwpm_valid_pid())
153 return 0;
154 if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) {
155 err_str = "Unregistered port mapper client";
156 goto add_mapping_error;
157 }
158 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_ADD_MAPPING, &nlh, nl_client);
159 if (!skb) {
160 err_str = "Unable to create a nlmsg";
161 goto add_mapping_error;
162 }
163 nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
164 nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq, nl_client, GFP_KERNEL);
165 if (!nlmsg_request) {
166 err_str = "Unable to allocate netlink request";
167 goto add_mapping_error;
168 }
169 msg_seq = atomic_read(&echo_nlmsg_seq);
170 /* fill in the add mapping message */
171 err_str = "Unable to put attribute of the nlmsg";
172 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
173 IWPM_NLA_MANAGE_MAPPING_SEQ);
174 if (ret)
175 goto add_mapping_error;
176 ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
177 &pm_msg->loc_addr, IWPM_NLA_MANAGE_ADDR);
178 if (ret)
179 goto add_mapping_error;
180
181 /* If flags are required and we're not V4, then return a quiet error */
182 if (pm_msg->flags && iwpm_ulib_version == IWPM_UABI_VERSION_MIN) {
183 ret = -EINVAL;
184 goto add_mapping_error_nowarn;
185 }
186 if (iwpm_ulib_version > IWPM_UABI_VERSION_MIN) {
187 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &pm_msg->flags,
188 IWPM_NLA_MANAGE_FLAGS);
189 if (ret)
190 goto add_mapping_error;
191 }
192
193 nlmsg_end(skb, nlh);
194 nlmsg_request->req_buffer = pm_msg;
195
196 ret = rdma_nl_unicast_wait(&init_net, skb, iwpm_user_pid);
197 if (ret) {
198 skb = NULL; /* skb is freed in the netlink send-op handling */
199 iwpm_user_pid = IWPM_PID_UNDEFINED;
200 err_str = "Unable to send a nlmsg";
201 goto add_mapping_error;
202 }
203 ret = iwpm_wait_complete_req(nlmsg_request);
204 return ret;
205add_mapping_error:
206 pr_info("%s: %s (client = %u)\n", __func__, err_str, nl_client);
207add_mapping_error_nowarn:
208 dev_kfree_skb(skb);
209 if (nlmsg_request)
210 iwpm_free_nlmsg_request(&nlmsg_request->kref);
211 return ret;
212}
213
214/**
215 * iwpm_add_and_query_mapping - Process the port mapper response to
216 * iwpm_add_and_query_mapping request
217 * @pm_msg: Contains the local ip/tcp address info to send
218 * @nl_client: The index of the netlink client
219 *
220 * nlmsg attributes:
221 * [IWPM_NLA_QUERY_MAPPING_SEQ]
222 * [IWPM_NLA_QUERY_LOCAL_ADDR]
223 * [IWPM_NLA_QUERY_REMOTE_ADDR]
224 * [IWPM_NLA_QUERY_FLAGS]
225 */
226int iwpm_add_and_query_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client)
227{
228 struct sk_buff *skb = NULL;
229 struct iwpm_nlmsg_request *nlmsg_request = NULL;
230 struct nlmsghdr *nlh;
231 u32 msg_seq;
232 const char *err_str = "";
233 int ret = -EINVAL;
234
235 if (!iwpm_valid_pid())
236 return 0;
237 if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) {
238 err_str = "Unregistered port mapper client";
239 goto query_mapping_error;
240 }
241 ret = -ENOMEM;
242 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_QUERY_MAPPING, &nlh, nl_client);
243 if (!skb) {
244 err_str = "Unable to create a nlmsg";
245 goto query_mapping_error;
246 }
247 nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
248 nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq,
249 nl_client, GFP_KERNEL);
250 if (!nlmsg_request) {
251 err_str = "Unable to allocate netlink request";
252 goto query_mapping_error;
253 }
254 msg_seq = atomic_read(&echo_nlmsg_seq);
255
256 /* fill in the query message */
257 err_str = "Unable to put attribute of the nlmsg";
258 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
259 IWPM_NLA_QUERY_MAPPING_SEQ);
260 if (ret)
261 goto query_mapping_error;
262 ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
263 &pm_msg->loc_addr, IWPM_NLA_QUERY_LOCAL_ADDR);
264 if (ret)
265 goto query_mapping_error;
266 ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
267 &pm_msg->rem_addr, IWPM_NLA_QUERY_REMOTE_ADDR);
268 if (ret)
269 goto query_mapping_error;
270
271 /* If flags are required and we're not V4, then return a quite error */
272 if (pm_msg->flags && iwpm_ulib_version == IWPM_UABI_VERSION_MIN) {
273 ret = -EINVAL;
274 goto query_mapping_error_nowarn;
275 }
276 if (iwpm_ulib_version > IWPM_UABI_VERSION_MIN) {
277 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &pm_msg->flags,
278 IWPM_NLA_QUERY_FLAGS);
279 if (ret)
280 goto query_mapping_error;
281 }
282
283 nlmsg_end(skb, nlh);
284 nlmsg_request->req_buffer = pm_msg;
285
286 ret = rdma_nl_unicast_wait(&init_net, skb, iwpm_user_pid);
287 if (ret) {
288 skb = NULL; /* skb is freed in the netlink send-op handling */
289 err_str = "Unable to send a nlmsg";
290 goto query_mapping_error;
291 }
292 ret = iwpm_wait_complete_req(nlmsg_request);
293 return ret;
294query_mapping_error:
295 pr_info("%s: %s (client = %u)\n", __func__, err_str, nl_client);
296query_mapping_error_nowarn:
297 dev_kfree_skb(skb);
298 if (nlmsg_request)
299 iwpm_free_nlmsg_request(&nlmsg_request->kref);
300 return ret;
301}
302
303/**
304 * iwpm_remove_mapping - Send a netlink remove mapping request
305 * to the userspace port mapper
306 *
307 * @local_addr: Local ip/tcp address to remove
308 * @nl_client: The index of the netlink client
309 *
310 * nlmsg attributes:
311 * [IWPM_NLA_MANAGE_MAPPING_SEQ]
312 * [IWPM_NLA_MANAGE_ADDR]
313 */
314int iwpm_remove_mapping(struct sockaddr_storage *local_addr, u8 nl_client)
315{
316 struct sk_buff *skb = NULL;
317 struct nlmsghdr *nlh;
318 u32 msg_seq;
319 const char *err_str = "";
320 int ret = -EINVAL;
321
322 if (!iwpm_valid_pid())
323 return 0;
324 if (iwpm_check_registration(nl_client, IWPM_REG_UNDEF)) {
325 err_str = "Unregistered port mapper client";
326 goto remove_mapping_error;
327 }
328 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_REMOVE_MAPPING, &nlh, nl_client);
329 if (!skb) {
330 ret = -ENOMEM;
331 err_str = "Unable to create a nlmsg";
332 goto remove_mapping_error;
333 }
334 msg_seq = atomic_read(&echo_nlmsg_seq);
335 nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
336 err_str = "Unable to put attribute of the nlmsg";
337 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
338 IWPM_NLA_MANAGE_MAPPING_SEQ);
339 if (ret)
340 goto remove_mapping_error;
341 ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
342 local_addr, IWPM_NLA_MANAGE_ADDR);
343 if (ret)
344 goto remove_mapping_error;
345
346 nlmsg_end(skb, nlh);
347
348 ret = rdma_nl_unicast_wait(&init_net, skb, iwpm_user_pid);
349 if (ret) {
350 skb = NULL; /* skb is freed in the netlink send-op handling */
351 iwpm_user_pid = IWPM_PID_UNDEFINED;
352 err_str = "Unable to send a nlmsg";
353 goto remove_mapping_error;
354 }
355 iwpm_print_sockaddr(local_addr,
356 "remove_mapping: Local sockaddr:");
357 return 0;
358remove_mapping_error:
359 pr_info("%s: %s (client = %u)\n", __func__, err_str, nl_client);
360 if (skb)
361 dev_kfree_skb_any(skb);
362 return ret;
363}
364
365/* netlink attribute policy for the received response to register pid request */
366static const struct nla_policy resp_reg_policy[IWPM_NLA_RREG_PID_MAX] = {
367 [IWPM_NLA_RREG_PID_SEQ] = { .type = NLA_U32 },
368 [IWPM_NLA_RREG_IBDEV_NAME] = { .type = NLA_STRING,
369 .len = IWPM_DEVNAME_SIZE - 1 },
370 [IWPM_NLA_RREG_ULIB_NAME] = { .type = NLA_STRING,
371 .len = IWPM_ULIBNAME_SIZE - 1 },
372 [IWPM_NLA_RREG_ULIB_VER] = { .type = NLA_U16 },
373 [IWPM_NLA_RREG_PID_ERR] = { .type = NLA_U16 }
374};
375
376/**
377 * iwpm_register_pid_cb - Process the port mapper response to
378 * iwpm_register_pid query
379 * @skb: The socket buffer
380 * @cb: Contains the received message (payload and netlink header)
381 *
382 * If successful, the function receives the userspace port mapper pid
383 * which is used in future communication with the port mapper
384 */
385int iwpm_register_pid_cb(struct sk_buff *skb, struct netlink_callback *cb)
386{
387 struct iwpm_nlmsg_request *nlmsg_request = NULL;
388 struct nlattr *nltb[IWPM_NLA_RREG_PID_MAX];
389 struct iwpm_dev_data *pm_msg;
390 char *dev_name, *iwpm_name;
391 u32 msg_seq;
392 u8 nl_client;
393 u16 iwpm_version;
394 const char *msg_type = "Register Pid response";
395
396 if (iwpm_parse_nlmsg(cb, IWPM_NLA_RREG_PID_MAX,
397 resp_reg_policy, nltb, msg_type))
398 return -EINVAL;
399
400 msg_seq = nla_get_u32(nltb[IWPM_NLA_RREG_PID_SEQ]);
401 nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
402 if (!nlmsg_request) {
403 pr_info("%s: Could not find a matching request (seq = %u)\n",
404 __func__, msg_seq);
405 return -EINVAL;
406 }
407 pm_msg = nlmsg_request->req_buffer;
408 nl_client = nlmsg_request->nl_client;
409 dev_name = (char *)nla_data(nltb[IWPM_NLA_RREG_IBDEV_NAME]);
410 iwpm_name = (char *)nla_data(nltb[IWPM_NLA_RREG_ULIB_NAME]);
411 iwpm_version = nla_get_u16(nltb[IWPM_NLA_RREG_ULIB_VER]);
412
413 /* check device name, ulib name and version */
414 if (strcmp(pm_msg->dev_name, dev_name) ||
415 strcmp(iwpm_ulib_name, iwpm_name) ||
416 iwpm_version < IWPM_UABI_VERSION_MIN) {
417
418 pr_info("%s: Incorrect info (dev = %s name = %s version = %u)\n",
419 __func__, dev_name, iwpm_name, iwpm_version);
420 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
421 goto register_pid_response_exit;
422 }
423 iwpm_user_pid = cb->nlh->nlmsg_pid;
424 iwpm_ulib_version = iwpm_version;
425 if (iwpm_ulib_version < IWPM_UABI_VERSION)
426 pr_warn_once("%s: Down level iwpmd/pid %d. Continuing...",
427 __func__, iwpm_user_pid);
428 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
429 pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
430 __func__, iwpm_user_pid);
431 iwpm_set_registration(nl_client, IWPM_REG_VALID);
432register_pid_response_exit:
433 nlmsg_request->request_done = 1;
434 /* always for found nlmsg_request */
435 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
436 barrier();
437 up(&nlmsg_request->sem);
438 return 0;
439}
440
441/* netlink attribute policy for the received response to add mapping request */
442static const struct nla_policy resp_add_policy[IWPM_NLA_RMANAGE_MAPPING_MAX] = {
443 [IWPM_NLA_RMANAGE_MAPPING_SEQ] = { .type = NLA_U32 },
444 [IWPM_NLA_RMANAGE_ADDR] = {
445 .len = sizeof(struct sockaddr_storage) },
446 [IWPM_NLA_RMANAGE_MAPPED_LOC_ADDR] = {
447 .len = sizeof(struct sockaddr_storage) },
448 [IWPM_NLA_RMANAGE_MAPPING_ERR] = { .type = NLA_U16 }
449};
450
451/**
452 * iwpm_add_mapping_cb - Process the port mapper response to
453 * iwpm_add_mapping request
454 * @skb: The socket buffer
455 * @cb: Contains the received message (payload and netlink header)
456 */
457int iwpm_add_mapping_cb(struct sk_buff *skb, struct netlink_callback *cb)
458{
459 struct iwpm_sa_data *pm_msg;
460 struct iwpm_nlmsg_request *nlmsg_request = NULL;
461 struct nlattr *nltb[IWPM_NLA_RMANAGE_MAPPING_MAX];
462 struct sockaddr_storage *local_sockaddr;
463 struct sockaddr_storage *mapped_sockaddr;
464 const char *msg_type;
465 u32 msg_seq;
466
467 msg_type = "Add Mapping response";
468 if (iwpm_parse_nlmsg(cb, IWPM_NLA_RMANAGE_MAPPING_MAX,
469 resp_add_policy, nltb, msg_type))
470 return -EINVAL;
471
472 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
473
474 msg_seq = nla_get_u32(nltb[IWPM_NLA_RMANAGE_MAPPING_SEQ]);
475 nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
476 if (!nlmsg_request) {
477 pr_info("%s: Could not find a matching request (seq = %u)\n",
478 __func__, msg_seq);
479 return -EINVAL;
480 }
481 pm_msg = nlmsg_request->req_buffer;
482 local_sockaddr = (struct sockaddr_storage *)
483 nla_data(nltb[IWPM_NLA_RMANAGE_ADDR]);
484 mapped_sockaddr = (struct sockaddr_storage *)
485 nla_data(nltb[IWPM_NLA_RMANAGE_MAPPED_LOC_ADDR]);
486
487 if (iwpm_compare_sockaddr(local_sockaddr, &pm_msg->loc_addr)) {
488 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
489 goto add_mapping_response_exit;
490 }
491 if (mapped_sockaddr->ss_family != local_sockaddr->ss_family) {
492 pr_info("%s: Sockaddr family doesn't match the requested one\n",
493 __func__);
494 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
495 goto add_mapping_response_exit;
496 }
497 memcpy(&pm_msg->mapped_loc_addr, mapped_sockaddr,
498 sizeof(*mapped_sockaddr));
499 iwpm_print_sockaddr(&pm_msg->loc_addr,
500 "add_mapping: Local sockaddr:");
501 iwpm_print_sockaddr(&pm_msg->mapped_loc_addr,
502 "add_mapping: Mapped local sockaddr:");
503
504add_mapping_response_exit:
505 nlmsg_request->request_done = 1;
506 /* always for found request */
507 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
508 barrier();
509 up(&nlmsg_request->sem);
510 return 0;
511}
512
513/* netlink attribute policy for the response to add and query mapping request
514 * and response with remote address info
515 */
516static const struct nla_policy resp_query_policy[IWPM_NLA_RQUERY_MAPPING_MAX] = {
517 [IWPM_NLA_RQUERY_MAPPING_SEQ] = { .type = NLA_U32 },
518 [IWPM_NLA_RQUERY_LOCAL_ADDR] = {
519 .len = sizeof(struct sockaddr_storage) },
520 [IWPM_NLA_RQUERY_REMOTE_ADDR] = {
521 .len = sizeof(struct sockaddr_storage) },
522 [IWPM_NLA_RQUERY_MAPPED_LOC_ADDR] = {
523 .len = sizeof(struct sockaddr_storage) },
524 [IWPM_NLA_RQUERY_MAPPED_REM_ADDR] = {
525 .len = sizeof(struct sockaddr_storage) },
526 [IWPM_NLA_RQUERY_MAPPING_ERR] = { .type = NLA_U16 }
527};
528
529/**
530 * iwpm_add_and_query_mapping_cb - Process the port mapper response to
531 * iwpm_add_and_query_mapping request
532 * @skb: The socket buffer
533 * @cb: Contains the received message (payload and netlink header)
534 */
535int iwpm_add_and_query_mapping_cb(struct sk_buff *skb,
536 struct netlink_callback *cb)
537{
538 struct iwpm_sa_data *pm_msg;
539 struct iwpm_nlmsg_request *nlmsg_request = NULL;
540 struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX];
541 struct sockaddr_storage *local_sockaddr, *remote_sockaddr;
542 struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr;
543 const char *msg_type;
544 u32 msg_seq;
545 u16 err_code;
546
547 msg_type = "Query Mapping response";
548 if (iwpm_parse_nlmsg(cb, IWPM_NLA_RQUERY_MAPPING_MAX,
549 resp_query_policy, nltb, msg_type))
550 return -EINVAL;
551 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
552
553 msg_seq = nla_get_u32(nltb[IWPM_NLA_RQUERY_MAPPING_SEQ]);
554 nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
555 if (!nlmsg_request) {
556 pr_info("%s: Could not find a matching request (seq = %u)\n",
557 __func__, msg_seq);
558 return -EINVAL;
559 }
560 pm_msg = nlmsg_request->req_buffer;
561 local_sockaddr = (struct sockaddr_storage *)
562 nla_data(nltb[IWPM_NLA_RQUERY_LOCAL_ADDR]);
563 remote_sockaddr = (struct sockaddr_storage *)
564 nla_data(nltb[IWPM_NLA_RQUERY_REMOTE_ADDR]);
565 mapped_loc_sockaddr = (struct sockaddr_storage *)
566 nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]);
567 mapped_rem_sockaddr = (struct sockaddr_storage *)
568 nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]);
569
570 err_code = nla_get_u16(nltb[IWPM_NLA_RQUERY_MAPPING_ERR]);
571 if (err_code == IWPM_REMOTE_QUERY_REJECT) {
572 pr_info("%s: Received a Reject (pid = %u, echo seq = %u)\n",
573 __func__, cb->nlh->nlmsg_pid, msg_seq);
574 nlmsg_request->err_code = IWPM_REMOTE_QUERY_REJECT;
575 }
576 if (iwpm_compare_sockaddr(local_sockaddr, &pm_msg->loc_addr) ||
577 iwpm_compare_sockaddr(remote_sockaddr, &pm_msg->rem_addr)) {
578 pr_info("%s: Incorrect local sockaddr\n", __func__);
579 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
580 goto query_mapping_response_exit;
581 }
582 if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family ||
583 mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) {
584 pr_info("%s: Sockaddr family doesn't match the requested one\n",
585 __func__);
586 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
587 goto query_mapping_response_exit;
588 }
589 memcpy(&pm_msg->mapped_loc_addr, mapped_loc_sockaddr,
590 sizeof(*mapped_loc_sockaddr));
591 memcpy(&pm_msg->mapped_rem_addr, mapped_rem_sockaddr,
592 sizeof(*mapped_rem_sockaddr));
593
594 iwpm_print_sockaddr(&pm_msg->loc_addr,
595 "query_mapping: Local sockaddr:");
596 iwpm_print_sockaddr(&pm_msg->mapped_loc_addr,
597 "query_mapping: Mapped local sockaddr:");
598 iwpm_print_sockaddr(&pm_msg->rem_addr,
599 "query_mapping: Remote sockaddr:");
600 iwpm_print_sockaddr(&pm_msg->mapped_rem_addr,
601 "query_mapping: Mapped remote sockaddr:");
602query_mapping_response_exit:
603 nlmsg_request->request_done = 1;
604 /* always for found request */
605 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
606 barrier();
607 up(&nlmsg_request->sem);
608 return 0;
609}
610
611/**
612 * iwpm_remote_info_cb - Process remote connecting peer address info, which
613 * the port mapper has received from the connecting peer
614 * @skb: The socket buffer
615 * @cb: Contains the received message (payload and netlink header)
616 *
617 * Stores the IPv4/IPv6 address info in a hash table
618 */
619int iwpm_remote_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
620{
621 struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX];
622 struct sockaddr_storage *local_sockaddr, *remote_sockaddr;
623 struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr;
624 struct iwpm_remote_info *rem_info;
625 const char *msg_type;
626 u8 nl_client;
627 int ret = -EINVAL;
628
629 msg_type = "Remote Mapping info";
630 if (iwpm_parse_nlmsg(cb, IWPM_NLA_RQUERY_MAPPING_MAX,
631 resp_query_policy, nltb, msg_type))
632 return ret;
633
634 nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
635 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
636
637 local_sockaddr = (struct sockaddr_storage *)
638 nla_data(nltb[IWPM_NLA_RQUERY_LOCAL_ADDR]);
639 remote_sockaddr = (struct sockaddr_storage *)
640 nla_data(nltb[IWPM_NLA_RQUERY_REMOTE_ADDR]);
641 mapped_loc_sockaddr = (struct sockaddr_storage *)
642 nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]);
643 mapped_rem_sockaddr = (struct sockaddr_storage *)
644 nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]);
645
646 if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family ||
647 mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) {
648 pr_info("%s: Sockaddr family doesn't match the requested one\n",
649 __func__);
650 return ret;
651 }
652 rem_info = kzalloc(sizeof(struct iwpm_remote_info), GFP_ATOMIC);
653 if (!rem_info) {
654 ret = -ENOMEM;
655 return ret;
656 }
657 memcpy(&rem_info->mapped_loc_sockaddr, mapped_loc_sockaddr,
658 sizeof(struct sockaddr_storage));
659 memcpy(&rem_info->remote_sockaddr, remote_sockaddr,
660 sizeof(struct sockaddr_storage));
661 memcpy(&rem_info->mapped_rem_sockaddr, mapped_rem_sockaddr,
662 sizeof(struct sockaddr_storage));
663 rem_info->nl_client = nl_client;
664
665 iwpm_add_remote_info(rem_info);
666
667 iwpm_print_sockaddr(local_sockaddr,
668 "remote_info: Local sockaddr:");
669 iwpm_print_sockaddr(mapped_loc_sockaddr,
670 "remote_info: Mapped local sockaddr:");
671 iwpm_print_sockaddr(remote_sockaddr,
672 "remote_info: Remote sockaddr:");
673 iwpm_print_sockaddr(mapped_rem_sockaddr,
674 "remote_info: Mapped remote sockaddr:");
675 return ret;
676}
677
678/* netlink attribute policy for the received request for mapping info */
679static const struct nla_policy resp_mapinfo_policy[IWPM_NLA_MAPINFO_REQ_MAX] = {
680 [IWPM_NLA_MAPINFO_ULIB_NAME] = { .type = NLA_STRING,
681 .len = IWPM_ULIBNAME_SIZE - 1 },
682 [IWPM_NLA_MAPINFO_ULIB_VER] = { .type = NLA_U16 }
683};
684
685/**
686 * iwpm_mapping_info_cb - Process a notification that the userspace
687 * port mapper daemon is started
688 * @skb: The socket buffer
689 * @cb: Contains the received message (payload and netlink header)
690 *
691 * Using the received port mapper pid, send all the local mapping
692 * info records to the userspace port mapper
693 */
694int iwpm_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
695{
696 struct nlattr *nltb[IWPM_NLA_MAPINFO_REQ_MAX];
697 const char *msg_type = "Mapping Info response";
698 u8 nl_client;
699 char *iwpm_name;
700 u16 iwpm_version;
701 int ret = -EINVAL;
702
703 if (iwpm_parse_nlmsg(cb, IWPM_NLA_MAPINFO_REQ_MAX,
704 resp_mapinfo_policy, nltb, msg_type)) {
705 pr_info("%s: Unable to parse nlmsg\n", __func__);
706 return ret;
707 }
708 iwpm_name = (char *)nla_data(nltb[IWPM_NLA_MAPINFO_ULIB_NAME]);
709 iwpm_version = nla_get_u16(nltb[IWPM_NLA_MAPINFO_ULIB_VER]);
710 if (strcmp(iwpm_ulib_name, iwpm_name) ||
711 iwpm_version < IWPM_UABI_VERSION_MIN) {
712 pr_info("%s: Invalid port mapper name = %s version = %u\n",
713 __func__, iwpm_name, iwpm_version);
714 return ret;
715 }
716 nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
717 iwpm_set_registration(nl_client, IWPM_REG_INCOMPL);
718 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
719 iwpm_user_pid = cb->nlh->nlmsg_pid;
720
721 if (iwpm_ulib_version < IWPM_UABI_VERSION)
722 pr_warn_once("%s: Down level iwpmd/pid %d. Continuing...",
723 __func__, iwpm_user_pid);
724
725 if (!iwpm_mapinfo_available())
726 return 0;
727 pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
728 __func__, iwpm_user_pid);
729 ret = iwpm_send_mapinfo(nl_client, iwpm_user_pid);
730 return ret;
731}
732
733/* netlink attribute policy for the received mapping info ack */
734static const struct nla_policy ack_mapinfo_policy[IWPM_NLA_MAPINFO_NUM_MAX] = {
735 [IWPM_NLA_MAPINFO_SEQ] = { .type = NLA_U32 },
736 [IWPM_NLA_MAPINFO_SEND_NUM] = { .type = NLA_U32 },
737 [IWPM_NLA_MAPINFO_ACK_NUM] = { .type = NLA_U32 }
738};
739
740/**
741 * iwpm_ack_mapping_info_cb - Process the port mapper ack for
742 * the provided local mapping info records
743 * @skb: The socket buffer
744 * @cb: Contains the received message (payload and netlink header)
745 */
746int iwpm_ack_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
747{
748 struct nlattr *nltb[IWPM_NLA_MAPINFO_NUM_MAX];
749 u32 mapinfo_send, mapinfo_ack;
750 const char *msg_type = "Mapping Info Ack";
751
752 if (iwpm_parse_nlmsg(cb, IWPM_NLA_MAPINFO_NUM_MAX,
753 ack_mapinfo_policy, nltb, msg_type))
754 return -EINVAL;
755 mapinfo_send = nla_get_u32(nltb[IWPM_NLA_MAPINFO_SEND_NUM]);
756 mapinfo_ack = nla_get_u32(nltb[IWPM_NLA_MAPINFO_ACK_NUM]);
757 if (mapinfo_ack != mapinfo_send)
758 pr_info("%s: Invalid mapinfo number (sent = %u ack-ed = %u)\n",
759 __func__, mapinfo_send, mapinfo_ack);
760 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
761 return 0;
762}
763
764/* netlink attribute policy for the received port mapper error message */
765static const struct nla_policy map_error_policy[IWPM_NLA_ERR_MAX] = {
766 [IWPM_NLA_ERR_SEQ] = { .type = NLA_U32 },
767 [IWPM_NLA_ERR_CODE] = { .type = NLA_U16 },
768};
769
770/**
771 * iwpm_mapping_error_cb - Process port mapper notification for error
772 *
773 * @skb: The socket buffer
774 * @cb: Contains the received message (payload and netlink header)
775 */
776int iwpm_mapping_error_cb(struct sk_buff *skb, struct netlink_callback *cb)
777{
778 struct iwpm_nlmsg_request *nlmsg_request = NULL;
779 int nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
780 struct nlattr *nltb[IWPM_NLA_ERR_MAX];
781 u32 msg_seq;
782 u16 err_code;
783 const char *msg_type = "Mapping Error Msg";
784
785 if (iwpm_parse_nlmsg(cb, IWPM_NLA_ERR_MAX,
786 map_error_policy, nltb, msg_type))
787 return -EINVAL;
788
789 msg_seq = nla_get_u32(nltb[IWPM_NLA_ERR_SEQ]);
790 err_code = nla_get_u16(nltb[IWPM_NLA_ERR_CODE]);
791 pr_info("%s: Received msg seq = %u err code = %u client = %d\n",
792 __func__, msg_seq, err_code, nl_client);
793 /* look for nlmsg_request */
794 nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
795 if (!nlmsg_request) {
796 /* not all errors have associated requests */
797 pr_debug("Could not find matching req (seq = %u)\n", msg_seq);
798 return 0;
799 }
800 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
801 nlmsg_request->err_code = err_code;
802 nlmsg_request->request_done = 1;
803 /* always for found request */
804 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
805 barrier();
806 up(&nlmsg_request->sem);
807 return 0;
808}
809
810/* netlink attribute policy for the received hello request */
811static const struct nla_policy hello_policy[IWPM_NLA_HELLO_MAX] = {
812 [IWPM_NLA_HELLO_ABI_VERSION] = { .type = NLA_U16 }
813};
814
815/**
816 * iwpm_hello_cb - Process a hello message from iwpmd
817 *
818 * @skb: The socket buffer
819 * @cb: Contains the received message (payload and netlink header)
820 *
821 * Using the received port mapper pid, send the kernel's abi_version
822 * after adjusting it to support the iwpmd version.
823 */
824int iwpm_hello_cb(struct sk_buff *skb, struct netlink_callback *cb)
825{
826 struct nlattr *nltb[IWPM_NLA_HELLO_MAX];
827 const char *msg_type = "Hello request";
828 u8 nl_client;
829 u16 abi_version;
830 int ret = -EINVAL;
831
832 if (iwpm_parse_nlmsg(cb, IWPM_NLA_HELLO_MAX, hello_policy, nltb,
833 msg_type)) {
834 pr_info("%s: Unable to parse nlmsg\n", __func__);
835 return ret;
836 }
837 abi_version = nla_get_u16(nltb[IWPM_NLA_HELLO_ABI_VERSION]);
838 nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
839 iwpm_set_registration(nl_client, IWPM_REG_INCOMPL);
840 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
841 iwpm_ulib_version = min_t(u16, IWPM_UABI_VERSION, abi_version);
842 pr_debug("Using ABI version %u\n", iwpm_ulib_version);
843 iwpm_user_pid = cb->nlh->nlmsg_pid;
844 ret = iwpm_send_hello(nl_client, iwpm_user_pid, iwpm_ulib_version);
845 return ret;
846}
1/*
2 * Copyright (c) 2014 Intel Corporation. All rights reserved.
3 * Copyright (c) 2014 Chelsio, Inc. All rights reserved.
4 *
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 */
33
34#include "iwpm_util.h"
35
36static const char iwpm_ulib_name[IWPM_ULIBNAME_SIZE] = "iWarpPortMapperUser";
37static int iwpm_ulib_version = 3;
38static int iwpm_user_pid = IWPM_PID_UNDEFINED;
39static atomic_t echo_nlmsg_seq;
40
41int iwpm_valid_pid(void)
42{
43 return iwpm_user_pid > 0;
44}
45
46/*
47 * iwpm_register_pid - Send a netlink query to user space
48 * for the iwarp port mapper pid
49 *
50 * nlmsg attributes:
51 * [IWPM_NLA_REG_PID_SEQ]
52 * [IWPM_NLA_REG_IF_NAME]
53 * [IWPM_NLA_REG_IBDEV_NAME]
54 * [IWPM_NLA_REG_ULIB_NAME]
55 */
56int iwpm_register_pid(struct iwpm_dev_data *pm_msg, u8 nl_client)
57{
58 struct sk_buff *skb = NULL;
59 struct iwpm_nlmsg_request *nlmsg_request = NULL;
60 struct nlmsghdr *nlh;
61 u32 msg_seq;
62 const char *err_str = "";
63 int ret = -EINVAL;
64
65 if (!iwpm_valid_client(nl_client)) {
66 err_str = "Invalid port mapper client";
67 goto pid_query_error;
68 }
69 if (iwpm_check_registration(nl_client, IWPM_REG_VALID) ||
70 iwpm_user_pid == IWPM_PID_UNAVAILABLE)
71 return 0;
72 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_REG_PID, &nlh, nl_client);
73 if (!skb) {
74 err_str = "Unable to create a nlmsg";
75 goto pid_query_error;
76 }
77 nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
78 nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq, nl_client, GFP_KERNEL);
79 if (!nlmsg_request) {
80 err_str = "Unable to allocate netlink request";
81 goto pid_query_error;
82 }
83 msg_seq = atomic_read(&echo_nlmsg_seq);
84
85 /* fill in the pid request message */
86 err_str = "Unable to put attribute of the nlmsg";
87 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq, IWPM_NLA_REG_PID_SEQ);
88 if (ret)
89 goto pid_query_error;
90 ret = ibnl_put_attr(skb, nlh, IFNAMSIZ,
91 pm_msg->if_name, IWPM_NLA_REG_IF_NAME);
92 if (ret)
93 goto pid_query_error;
94 ret = ibnl_put_attr(skb, nlh, IWPM_DEVNAME_SIZE,
95 pm_msg->dev_name, IWPM_NLA_REG_IBDEV_NAME);
96 if (ret)
97 goto pid_query_error;
98 ret = ibnl_put_attr(skb, nlh, IWPM_ULIBNAME_SIZE,
99 (char *)iwpm_ulib_name, IWPM_NLA_REG_ULIB_NAME);
100 if (ret)
101 goto pid_query_error;
102
103 nlmsg_end(skb, nlh);
104
105 pr_debug("%s: Multicasting a nlmsg (dev = %s ifname = %s iwpm = %s)\n",
106 __func__, pm_msg->dev_name, pm_msg->if_name, iwpm_ulib_name);
107
108 ret = rdma_nl_multicast(skb, RDMA_NL_GROUP_IWPM, GFP_KERNEL);
109 if (ret) {
110 skb = NULL; /* skb is freed in the netlink send-op handling */
111 iwpm_user_pid = IWPM_PID_UNAVAILABLE;
112 err_str = "Unable to send a nlmsg";
113 goto pid_query_error;
114 }
115 nlmsg_request->req_buffer = pm_msg;
116 ret = iwpm_wait_complete_req(nlmsg_request);
117 return ret;
118pid_query_error:
119 pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
120 if (skb)
121 dev_kfree_skb(skb);
122 if (nlmsg_request)
123 iwpm_free_nlmsg_request(&nlmsg_request->kref);
124 return ret;
125}
126
127/*
128 * iwpm_add_mapping - Send a netlink add mapping message
129 * to the port mapper
130 * nlmsg attributes:
131 * [IWPM_NLA_MANAGE_MAPPING_SEQ]
132 * [IWPM_NLA_MANAGE_ADDR]
133 */
134int iwpm_add_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client)
135{
136 struct sk_buff *skb = NULL;
137 struct iwpm_nlmsg_request *nlmsg_request = NULL;
138 struct nlmsghdr *nlh;
139 u32 msg_seq;
140 const char *err_str = "";
141 int ret = -EINVAL;
142
143 if (!iwpm_valid_client(nl_client)) {
144 err_str = "Invalid port mapper client";
145 goto add_mapping_error;
146 }
147 if (!iwpm_valid_pid())
148 return 0;
149 if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) {
150 err_str = "Unregistered port mapper client";
151 goto add_mapping_error;
152 }
153 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_ADD_MAPPING, &nlh, nl_client);
154 if (!skb) {
155 err_str = "Unable to create a nlmsg";
156 goto add_mapping_error;
157 }
158 nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
159 nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq, nl_client, GFP_KERNEL);
160 if (!nlmsg_request) {
161 err_str = "Unable to allocate netlink request";
162 goto add_mapping_error;
163 }
164 msg_seq = atomic_read(&echo_nlmsg_seq);
165 /* fill in the add mapping message */
166 err_str = "Unable to put attribute of the nlmsg";
167 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
168 IWPM_NLA_MANAGE_MAPPING_SEQ);
169 if (ret)
170 goto add_mapping_error;
171 ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
172 &pm_msg->loc_addr, IWPM_NLA_MANAGE_ADDR);
173 if (ret)
174 goto add_mapping_error;
175
176 nlmsg_end(skb, nlh);
177 nlmsg_request->req_buffer = pm_msg;
178
179 ret = rdma_nl_unicast_wait(skb, iwpm_user_pid);
180 if (ret) {
181 skb = NULL; /* skb is freed in the netlink send-op handling */
182 iwpm_user_pid = IWPM_PID_UNDEFINED;
183 err_str = "Unable to send a nlmsg";
184 goto add_mapping_error;
185 }
186 ret = iwpm_wait_complete_req(nlmsg_request);
187 return ret;
188add_mapping_error:
189 pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
190 if (skb)
191 dev_kfree_skb(skb);
192 if (nlmsg_request)
193 iwpm_free_nlmsg_request(&nlmsg_request->kref);
194 return ret;
195}
196
197/*
198 * iwpm_add_and_query_mapping - Send a netlink add and query
199 * mapping message to the port mapper
200 * nlmsg attributes:
201 * [IWPM_NLA_QUERY_MAPPING_SEQ]
202 * [IWPM_NLA_QUERY_LOCAL_ADDR]
203 * [IWPM_NLA_QUERY_REMOTE_ADDR]
204 */
205int iwpm_add_and_query_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client)
206{
207 struct sk_buff *skb = NULL;
208 struct iwpm_nlmsg_request *nlmsg_request = NULL;
209 struct nlmsghdr *nlh;
210 u32 msg_seq;
211 const char *err_str = "";
212 int ret = -EINVAL;
213
214 if (!iwpm_valid_client(nl_client)) {
215 err_str = "Invalid port mapper client";
216 goto query_mapping_error;
217 }
218 if (!iwpm_valid_pid())
219 return 0;
220 if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) {
221 err_str = "Unregistered port mapper client";
222 goto query_mapping_error;
223 }
224 ret = -ENOMEM;
225 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_QUERY_MAPPING, &nlh, nl_client);
226 if (!skb) {
227 err_str = "Unable to create a nlmsg";
228 goto query_mapping_error;
229 }
230 nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
231 nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq,
232 nl_client, GFP_KERNEL);
233 if (!nlmsg_request) {
234 err_str = "Unable to allocate netlink request";
235 goto query_mapping_error;
236 }
237 msg_seq = atomic_read(&echo_nlmsg_seq);
238
239 /* fill in the query message */
240 err_str = "Unable to put attribute of the nlmsg";
241 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
242 IWPM_NLA_QUERY_MAPPING_SEQ);
243 if (ret)
244 goto query_mapping_error;
245 ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
246 &pm_msg->loc_addr, IWPM_NLA_QUERY_LOCAL_ADDR);
247 if (ret)
248 goto query_mapping_error;
249 ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
250 &pm_msg->rem_addr, IWPM_NLA_QUERY_REMOTE_ADDR);
251 if (ret)
252 goto query_mapping_error;
253
254 nlmsg_end(skb, nlh);
255 nlmsg_request->req_buffer = pm_msg;
256
257 ret = rdma_nl_unicast_wait(skb, iwpm_user_pid);
258 if (ret) {
259 skb = NULL; /* skb is freed in the netlink send-op handling */
260 err_str = "Unable to send a nlmsg";
261 goto query_mapping_error;
262 }
263 ret = iwpm_wait_complete_req(nlmsg_request);
264 return ret;
265query_mapping_error:
266 pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
267 if (skb)
268 dev_kfree_skb(skb);
269 if (nlmsg_request)
270 iwpm_free_nlmsg_request(&nlmsg_request->kref);
271 return ret;
272}
273
274/*
275 * iwpm_remove_mapping - Send a netlink remove mapping message
276 * to the port mapper
277 * nlmsg attributes:
278 * [IWPM_NLA_MANAGE_MAPPING_SEQ]
279 * [IWPM_NLA_MANAGE_ADDR]
280 */
281int iwpm_remove_mapping(struct sockaddr_storage *local_addr, u8 nl_client)
282{
283 struct sk_buff *skb = NULL;
284 struct nlmsghdr *nlh;
285 u32 msg_seq;
286 const char *err_str = "";
287 int ret = -EINVAL;
288
289 if (!iwpm_valid_client(nl_client)) {
290 err_str = "Invalid port mapper client";
291 goto remove_mapping_error;
292 }
293 if (!iwpm_valid_pid())
294 return 0;
295 if (iwpm_check_registration(nl_client, IWPM_REG_UNDEF)) {
296 err_str = "Unregistered port mapper client";
297 goto remove_mapping_error;
298 }
299 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_REMOVE_MAPPING, &nlh, nl_client);
300 if (!skb) {
301 ret = -ENOMEM;
302 err_str = "Unable to create a nlmsg";
303 goto remove_mapping_error;
304 }
305 msg_seq = atomic_read(&echo_nlmsg_seq);
306 nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
307 err_str = "Unable to put attribute of the nlmsg";
308 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
309 IWPM_NLA_MANAGE_MAPPING_SEQ);
310 if (ret)
311 goto remove_mapping_error;
312 ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
313 local_addr, IWPM_NLA_MANAGE_ADDR);
314 if (ret)
315 goto remove_mapping_error;
316
317 nlmsg_end(skb, nlh);
318
319 ret = rdma_nl_unicast_wait(skb, iwpm_user_pid);
320 if (ret) {
321 skb = NULL; /* skb is freed in the netlink send-op handling */
322 iwpm_user_pid = IWPM_PID_UNDEFINED;
323 err_str = "Unable to send a nlmsg";
324 goto remove_mapping_error;
325 }
326 iwpm_print_sockaddr(local_addr,
327 "remove_mapping: Local sockaddr:");
328 return 0;
329remove_mapping_error:
330 pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
331 if (skb)
332 dev_kfree_skb_any(skb);
333 return ret;
334}
335
336/* netlink attribute policy for the received response to register pid request */
337static const struct nla_policy resp_reg_policy[IWPM_NLA_RREG_PID_MAX] = {
338 [IWPM_NLA_RREG_PID_SEQ] = { .type = NLA_U32 },
339 [IWPM_NLA_RREG_IBDEV_NAME] = { .type = NLA_STRING,
340 .len = IWPM_DEVNAME_SIZE - 1 },
341 [IWPM_NLA_RREG_ULIB_NAME] = { .type = NLA_STRING,
342 .len = IWPM_ULIBNAME_SIZE - 1 },
343 [IWPM_NLA_RREG_ULIB_VER] = { .type = NLA_U16 },
344 [IWPM_NLA_RREG_PID_ERR] = { .type = NLA_U16 }
345};
346
347/*
348 * iwpm_register_pid_cb - Process a port mapper response to
349 * iwpm_register_pid()
350 */
351int iwpm_register_pid_cb(struct sk_buff *skb, struct netlink_callback *cb)
352{
353 struct iwpm_nlmsg_request *nlmsg_request = NULL;
354 struct nlattr *nltb[IWPM_NLA_RREG_PID_MAX];
355 struct iwpm_dev_data *pm_msg;
356 char *dev_name, *iwpm_name;
357 u32 msg_seq;
358 u8 nl_client;
359 u16 iwpm_version;
360 const char *msg_type = "Register Pid response";
361
362 if (iwpm_parse_nlmsg(cb, IWPM_NLA_RREG_PID_MAX,
363 resp_reg_policy, nltb, msg_type))
364 return -EINVAL;
365
366 msg_seq = nla_get_u32(nltb[IWPM_NLA_RREG_PID_SEQ]);
367 nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
368 if (!nlmsg_request) {
369 pr_info("%s: Could not find a matching request (seq = %u)\n",
370 __func__, msg_seq);
371 return -EINVAL;
372 }
373 pm_msg = nlmsg_request->req_buffer;
374 nl_client = nlmsg_request->nl_client;
375 dev_name = (char *)nla_data(nltb[IWPM_NLA_RREG_IBDEV_NAME]);
376 iwpm_name = (char *)nla_data(nltb[IWPM_NLA_RREG_ULIB_NAME]);
377 iwpm_version = nla_get_u16(nltb[IWPM_NLA_RREG_ULIB_VER]);
378
379 /* check device name, ulib name and version */
380 if (strcmp(pm_msg->dev_name, dev_name) ||
381 strcmp(iwpm_ulib_name, iwpm_name) ||
382 iwpm_version != iwpm_ulib_version) {
383
384 pr_info("%s: Incorrect info (dev = %s name = %s version = %d)\n",
385 __func__, dev_name, iwpm_name, iwpm_version);
386 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
387 goto register_pid_response_exit;
388 }
389 iwpm_user_pid = cb->nlh->nlmsg_pid;
390 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
391 pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
392 __func__, iwpm_user_pid);
393 if (iwpm_valid_client(nl_client))
394 iwpm_set_registration(nl_client, IWPM_REG_VALID);
395register_pid_response_exit:
396 nlmsg_request->request_done = 1;
397 /* always for found nlmsg_request */
398 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
399 barrier();
400 up(&nlmsg_request->sem);
401 return 0;
402}
403
404/* netlink attribute policy for the received response to add mapping request */
405static const struct nla_policy resp_add_policy[IWPM_NLA_RMANAGE_MAPPING_MAX] = {
406 [IWPM_NLA_MANAGE_MAPPING_SEQ] = { .type = NLA_U32 },
407 [IWPM_NLA_MANAGE_ADDR] = { .len = sizeof(struct sockaddr_storage) },
408 [IWPM_NLA_MANAGE_MAPPED_LOC_ADDR] = { .len = sizeof(struct sockaddr_storage) },
409 [IWPM_NLA_RMANAGE_MAPPING_ERR] = { .type = NLA_U16 }
410};
411
412/*
413 * iwpm_add_mapping_cb - Process a port mapper response to
414 * iwpm_add_mapping()
415 */
416int iwpm_add_mapping_cb(struct sk_buff *skb, struct netlink_callback *cb)
417{
418 struct iwpm_sa_data *pm_msg;
419 struct iwpm_nlmsg_request *nlmsg_request = NULL;
420 struct nlattr *nltb[IWPM_NLA_RMANAGE_MAPPING_MAX];
421 struct sockaddr_storage *local_sockaddr;
422 struct sockaddr_storage *mapped_sockaddr;
423 const char *msg_type;
424 u32 msg_seq;
425
426 msg_type = "Add Mapping response";
427 if (iwpm_parse_nlmsg(cb, IWPM_NLA_RMANAGE_MAPPING_MAX,
428 resp_add_policy, nltb, msg_type))
429 return -EINVAL;
430
431 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
432
433 msg_seq = nla_get_u32(nltb[IWPM_NLA_MANAGE_MAPPING_SEQ]);
434 nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
435 if (!nlmsg_request) {
436 pr_info("%s: Could not find a matching request (seq = %u)\n",
437 __func__, msg_seq);
438 return -EINVAL;
439 }
440 pm_msg = nlmsg_request->req_buffer;
441 local_sockaddr = (struct sockaddr_storage *)
442 nla_data(nltb[IWPM_NLA_MANAGE_ADDR]);
443 mapped_sockaddr = (struct sockaddr_storage *)
444 nla_data(nltb[IWPM_NLA_MANAGE_MAPPED_LOC_ADDR]);
445
446 if (iwpm_compare_sockaddr(local_sockaddr, &pm_msg->loc_addr)) {
447 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
448 goto add_mapping_response_exit;
449 }
450 if (mapped_sockaddr->ss_family != local_sockaddr->ss_family) {
451 pr_info("%s: Sockaddr family doesn't match the requested one\n",
452 __func__);
453 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
454 goto add_mapping_response_exit;
455 }
456 memcpy(&pm_msg->mapped_loc_addr, mapped_sockaddr,
457 sizeof(*mapped_sockaddr));
458 iwpm_print_sockaddr(&pm_msg->loc_addr,
459 "add_mapping: Local sockaddr:");
460 iwpm_print_sockaddr(&pm_msg->mapped_loc_addr,
461 "add_mapping: Mapped local sockaddr:");
462
463add_mapping_response_exit:
464 nlmsg_request->request_done = 1;
465 /* always for found request */
466 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
467 barrier();
468 up(&nlmsg_request->sem);
469 return 0;
470}
471
472/* netlink attribute policy for the response to add and query mapping request
473 * and response with remote address info */
474static const struct nla_policy resp_query_policy[IWPM_NLA_RQUERY_MAPPING_MAX] = {
475 [IWPM_NLA_QUERY_MAPPING_SEQ] = { .type = NLA_U32 },
476 [IWPM_NLA_QUERY_LOCAL_ADDR] = { .len = sizeof(struct sockaddr_storage) },
477 [IWPM_NLA_QUERY_REMOTE_ADDR] = { .len = sizeof(struct sockaddr_storage) },
478 [IWPM_NLA_RQUERY_MAPPED_LOC_ADDR] = { .len = sizeof(struct sockaddr_storage) },
479 [IWPM_NLA_RQUERY_MAPPED_REM_ADDR] = { .len = sizeof(struct sockaddr_storage) },
480 [IWPM_NLA_RQUERY_MAPPING_ERR] = { .type = NLA_U16 }
481};
482
483/*
484 * iwpm_add_and_query_mapping_cb - Process a port mapper response to
485 * iwpm_add_and_query_mapping()
486 */
487int iwpm_add_and_query_mapping_cb(struct sk_buff *skb,
488 struct netlink_callback *cb)
489{
490 struct iwpm_sa_data *pm_msg;
491 struct iwpm_nlmsg_request *nlmsg_request = NULL;
492 struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX];
493 struct sockaddr_storage *local_sockaddr, *remote_sockaddr;
494 struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr;
495 const char *msg_type;
496 u32 msg_seq;
497 u16 err_code;
498
499 msg_type = "Query Mapping response";
500 if (iwpm_parse_nlmsg(cb, IWPM_NLA_RQUERY_MAPPING_MAX,
501 resp_query_policy, nltb, msg_type))
502 return -EINVAL;
503 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
504
505 msg_seq = nla_get_u32(nltb[IWPM_NLA_QUERY_MAPPING_SEQ]);
506 nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
507 if (!nlmsg_request) {
508 pr_info("%s: Could not find a matching request (seq = %u)\n",
509 __func__, msg_seq);
510 return -EINVAL;
511 }
512 pm_msg = nlmsg_request->req_buffer;
513 local_sockaddr = (struct sockaddr_storage *)
514 nla_data(nltb[IWPM_NLA_QUERY_LOCAL_ADDR]);
515 remote_sockaddr = (struct sockaddr_storage *)
516 nla_data(nltb[IWPM_NLA_QUERY_REMOTE_ADDR]);
517 mapped_loc_sockaddr = (struct sockaddr_storage *)
518 nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]);
519 mapped_rem_sockaddr = (struct sockaddr_storage *)
520 nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]);
521
522 err_code = nla_get_u16(nltb[IWPM_NLA_RQUERY_MAPPING_ERR]);
523 if (err_code == IWPM_REMOTE_QUERY_REJECT) {
524 pr_info("%s: Received a Reject (pid = %u, echo seq = %u)\n",
525 __func__, cb->nlh->nlmsg_pid, msg_seq);
526 nlmsg_request->err_code = IWPM_REMOTE_QUERY_REJECT;
527 }
528 if (iwpm_compare_sockaddr(local_sockaddr, &pm_msg->loc_addr) ||
529 iwpm_compare_sockaddr(remote_sockaddr, &pm_msg->rem_addr)) {
530 pr_info("%s: Incorrect local sockaddr\n", __func__);
531 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
532 goto query_mapping_response_exit;
533 }
534 if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family ||
535 mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) {
536 pr_info("%s: Sockaddr family doesn't match the requested one\n",
537 __func__);
538 nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
539 goto query_mapping_response_exit;
540 }
541 memcpy(&pm_msg->mapped_loc_addr, mapped_loc_sockaddr,
542 sizeof(*mapped_loc_sockaddr));
543 memcpy(&pm_msg->mapped_rem_addr, mapped_rem_sockaddr,
544 sizeof(*mapped_rem_sockaddr));
545
546 iwpm_print_sockaddr(&pm_msg->loc_addr,
547 "query_mapping: Local sockaddr:");
548 iwpm_print_sockaddr(&pm_msg->mapped_loc_addr,
549 "query_mapping: Mapped local sockaddr:");
550 iwpm_print_sockaddr(&pm_msg->rem_addr,
551 "query_mapping: Remote sockaddr:");
552 iwpm_print_sockaddr(&pm_msg->mapped_rem_addr,
553 "query_mapping: Mapped remote sockaddr:");
554query_mapping_response_exit:
555 nlmsg_request->request_done = 1;
556 /* always for found request */
557 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
558 barrier();
559 up(&nlmsg_request->sem);
560 return 0;
561}
562
563/*
564 * iwpm_remote_info_cb - Process a port mapper message, containing
565 * the remote connecting peer address info
566 */
567int iwpm_remote_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
568{
569 struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX];
570 struct sockaddr_storage *local_sockaddr, *remote_sockaddr;
571 struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr;
572 struct iwpm_remote_info *rem_info;
573 const char *msg_type;
574 u8 nl_client;
575 int ret = -EINVAL;
576
577 msg_type = "Remote Mapping info";
578 if (iwpm_parse_nlmsg(cb, IWPM_NLA_RQUERY_MAPPING_MAX,
579 resp_query_policy, nltb, msg_type))
580 return ret;
581
582 nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
583 if (!iwpm_valid_client(nl_client)) {
584 pr_info("%s: Invalid port mapper client = %d\n",
585 __func__, nl_client);
586 return ret;
587 }
588 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
589
590 local_sockaddr = (struct sockaddr_storage *)
591 nla_data(nltb[IWPM_NLA_QUERY_LOCAL_ADDR]);
592 remote_sockaddr = (struct sockaddr_storage *)
593 nla_data(nltb[IWPM_NLA_QUERY_REMOTE_ADDR]);
594 mapped_loc_sockaddr = (struct sockaddr_storage *)
595 nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]);
596 mapped_rem_sockaddr = (struct sockaddr_storage *)
597 nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]);
598
599 if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family ||
600 mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) {
601 pr_info("%s: Sockaddr family doesn't match the requested one\n",
602 __func__);
603 return ret;
604 }
605 rem_info = kzalloc(sizeof(struct iwpm_remote_info), GFP_ATOMIC);
606 if (!rem_info) {
607 ret = -ENOMEM;
608 return ret;
609 }
610 memcpy(&rem_info->mapped_loc_sockaddr, mapped_loc_sockaddr,
611 sizeof(struct sockaddr_storage));
612 memcpy(&rem_info->remote_sockaddr, remote_sockaddr,
613 sizeof(struct sockaddr_storage));
614 memcpy(&rem_info->mapped_rem_sockaddr, mapped_rem_sockaddr,
615 sizeof(struct sockaddr_storage));
616 rem_info->nl_client = nl_client;
617
618 iwpm_add_remote_info(rem_info);
619
620 iwpm_print_sockaddr(local_sockaddr,
621 "remote_info: Local sockaddr:");
622 iwpm_print_sockaddr(mapped_loc_sockaddr,
623 "remote_info: Mapped local sockaddr:");
624 iwpm_print_sockaddr(remote_sockaddr,
625 "remote_info: Remote sockaddr:");
626 iwpm_print_sockaddr(mapped_rem_sockaddr,
627 "remote_info: Mapped remote sockaddr:");
628 return ret;
629}
630
631/* netlink attribute policy for the received request for mapping info */
632static const struct nla_policy resp_mapinfo_policy[IWPM_NLA_MAPINFO_REQ_MAX] = {
633 [IWPM_NLA_MAPINFO_ULIB_NAME] = { .type = NLA_STRING,
634 .len = IWPM_ULIBNAME_SIZE - 1 },
635 [IWPM_NLA_MAPINFO_ULIB_VER] = { .type = NLA_U16 }
636};
637
638/*
639 * iwpm_mapping_info_cb - Process a port mapper request for mapping info
640 */
641int iwpm_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
642{
643 struct nlattr *nltb[IWPM_NLA_MAPINFO_REQ_MAX];
644 const char *msg_type = "Mapping Info response";
645 u8 nl_client;
646 char *iwpm_name;
647 u16 iwpm_version;
648 int ret = -EINVAL;
649
650 if (iwpm_parse_nlmsg(cb, IWPM_NLA_MAPINFO_REQ_MAX,
651 resp_mapinfo_policy, nltb, msg_type)) {
652 pr_info("%s: Unable to parse nlmsg\n", __func__);
653 return ret;
654 }
655 iwpm_name = (char *)nla_data(nltb[IWPM_NLA_MAPINFO_ULIB_NAME]);
656 iwpm_version = nla_get_u16(nltb[IWPM_NLA_MAPINFO_ULIB_VER]);
657 if (strcmp(iwpm_ulib_name, iwpm_name) ||
658 iwpm_version != iwpm_ulib_version) {
659 pr_info("%s: Invalid port mapper name = %s version = %d\n",
660 __func__, iwpm_name, iwpm_version);
661 return ret;
662 }
663 nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
664 if (!iwpm_valid_client(nl_client)) {
665 pr_info("%s: Invalid port mapper client = %d\n",
666 __func__, nl_client);
667 return ret;
668 }
669 iwpm_set_registration(nl_client, IWPM_REG_INCOMPL);
670 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
671 iwpm_user_pid = cb->nlh->nlmsg_pid;
672 if (!iwpm_mapinfo_available())
673 return 0;
674 pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
675 __func__, iwpm_user_pid);
676 ret = iwpm_send_mapinfo(nl_client, iwpm_user_pid);
677 return ret;
678}
679
680/* netlink attribute policy for the received mapping info ack */
681static const struct nla_policy ack_mapinfo_policy[IWPM_NLA_MAPINFO_NUM_MAX] = {
682 [IWPM_NLA_MAPINFO_SEQ] = { .type = NLA_U32 },
683 [IWPM_NLA_MAPINFO_SEND_NUM] = { .type = NLA_U32 },
684 [IWPM_NLA_MAPINFO_ACK_NUM] = { .type = NLA_U32 }
685};
686
687/*
688 * iwpm_ack_mapping_info_cb - Process a port mapper ack for
689 * the provided mapping info records
690 */
691int iwpm_ack_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
692{
693 struct nlattr *nltb[IWPM_NLA_MAPINFO_NUM_MAX];
694 u32 mapinfo_send, mapinfo_ack;
695 const char *msg_type = "Mapping Info Ack";
696
697 if (iwpm_parse_nlmsg(cb, IWPM_NLA_MAPINFO_NUM_MAX,
698 ack_mapinfo_policy, nltb, msg_type))
699 return -EINVAL;
700 mapinfo_send = nla_get_u32(nltb[IWPM_NLA_MAPINFO_SEND_NUM]);
701 mapinfo_ack = nla_get_u32(nltb[IWPM_NLA_MAPINFO_ACK_NUM]);
702 if (mapinfo_ack != mapinfo_send)
703 pr_info("%s: Invalid mapinfo number (sent = %u ack-ed = %u)\n",
704 __func__, mapinfo_send, mapinfo_ack);
705 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
706 return 0;
707}
708
709/* netlink attribute policy for the received port mapper error message */
710static const struct nla_policy map_error_policy[IWPM_NLA_ERR_MAX] = {
711 [IWPM_NLA_ERR_SEQ] = { .type = NLA_U32 },
712 [IWPM_NLA_ERR_CODE] = { .type = NLA_U16 },
713};
714
715/*
716 * iwpm_mapping_error_cb - Process a port mapper error message
717 */
718int iwpm_mapping_error_cb(struct sk_buff *skb, struct netlink_callback *cb)
719{
720 struct iwpm_nlmsg_request *nlmsg_request = NULL;
721 int nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
722 struct nlattr *nltb[IWPM_NLA_ERR_MAX];
723 u32 msg_seq;
724 u16 err_code;
725 const char *msg_type = "Mapping Error Msg";
726
727 if (iwpm_parse_nlmsg(cb, IWPM_NLA_ERR_MAX,
728 map_error_policy, nltb, msg_type))
729 return -EINVAL;
730
731 msg_seq = nla_get_u32(nltb[IWPM_NLA_ERR_SEQ]);
732 err_code = nla_get_u16(nltb[IWPM_NLA_ERR_CODE]);
733 pr_info("%s: Received msg seq = %u err code = %u client = %d\n",
734 __func__, msg_seq, err_code, nl_client);
735 /* look for nlmsg_request */
736 nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
737 if (!nlmsg_request) {
738 /* not all errors have associated requests */
739 pr_debug("Could not find matching req (seq = %u)\n", msg_seq);
740 return 0;
741 }
742 atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
743 nlmsg_request->err_code = err_code;
744 nlmsg_request->request_done = 1;
745 /* always for found request */
746 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
747 barrier();
748 up(&nlmsg_request->sem);
749 return 0;
750}