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