1 /* 2 * Copyright (c) 2017 Mellanox Technologies. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. Neither the names of the copyright holders nor the names of its 13 * contributors may be used to endorse or promote products derived from 14 * this software without specific prior written permission. 15 * 16 * Alternatively, this software may be distributed under the terms of the 17 * GNU General Public License ("GPL") version 2 as published by the Free 18 * Software Foundation. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <linux/module.h> 34 #include <linux/pid.h> 35 #include <linux/pid_namespace.h> 36 #include <linux/mutex.h> 37 #include <net/netlink.h> 38 #include <rdma/rdma_cm.h> 39 #include <rdma/rdma_netlink.h> 40 41 #include "core_priv.h" 42 #include "cma_priv.h" 43 #include "restrack.h" 44 #include "uverbs.h" 45 46 typedef int (*res_fill_func_t)(struct sk_buff*, bool, 47 struct rdma_restrack_entry*, uint32_t); 48 49 /* 50 * Sort array elements by the netlink attribute name 51 */ 52 static const struct nla_policy nldev_policy[RDMA_NLDEV_ATTR_MAX] = { 53 [RDMA_NLDEV_ATTR_CHARDEV] = { .type = NLA_U64 }, 54 [RDMA_NLDEV_ATTR_CHARDEV_ABI] = { .type = NLA_U64 }, 55 [RDMA_NLDEV_ATTR_CHARDEV_NAME] = { .type = NLA_NUL_STRING, 56 .len = RDMA_NLDEV_ATTR_EMPTY_STRING }, 57 [RDMA_NLDEV_ATTR_CHARDEV_TYPE] = { .type = NLA_NUL_STRING, 58 .len = RDMA_NLDEV_ATTR_CHARDEV_TYPE_SIZE }, 59 [RDMA_NLDEV_ATTR_DEV_DIM] = { .type = NLA_U8 }, 60 [RDMA_NLDEV_ATTR_DEV_INDEX] = { .type = NLA_U32 }, 61 [RDMA_NLDEV_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, 62 .len = IB_DEVICE_NAME_MAX }, 63 [RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = { .type = NLA_U8 }, 64 [RDMA_NLDEV_ATTR_DEV_PROTOCOL] = { .type = NLA_NUL_STRING, 65 .len = RDMA_NLDEV_ATTR_EMPTY_STRING }, 66 [RDMA_NLDEV_ATTR_DRIVER] = { .type = NLA_NESTED }, 67 [RDMA_NLDEV_ATTR_DRIVER_ENTRY] = { .type = NLA_NESTED }, 68 [RDMA_NLDEV_ATTR_DRIVER_PRINT_TYPE] = { .type = NLA_U8 }, 69 [RDMA_NLDEV_ATTR_DRIVER_STRING] = { .type = NLA_NUL_STRING, 70 .len = RDMA_NLDEV_ATTR_EMPTY_STRING }, 71 [RDMA_NLDEV_ATTR_DRIVER_S32] = { .type = NLA_S32 }, 72 [RDMA_NLDEV_ATTR_DRIVER_S64] = { .type = NLA_S64 }, 73 [RDMA_NLDEV_ATTR_DRIVER_U32] = { .type = NLA_U32 }, 74 [RDMA_NLDEV_ATTR_DRIVER_U64] = { .type = NLA_U64 }, 75 [RDMA_NLDEV_ATTR_FW_VERSION] = { .type = NLA_NUL_STRING, 76 .len = RDMA_NLDEV_ATTR_EMPTY_STRING }, 77 [RDMA_NLDEV_ATTR_LID] = { .type = NLA_U32 }, 78 [RDMA_NLDEV_ATTR_LINK_TYPE] = { .type = NLA_NUL_STRING, 79 .len = IFNAMSIZ }, 80 [RDMA_NLDEV_ATTR_LMC] = { .type = NLA_U8 }, 81 [RDMA_NLDEV_ATTR_NDEV_INDEX] = { .type = NLA_U32 }, 82 [RDMA_NLDEV_ATTR_NDEV_NAME] = { .type = NLA_NUL_STRING, 83 .len = IFNAMSIZ }, 84 [RDMA_NLDEV_ATTR_NODE_GUID] = { .type = NLA_U64 }, 85 [RDMA_NLDEV_ATTR_PORT_INDEX] = { .type = NLA_U32 }, 86 [RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = { .type = NLA_U8 }, 87 [RDMA_NLDEV_ATTR_PORT_STATE] = { .type = NLA_U8 }, 88 [RDMA_NLDEV_ATTR_RES_CM_ID] = { .type = NLA_NESTED }, 89 [RDMA_NLDEV_ATTR_RES_CM_IDN] = { .type = NLA_U32 }, 90 [RDMA_NLDEV_ATTR_RES_CM_ID_ENTRY] = { .type = NLA_NESTED }, 91 [RDMA_NLDEV_ATTR_RES_CQ] = { .type = NLA_NESTED }, 92 [RDMA_NLDEV_ATTR_RES_CQE] = { .type = NLA_U32 }, 93 [RDMA_NLDEV_ATTR_RES_CQN] = { .type = NLA_U32 }, 94 [RDMA_NLDEV_ATTR_RES_CQ_ENTRY] = { .type = NLA_NESTED }, 95 [RDMA_NLDEV_ATTR_RES_CTXN] = { .type = NLA_U32 }, 96 [RDMA_NLDEV_ATTR_RES_DST_ADDR] = { 97 .len = sizeof(struct __kernel_sockaddr_storage) }, 98 [RDMA_NLDEV_ATTR_RES_IOVA] = { .type = NLA_U64 }, 99 [RDMA_NLDEV_ATTR_RES_KERN_NAME] = { .type = NLA_NUL_STRING, 100 .len = RDMA_NLDEV_ATTR_EMPTY_STRING }, 101 [RDMA_NLDEV_ATTR_RES_LKEY] = { .type = NLA_U32 }, 102 [RDMA_NLDEV_ATTR_RES_LOCAL_DMA_LKEY] = { .type = NLA_U32 }, 103 [RDMA_NLDEV_ATTR_RES_LQPN] = { .type = NLA_U32 }, 104 [RDMA_NLDEV_ATTR_RES_MR] = { .type = NLA_NESTED }, 105 [RDMA_NLDEV_ATTR_RES_MRLEN] = { .type = NLA_U64 }, 106 [RDMA_NLDEV_ATTR_RES_MRN] = { .type = NLA_U32 }, 107 [RDMA_NLDEV_ATTR_RES_MR_ENTRY] = { .type = NLA_NESTED }, 108 [RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE] = { .type = NLA_U8 }, 109 [RDMA_NLDEV_ATTR_RES_PD] = { .type = NLA_NESTED }, 110 [RDMA_NLDEV_ATTR_RES_PDN] = { .type = NLA_U32 }, 111 [RDMA_NLDEV_ATTR_RES_PD_ENTRY] = { .type = NLA_NESTED }, 112 [RDMA_NLDEV_ATTR_RES_PID] = { .type = NLA_U32 }, 113 [RDMA_NLDEV_ATTR_RES_POLL_CTX] = { .type = NLA_U8 }, 114 [RDMA_NLDEV_ATTR_RES_PS] = { .type = NLA_U32 }, 115 [RDMA_NLDEV_ATTR_RES_QP] = { .type = NLA_NESTED }, 116 [RDMA_NLDEV_ATTR_RES_QP_ENTRY] = { .type = NLA_NESTED }, 117 [RDMA_NLDEV_ATTR_RES_RKEY] = { .type = NLA_U32 }, 118 [RDMA_NLDEV_ATTR_RES_RQPN] = { .type = NLA_U32 }, 119 [RDMA_NLDEV_ATTR_RES_RQ_PSN] = { .type = NLA_U32 }, 120 [RDMA_NLDEV_ATTR_RES_SQ_PSN] = { .type = NLA_U32 }, 121 [RDMA_NLDEV_ATTR_RES_SRC_ADDR] = { 122 .len = sizeof(struct __kernel_sockaddr_storage) }, 123 [RDMA_NLDEV_ATTR_RES_STATE] = { .type = NLA_U8 }, 124 [RDMA_NLDEV_ATTR_RES_SUMMARY] = { .type = NLA_NESTED }, 125 [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY] = { .type = NLA_NESTED }, 126 [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]= { .type = NLA_U64 }, 127 [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME]= { .type = NLA_NUL_STRING, 128 .len = RDMA_NLDEV_ATTR_EMPTY_STRING }, 129 [RDMA_NLDEV_ATTR_RES_TYPE] = { .type = NLA_U8 }, 130 [RDMA_NLDEV_ATTR_RES_UNSAFE_GLOBAL_RKEY]= { .type = NLA_U32 }, 131 [RDMA_NLDEV_ATTR_RES_USECNT] = { .type = NLA_U64 }, 132 [RDMA_NLDEV_ATTR_SM_LID] = { .type = NLA_U32 }, 133 [RDMA_NLDEV_ATTR_SUBNET_PREFIX] = { .type = NLA_U64 }, 134 [RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK] = { .type = NLA_U32 }, 135 [RDMA_NLDEV_ATTR_STAT_MODE] = { .type = NLA_U32 }, 136 [RDMA_NLDEV_ATTR_STAT_RES] = { .type = NLA_U32 }, 137 [RDMA_NLDEV_ATTR_STAT_COUNTER] = { .type = NLA_NESTED }, 138 [RDMA_NLDEV_ATTR_STAT_COUNTER_ENTRY] = { .type = NLA_NESTED }, 139 [RDMA_NLDEV_ATTR_STAT_COUNTER_ID] = { .type = NLA_U32 }, 140 [RDMA_NLDEV_ATTR_STAT_HWCOUNTERS] = { .type = NLA_NESTED }, 141 [RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY] = { .type = NLA_NESTED }, 142 [RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_NAME] = { .type = NLA_NUL_STRING }, 143 [RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_VALUE] = { .type = NLA_U64 }, 144 [RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = { .type = NLA_U64 }, 145 [RDMA_NLDEV_ATTR_UVERBS_DRIVER_ID] = { .type = NLA_U32 }, 146 [RDMA_NLDEV_NET_NS_FD] = { .type = NLA_U32 }, 147 [RDMA_NLDEV_SYS_ATTR_NETNS_MODE] = { .type = NLA_U8 }, 148 }; 149 150 static int put_driver_name_print_type(struct sk_buff *msg, const char *name, 151 enum rdma_nldev_print_type print_type) 152 { 153 if (nla_put_string(msg, RDMA_NLDEV_ATTR_DRIVER_STRING, name)) 154 return -EMSGSIZE; 155 if (print_type != RDMA_NLDEV_PRINT_TYPE_UNSPEC && 156 nla_put_u8(msg, RDMA_NLDEV_ATTR_DRIVER_PRINT_TYPE, print_type)) 157 return -EMSGSIZE; 158 159 return 0; 160 } 161 162 static int _rdma_nl_put_driver_u32(struct sk_buff *msg, const char *name, 163 enum rdma_nldev_print_type print_type, 164 u32 value) 165 { 166 if (put_driver_name_print_type(msg, name, print_type)) 167 return -EMSGSIZE; 168 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_DRIVER_U32, value)) 169 return -EMSGSIZE; 170 171 return 0; 172 } 173 174 static int _rdma_nl_put_driver_u64(struct sk_buff *msg, const char *name, 175 enum rdma_nldev_print_type print_type, 176 u64 value) 177 { 178 if (put_driver_name_print_type(msg, name, print_type)) 179 return -EMSGSIZE; 180 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_DRIVER_U64, value, 181 RDMA_NLDEV_ATTR_PAD)) 182 return -EMSGSIZE; 183 184 return 0; 185 } 186 187 int rdma_nl_put_driver_string(struct sk_buff *msg, const char *name, 188 const char *str) 189 { 190 if (put_driver_name_print_type(msg, name, 191 RDMA_NLDEV_PRINT_TYPE_UNSPEC)) 192 return -EMSGSIZE; 193 if (nla_put_string(msg, RDMA_NLDEV_ATTR_DRIVER_STRING, str)) 194 return -EMSGSIZE; 195 196 return 0; 197 } 198 EXPORT_SYMBOL(rdma_nl_put_driver_string); 199 200 int rdma_nl_put_driver_u32(struct sk_buff *msg, const char *name, u32 value) 201 { 202 return _rdma_nl_put_driver_u32(msg, name, RDMA_NLDEV_PRINT_TYPE_UNSPEC, 203 value); 204 } 205 EXPORT_SYMBOL(rdma_nl_put_driver_u32); 206 207 int rdma_nl_put_driver_u32_hex(struct sk_buff *msg, const char *name, 208 u32 value) 209 { 210 return _rdma_nl_put_driver_u32(msg, name, RDMA_NLDEV_PRINT_TYPE_HEX, 211 value); 212 } 213 EXPORT_SYMBOL(rdma_nl_put_driver_u32_hex); 214 215 int rdma_nl_put_driver_u64(struct sk_buff *msg, const char *name, u64 value) 216 { 217 return _rdma_nl_put_driver_u64(msg, name, RDMA_NLDEV_PRINT_TYPE_UNSPEC, 218 value); 219 } 220 EXPORT_SYMBOL(rdma_nl_put_driver_u64); 221 222 int rdma_nl_put_driver_u64_hex(struct sk_buff *msg, const char *name, u64 value) 223 { 224 return _rdma_nl_put_driver_u64(msg, name, RDMA_NLDEV_PRINT_TYPE_HEX, 225 value); 226 } 227 EXPORT_SYMBOL(rdma_nl_put_driver_u64_hex); 228 229 static int fill_nldev_handle(struct sk_buff *msg, struct ib_device *device) 230 { 231 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_DEV_INDEX, device->index)) 232 return -EMSGSIZE; 233 if (nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_NAME, 234 dev_name(&device->dev))) 235 return -EMSGSIZE; 236 237 return 0; 238 } 239 240 static int fill_dev_info(struct sk_buff *msg, struct ib_device *device) 241 { 242 char fw[IB_FW_VERSION_NAME_MAX]; 243 int ret = 0; 244 u8 port; 245 246 if (fill_nldev_handle(msg, device)) 247 return -EMSGSIZE; 248 249 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, rdma_end_port(device))) 250 return -EMSGSIZE; 251 252 BUILD_BUG_ON(sizeof(device->attrs.device_cap_flags) != sizeof(u64)); 253 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_CAP_FLAGS, 254 device->attrs.device_cap_flags, 255 RDMA_NLDEV_ATTR_PAD)) 256 return -EMSGSIZE; 257 258 ib_get_device_fw_str(device, fw); 259 /* Device without FW has strlen(fw) = 0 */ 260 if (strlen(fw) && nla_put_string(msg, RDMA_NLDEV_ATTR_FW_VERSION, fw)) 261 return -EMSGSIZE; 262 263 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_NODE_GUID, 264 be64_to_cpu(device->node_guid), 265 RDMA_NLDEV_ATTR_PAD)) 266 return -EMSGSIZE; 267 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_SYS_IMAGE_GUID, 268 be64_to_cpu(device->attrs.sys_image_guid), 269 RDMA_NLDEV_ATTR_PAD)) 270 return -EMSGSIZE; 271 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_DEV_NODE_TYPE, device->node_type)) 272 return -EMSGSIZE; 273 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_DEV_DIM, device->use_cq_dim)) 274 return -EMSGSIZE; 275 276 /* 277 * Link type is determined on first port and mlx4 device 278 * which can potentially have two different link type for the same 279 * IB device is considered as better to be avoided in the future, 280 */ 281 port = rdma_start_port(device); 282 if (rdma_cap_opa_mad(device, port)) 283 ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, "opa"); 284 else if (rdma_protocol_ib(device, port)) 285 ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, "ib"); 286 else if (rdma_protocol_iwarp(device, port)) 287 ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, "iw"); 288 else if (rdma_protocol_roce(device, port)) 289 ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, "roce"); 290 else if (rdma_protocol_usnic(device, port)) 291 ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, 292 "usnic"); 293 return ret; 294 } 295 296 static int fill_port_info(struct sk_buff *msg, 297 struct ib_device *device, u32 port, 298 const struct net *net) 299 { 300 struct net_device *netdev = NULL; 301 struct ib_port_attr attr; 302 int ret; 303 u64 cap_flags = 0; 304 305 if (fill_nldev_handle(msg, device)) 306 return -EMSGSIZE; 307 308 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port)) 309 return -EMSGSIZE; 310 311 ret = ib_query_port(device, port, &attr); 312 if (ret) 313 return ret; 314 315 if (rdma_protocol_ib(device, port)) { 316 BUILD_BUG_ON((sizeof(attr.port_cap_flags) + 317 sizeof(attr.port_cap_flags2)) > sizeof(u64)); 318 cap_flags = attr.port_cap_flags | 319 ((u64)attr.port_cap_flags2 << 32); 320 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_CAP_FLAGS, 321 cap_flags, RDMA_NLDEV_ATTR_PAD)) 322 return -EMSGSIZE; 323 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_SUBNET_PREFIX, 324 attr.subnet_prefix, RDMA_NLDEV_ATTR_PAD)) 325 return -EMSGSIZE; 326 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_LID, attr.lid)) 327 return -EMSGSIZE; 328 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_SM_LID, attr.sm_lid)) 329 return -EMSGSIZE; 330 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_LMC, attr.lmc)) 331 return -EMSGSIZE; 332 } 333 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_PORT_STATE, attr.state)) 334 return -EMSGSIZE; 335 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_PORT_PHYS_STATE, attr.phys_state)) 336 return -EMSGSIZE; 337 338 netdev = ib_device_get_netdev(device, port); 339 if (netdev && net_eq(dev_net(netdev), net)) { 340 ret = nla_put_u32(msg, 341 RDMA_NLDEV_ATTR_NDEV_INDEX, netdev->ifindex); 342 if (ret) 343 goto out; 344 ret = nla_put_string(msg, 345 RDMA_NLDEV_ATTR_NDEV_NAME, netdev->name); 346 } 347 348 out: 349 if (netdev) 350 dev_put(netdev); 351 return ret; 352 } 353 354 static int fill_res_info_entry(struct sk_buff *msg, 355 const char *name, u64 curr) 356 { 357 struct nlattr *entry_attr; 358 359 entry_attr = nla_nest_start_noflag(msg, 360 RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY); 361 if (!entry_attr) 362 return -EMSGSIZE; 363 364 if (nla_put_string(msg, RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME, name)) 365 goto err; 366 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR, curr, 367 RDMA_NLDEV_ATTR_PAD)) 368 goto err; 369 370 nla_nest_end(msg, entry_attr); 371 return 0; 372 373 err: 374 nla_nest_cancel(msg, entry_attr); 375 return -EMSGSIZE; 376 } 377 378 static int fill_res_info(struct sk_buff *msg, struct ib_device *device) 379 { 380 static const char * const names[RDMA_RESTRACK_MAX] = { 381 [RDMA_RESTRACK_PD] = "pd", 382 [RDMA_RESTRACK_CQ] = "cq", 383 [RDMA_RESTRACK_QP] = "qp", 384 [RDMA_RESTRACK_CM_ID] = "cm_id", 385 [RDMA_RESTRACK_MR] = "mr", 386 [RDMA_RESTRACK_CTX] = "ctx", 387 }; 388 389 struct nlattr *table_attr; 390 int ret, i, curr; 391 392 if (fill_nldev_handle(msg, device)) 393 return -EMSGSIZE; 394 395 table_attr = nla_nest_start_noflag(msg, RDMA_NLDEV_ATTR_RES_SUMMARY); 396 if (!table_attr) 397 return -EMSGSIZE; 398 399 for (i = 0; i < RDMA_RESTRACK_MAX; i++) { 400 if (!names[i]) 401 continue; 402 curr = rdma_restrack_count(device, i); 403 ret = fill_res_info_entry(msg, names[i], curr); 404 if (ret) 405 goto err; 406 } 407 408 nla_nest_end(msg, table_attr); 409 return 0; 410 411 err: 412 nla_nest_cancel(msg, table_attr); 413 return ret; 414 } 415 416 static int fill_res_name_pid(struct sk_buff *msg, 417 struct rdma_restrack_entry *res) 418 { 419 int err = 0; 420 421 /* 422 * For user resources, user is should read /proc/PID/comm to get the 423 * name of the task file. 424 */ 425 if (rdma_is_kernel_res(res)) { 426 err = nla_put_string(msg, RDMA_NLDEV_ATTR_RES_KERN_NAME, 427 res->kern_name); 428 } else { 429 pid_t pid; 430 431 pid = task_pid_vnr(res->task); 432 /* 433 * Task is dead and in zombie state. 434 * There is no need to print PID anymore. 435 */ 436 if (pid) 437 /* 438 * This part is racy, task can be killed and PID will 439 * be zero right here but it is ok, next query won't 440 * return PID. We don't promise real-time reflection 441 * of SW objects. 442 */ 443 err = nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PID, pid); 444 } 445 446 return err ? -EMSGSIZE : 0; 447 } 448 449 static bool fill_res_entry(struct ib_device *dev, struct sk_buff *msg, 450 struct rdma_restrack_entry *res) 451 { 452 if (!dev->ops.fill_res_entry) 453 return false; 454 return dev->ops.fill_res_entry(msg, res); 455 } 456 457 static bool fill_stat_entry(struct ib_device *dev, struct sk_buff *msg, 458 struct rdma_restrack_entry *res) 459 { 460 if (!dev->ops.fill_stat_entry) 461 return false; 462 return dev->ops.fill_stat_entry(msg, res); 463 } 464 465 static int fill_res_qp_entry(struct sk_buff *msg, bool has_cap_net_admin, 466 struct rdma_restrack_entry *res, uint32_t port) 467 { 468 struct ib_qp *qp = container_of(res, struct ib_qp, res); 469 struct ib_device *dev = qp->device; 470 struct ib_qp_init_attr qp_init_attr; 471 struct ib_qp_attr qp_attr; 472 int ret; 473 474 ret = ib_query_qp(qp, &qp_attr, 0, &qp_init_attr); 475 if (ret) 476 return ret; 477 478 if (port && port != qp_attr.port_num) 479 return -EAGAIN; 480 481 /* In create_qp() port is not set yet */ 482 if (qp_attr.port_num && 483 nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, qp_attr.port_num)) 484 goto err; 485 486 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, qp->qp_num)) 487 goto err; 488 if (qp->qp_type == IB_QPT_RC || qp->qp_type == IB_QPT_UC) { 489 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_RQPN, 490 qp_attr.dest_qp_num)) 491 goto err; 492 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_RQ_PSN, 493 qp_attr.rq_psn)) 494 goto err; 495 } 496 497 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_SQ_PSN, qp_attr.sq_psn)) 498 goto err; 499 500 if (qp->qp_type == IB_QPT_RC || qp->qp_type == IB_QPT_UC || 501 qp->qp_type == IB_QPT_XRC_INI || qp->qp_type == IB_QPT_XRC_TGT) { 502 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE, 503 qp_attr.path_mig_state)) 504 goto err; 505 } 506 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_TYPE, qp->qp_type)) 507 goto err; 508 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_STATE, qp_attr.qp_state)) 509 goto err; 510 511 if (!rdma_is_kernel_res(res) && 512 nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PDN, qp->pd->res.id)) 513 goto err; 514 515 if (fill_res_name_pid(msg, res)) 516 goto err; 517 518 if (fill_res_entry(dev, msg, res)) 519 goto err; 520 521 return 0; 522 523 err: return -EMSGSIZE; 524 } 525 526 static int fill_res_cm_id_entry(struct sk_buff *msg, bool has_cap_net_admin, 527 struct rdma_restrack_entry *res, uint32_t port) 528 { 529 struct rdma_id_private *id_priv = 530 container_of(res, struct rdma_id_private, res); 531 struct ib_device *dev = id_priv->id.device; 532 struct rdma_cm_id *cm_id = &id_priv->id; 533 534 if (port && port != cm_id->port_num) 535 return 0; 536 537 if (cm_id->port_num && 538 nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, cm_id->port_num)) 539 goto err; 540 541 if (id_priv->qp_num) { 542 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, id_priv->qp_num)) 543 goto err; 544 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_TYPE, cm_id->qp_type)) 545 goto err; 546 } 547 548 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PS, cm_id->ps)) 549 goto err; 550 551 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_STATE, id_priv->state)) 552 goto err; 553 554 if (cm_id->route.addr.src_addr.ss_family && 555 nla_put(msg, RDMA_NLDEV_ATTR_RES_SRC_ADDR, 556 sizeof(cm_id->route.addr.src_addr), 557 &cm_id->route.addr.src_addr)) 558 goto err; 559 if (cm_id->route.addr.dst_addr.ss_family && 560 nla_put(msg, RDMA_NLDEV_ATTR_RES_DST_ADDR, 561 sizeof(cm_id->route.addr.dst_addr), 562 &cm_id->route.addr.dst_addr)) 563 goto err; 564 565 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CM_IDN, res->id)) 566 goto err; 567 568 if (fill_res_name_pid(msg, res)) 569 goto err; 570 571 if (fill_res_entry(dev, msg, res)) 572 goto err; 573 574 return 0; 575 576 err: return -EMSGSIZE; 577 } 578 579 static int fill_res_cq_entry(struct sk_buff *msg, bool has_cap_net_admin, 580 struct rdma_restrack_entry *res, uint32_t port) 581 { 582 struct ib_cq *cq = container_of(res, struct ib_cq, res); 583 struct ib_device *dev = cq->device; 584 585 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CQE, cq->cqe)) 586 goto err; 587 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_USECNT, 588 atomic_read(&cq->usecnt), RDMA_NLDEV_ATTR_PAD)) 589 goto err; 590 591 /* Poll context is only valid for kernel CQs */ 592 if (rdma_is_kernel_res(res) && 593 nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_POLL_CTX, cq->poll_ctx)) 594 goto err; 595 596 if (nla_put_u8(msg, RDMA_NLDEV_ATTR_DEV_DIM, (cq->dim != NULL))) 597 goto err; 598 599 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CQN, res->id)) 600 goto err; 601 if (!rdma_is_kernel_res(res) && 602 nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CTXN, 603 cq->uobject->uevent.uobject.context->res.id)) 604 goto err; 605 606 if (fill_res_name_pid(msg, res)) 607 goto err; 608 609 if (fill_res_entry(dev, msg, res)) 610 goto err; 611 612 return 0; 613 614 err: return -EMSGSIZE; 615 } 616 617 static int fill_res_mr_entry(struct sk_buff *msg, bool has_cap_net_admin, 618 struct rdma_restrack_entry *res, uint32_t port) 619 { 620 struct ib_mr *mr = container_of(res, struct ib_mr, res); 621 struct ib_device *dev = mr->pd->device; 622 623 if (has_cap_net_admin) { 624 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_RKEY, mr->rkey)) 625 goto err; 626 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LKEY, mr->lkey)) 627 goto err; 628 } 629 630 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_MRLEN, mr->length, 631 RDMA_NLDEV_ATTR_PAD)) 632 goto err; 633 634 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_MRN, res->id)) 635 goto err; 636 637 if (!rdma_is_kernel_res(res) && 638 nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PDN, mr->pd->res.id)) 639 goto err; 640 641 if (fill_res_name_pid(msg, res)) 642 goto err; 643 644 if (fill_res_entry(dev, msg, res)) 645 goto err; 646 647 return 0; 648 649 err: return -EMSGSIZE; 650 } 651 652 static int fill_res_pd_entry(struct sk_buff *msg, bool has_cap_net_admin, 653 struct rdma_restrack_entry *res, uint32_t port) 654 { 655 struct ib_pd *pd = container_of(res, struct ib_pd, res); 656 struct ib_device *dev = pd->device; 657 658 if (has_cap_net_admin) { 659 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LOCAL_DMA_LKEY, 660 pd->local_dma_lkey)) 661 goto err; 662 if ((pd->flags & IB_PD_UNSAFE_GLOBAL_RKEY) && 663 nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_UNSAFE_GLOBAL_RKEY, 664 pd->unsafe_global_rkey)) 665 goto err; 666 } 667 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_USECNT, 668 atomic_read(&pd->usecnt), RDMA_NLDEV_ATTR_PAD)) 669 goto err; 670 671 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PDN, res->id)) 672 goto err; 673 674 if (!rdma_is_kernel_res(res) && 675 nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CTXN, 676 pd->uobject->context->res.id)) 677 goto err; 678 679 if (fill_res_name_pid(msg, res)) 680 goto err; 681 682 if (fill_res_entry(dev, msg, res)) 683 goto err; 684 685 return 0; 686 687 err: return -EMSGSIZE; 688 } 689 690 static int fill_stat_counter_mode(struct sk_buff *msg, 691 struct rdma_counter *counter) 692 { 693 struct rdma_counter_mode *m = &counter->mode; 694 695 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_MODE, m->mode)) 696 return -EMSGSIZE; 697 698 if (m->mode == RDMA_COUNTER_MODE_AUTO) 699 if ((m->mask & RDMA_COUNTER_MASK_QP_TYPE) && 700 nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_TYPE, m->param.qp_type)) 701 return -EMSGSIZE; 702 703 return 0; 704 } 705 706 static int fill_stat_counter_qp_entry(struct sk_buff *msg, u32 qpn) 707 { 708 struct nlattr *entry_attr; 709 710 entry_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_RES_QP_ENTRY); 711 if (!entry_attr) 712 return -EMSGSIZE; 713 714 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, qpn)) 715 goto err; 716 717 nla_nest_end(msg, entry_attr); 718 return 0; 719 720 err: 721 nla_nest_cancel(msg, entry_attr); 722 return -EMSGSIZE; 723 } 724 725 static int fill_stat_counter_qps(struct sk_buff *msg, 726 struct rdma_counter *counter) 727 { 728 struct rdma_restrack_entry *res; 729 struct rdma_restrack_root *rt; 730 struct nlattr *table_attr; 731 struct ib_qp *qp = NULL; 732 unsigned long id = 0; 733 int ret = 0; 734 735 table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_RES_QP); 736 737 rt = &counter->device->res[RDMA_RESTRACK_QP]; 738 xa_lock(&rt->xa); 739 xa_for_each(&rt->xa, id, res) { 740 qp = container_of(res, struct ib_qp, res); 741 if (qp->qp_type == IB_QPT_RAW_PACKET && !capable(CAP_NET_RAW)) 742 continue; 743 744 if (!qp->counter || (qp->counter->id != counter->id)) 745 continue; 746 747 ret = fill_stat_counter_qp_entry(msg, qp->qp_num); 748 if (ret) 749 goto err; 750 } 751 752 xa_unlock(&rt->xa); 753 nla_nest_end(msg, table_attr); 754 return 0; 755 756 err: 757 xa_unlock(&rt->xa); 758 nla_nest_cancel(msg, table_attr); 759 return ret; 760 } 761 762 int rdma_nl_stat_hwcounter_entry(struct sk_buff *msg, const char *name, 763 u64 value) 764 { 765 struct nlattr *entry_attr; 766 767 entry_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY); 768 if (!entry_attr) 769 return -EMSGSIZE; 770 771 if (nla_put_string(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_NAME, 772 name)) 773 goto err; 774 if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_VALUE, 775 value, RDMA_NLDEV_ATTR_PAD)) 776 goto err; 777 778 nla_nest_end(msg, entry_attr); 779 return 0; 780 781 err: 782 nla_nest_cancel(msg, entry_attr); 783 return -EMSGSIZE; 784 } 785 EXPORT_SYMBOL(rdma_nl_stat_hwcounter_entry); 786 787 static int fill_stat_mr_entry(struct sk_buff *msg, bool has_cap_net_admin, 788 struct rdma_restrack_entry *res, uint32_t port) 789 { 790 struct ib_mr *mr = container_of(res, struct ib_mr, res); 791 struct ib_device *dev = mr->pd->device; 792 793 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_MRN, res->id)) 794 goto err; 795 796 if (fill_stat_entry(dev, msg, res)) 797 goto err; 798 799 return 0; 800 801 err: 802 return -EMSGSIZE; 803 } 804 805 static int fill_stat_counter_hwcounters(struct sk_buff *msg, 806 struct rdma_counter *counter) 807 { 808 struct rdma_hw_stats *st = counter->stats; 809 struct nlattr *table_attr; 810 int i; 811 812 table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTERS); 813 if (!table_attr) 814 return -EMSGSIZE; 815 816 for (i = 0; i < st->num_counters; i++) 817 if (rdma_nl_stat_hwcounter_entry(msg, st->names[i], st->value[i])) 818 goto err; 819 820 nla_nest_end(msg, table_attr); 821 return 0; 822 823 err: 824 nla_nest_cancel(msg, table_attr); 825 return -EMSGSIZE; 826 } 827 828 static int fill_res_counter_entry(struct sk_buff *msg, bool has_cap_net_admin, 829 struct rdma_restrack_entry *res, 830 uint32_t port) 831 { 832 struct rdma_counter *counter = 833 container_of(res, struct rdma_counter, res); 834 835 if (port && port != counter->port) 836 return -EAGAIN; 837 838 /* Dump it even query failed */ 839 rdma_counter_query_stats(counter); 840 841 if (nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, counter->port) || 842 nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_COUNTER_ID, counter->id) || 843 fill_res_name_pid(msg, &counter->res) || 844 fill_stat_counter_mode(msg, counter) || 845 fill_stat_counter_qps(msg, counter) || 846 fill_stat_counter_hwcounters(msg, counter)) 847 return -EMSGSIZE; 848 849 return 0; 850 } 851 852 static int nldev_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 853 struct netlink_ext_ack *extack) 854 { 855 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 856 struct ib_device *device; 857 struct sk_buff *msg; 858 u32 index; 859 int err; 860 861 err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 862 nldev_policy, extack); 863 if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX]) 864 return -EINVAL; 865 866 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 867 868 device = ib_device_get_by_index(sock_net(skb->sk), index); 869 if (!device) 870 return -EINVAL; 871 872 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 873 if (!msg) { 874 err = -ENOMEM; 875 goto err; 876 } 877 878 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 879 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_GET), 880 0, 0); 881 882 err = fill_dev_info(msg, device); 883 if (err) 884 goto err_free; 885 886 nlmsg_end(msg, nlh); 887 888 ib_device_put(device); 889 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 890 891 err_free: 892 nlmsg_free(msg); 893 err: 894 ib_device_put(device); 895 return err; 896 } 897 898 static int nldev_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 899 struct netlink_ext_ack *extack) 900 { 901 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 902 struct ib_device *device; 903 u32 index; 904 int err; 905 906 err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 907 nldev_policy, extack); 908 if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX]) 909 return -EINVAL; 910 911 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 912 device = ib_device_get_by_index(sock_net(skb->sk), index); 913 if (!device) 914 return -EINVAL; 915 916 if (tb[RDMA_NLDEV_ATTR_DEV_NAME]) { 917 char name[IB_DEVICE_NAME_MAX] = {}; 918 919 nla_strlcpy(name, tb[RDMA_NLDEV_ATTR_DEV_NAME], 920 IB_DEVICE_NAME_MAX); 921 if (strlen(name) == 0) { 922 err = -EINVAL; 923 goto done; 924 } 925 err = ib_device_rename(device, name); 926 goto done; 927 } 928 929 if (tb[RDMA_NLDEV_NET_NS_FD]) { 930 u32 ns_fd; 931 932 ns_fd = nla_get_u32(tb[RDMA_NLDEV_NET_NS_FD]); 933 err = ib_device_set_netns_put(skb, device, ns_fd); 934 goto put_done; 935 } 936 937 if (tb[RDMA_NLDEV_ATTR_DEV_DIM]) { 938 u8 use_dim; 939 940 use_dim = nla_get_u8(tb[RDMA_NLDEV_ATTR_DEV_DIM]); 941 err = ib_device_set_dim(device, use_dim); 942 goto done; 943 } 944 945 done: 946 ib_device_put(device); 947 put_done: 948 return err; 949 } 950 951 static int _nldev_get_dumpit(struct ib_device *device, 952 struct sk_buff *skb, 953 struct netlink_callback *cb, 954 unsigned int idx) 955 { 956 int start = cb->args[0]; 957 struct nlmsghdr *nlh; 958 959 if (idx < start) 960 return 0; 961 962 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 963 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_GET), 964 0, NLM_F_MULTI); 965 966 if (fill_dev_info(skb, device)) { 967 nlmsg_cancel(skb, nlh); 968 goto out; 969 } 970 971 nlmsg_end(skb, nlh); 972 973 idx++; 974 975 out: cb->args[0] = idx; 976 return skb->len; 977 } 978 979 static int nldev_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 980 { 981 /* 982 * There is no need to take lock, because 983 * we are relying on ib_core's locking. 984 */ 985 return ib_enum_all_devs(_nldev_get_dumpit, skb, cb); 986 } 987 988 static int nldev_port_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 989 struct netlink_ext_ack *extack) 990 { 991 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 992 struct ib_device *device; 993 struct sk_buff *msg; 994 u32 index; 995 u32 port; 996 int err; 997 998 err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 999 nldev_policy, extack); 1000 if (err || 1001 !tb[RDMA_NLDEV_ATTR_DEV_INDEX] || 1002 !tb[RDMA_NLDEV_ATTR_PORT_INDEX]) 1003 return -EINVAL; 1004 1005 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1006 device = ib_device_get_by_index(sock_net(skb->sk), index); 1007 if (!device) 1008 return -EINVAL; 1009 1010 port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); 1011 if (!rdma_is_port_valid(device, port)) { 1012 err = -EINVAL; 1013 goto err; 1014 } 1015 1016 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1017 if (!msg) { 1018 err = -ENOMEM; 1019 goto err; 1020 } 1021 1022 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1023 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_GET), 1024 0, 0); 1025 1026 err = fill_port_info(msg, device, port, sock_net(skb->sk)); 1027 if (err) 1028 goto err_free; 1029 1030 nlmsg_end(msg, nlh); 1031 ib_device_put(device); 1032 1033 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 1034 1035 err_free: 1036 nlmsg_free(msg); 1037 err: 1038 ib_device_put(device); 1039 return err; 1040 } 1041 1042 static int nldev_port_get_dumpit(struct sk_buff *skb, 1043 struct netlink_callback *cb) 1044 { 1045 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1046 struct ib_device *device; 1047 int start = cb->args[0]; 1048 struct nlmsghdr *nlh; 1049 u32 idx = 0; 1050 u32 ifindex; 1051 int err; 1052 unsigned int p; 1053 1054 err = nlmsg_parse_deprecated(cb->nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1055 nldev_policy, NULL); 1056 if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX]) 1057 return -EINVAL; 1058 1059 ifindex = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1060 device = ib_device_get_by_index(sock_net(skb->sk), ifindex); 1061 if (!device) 1062 return -EINVAL; 1063 1064 rdma_for_each_port (device, p) { 1065 /* 1066 * The dumpit function returns all information from specific 1067 * index. This specific index is taken from the netlink 1068 * messages request sent by user and it is available 1069 * in cb->args[0]. 1070 * 1071 * Usually, the user doesn't fill this field and it causes 1072 * to return everything. 1073 * 1074 */ 1075 if (idx < start) { 1076 idx++; 1077 continue; 1078 } 1079 1080 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, 1081 cb->nlh->nlmsg_seq, 1082 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, 1083 RDMA_NLDEV_CMD_PORT_GET), 1084 0, NLM_F_MULTI); 1085 1086 if (fill_port_info(skb, device, p, sock_net(skb->sk))) { 1087 nlmsg_cancel(skb, nlh); 1088 goto out; 1089 } 1090 idx++; 1091 nlmsg_end(skb, nlh); 1092 } 1093 1094 out: 1095 ib_device_put(device); 1096 cb->args[0] = idx; 1097 return skb->len; 1098 } 1099 1100 static int nldev_res_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 1101 struct netlink_ext_ack *extack) 1102 { 1103 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1104 struct ib_device *device; 1105 struct sk_buff *msg; 1106 u32 index; 1107 int ret; 1108 1109 ret = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1110 nldev_policy, extack); 1111 if (ret || !tb[RDMA_NLDEV_ATTR_DEV_INDEX]) 1112 return -EINVAL; 1113 1114 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1115 device = ib_device_get_by_index(sock_net(skb->sk), index); 1116 if (!device) 1117 return -EINVAL; 1118 1119 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1120 if (!msg) { 1121 ret = -ENOMEM; 1122 goto err; 1123 } 1124 1125 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1126 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_RES_GET), 1127 0, 0); 1128 1129 ret = fill_res_info(msg, device); 1130 if (ret) 1131 goto err_free; 1132 1133 nlmsg_end(msg, nlh); 1134 ib_device_put(device); 1135 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 1136 1137 err_free: 1138 nlmsg_free(msg); 1139 err: 1140 ib_device_put(device); 1141 return ret; 1142 } 1143 1144 static int _nldev_res_get_dumpit(struct ib_device *device, 1145 struct sk_buff *skb, 1146 struct netlink_callback *cb, 1147 unsigned int idx) 1148 { 1149 int start = cb->args[0]; 1150 struct nlmsghdr *nlh; 1151 1152 if (idx < start) 1153 return 0; 1154 1155 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 1156 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_RES_GET), 1157 0, NLM_F_MULTI); 1158 1159 if (fill_res_info(skb, device)) { 1160 nlmsg_cancel(skb, nlh); 1161 goto out; 1162 } 1163 nlmsg_end(skb, nlh); 1164 1165 idx++; 1166 1167 out: 1168 cb->args[0] = idx; 1169 return skb->len; 1170 } 1171 1172 static int nldev_res_get_dumpit(struct sk_buff *skb, 1173 struct netlink_callback *cb) 1174 { 1175 return ib_enum_all_devs(_nldev_res_get_dumpit, skb, cb); 1176 } 1177 1178 struct nldev_fill_res_entry { 1179 enum rdma_nldev_attr nldev_attr; 1180 enum rdma_nldev_command nldev_cmd; 1181 u8 flags; 1182 u32 entry; 1183 u32 id; 1184 }; 1185 1186 enum nldev_res_flags { 1187 NLDEV_PER_DEV = 1 << 0, 1188 }; 1189 1190 static const struct nldev_fill_res_entry fill_entries[RDMA_RESTRACK_MAX] = { 1191 [RDMA_RESTRACK_QP] = { 1192 .nldev_cmd = RDMA_NLDEV_CMD_RES_QP_GET, 1193 .nldev_attr = RDMA_NLDEV_ATTR_RES_QP, 1194 .entry = RDMA_NLDEV_ATTR_RES_QP_ENTRY, 1195 .id = RDMA_NLDEV_ATTR_RES_LQPN, 1196 }, 1197 [RDMA_RESTRACK_CM_ID] = { 1198 .nldev_cmd = RDMA_NLDEV_CMD_RES_CM_ID_GET, 1199 .nldev_attr = RDMA_NLDEV_ATTR_RES_CM_ID, 1200 .entry = RDMA_NLDEV_ATTR_RES_CM_ID_ENTRY, 1201 .id = RDMA_NLDEV_ATTR_RES_CM_IDN, 1202 }, 1203 [RDMA_RESTRACK_CQ] = { 1204 .nldev_cmd = RDMA_NLDEV_CMD_RES_CQ_GET, 1205 .nldev_attr = RDMA_NLDEV_ATTR_RES_CQ, 1206 .flags = NLDEV_PER_DEV, 1207 .entry = RDMA_NLDEV_ATTR_RES_CQ_ENTRY, 1208 .id = RDMA_NLDEV_ATTR_RES_CQN, 1209 }, 1210 [RDMA_RESTRACK_MR] = { 1211 .nldev_cmd = RDMA_NLDEV_CMD_RES_MR_GET, 1212 .nldev_attr = RDMA_NLDEV_ATTR_RES_MR, 1213 .flags = NLDEV_PER_DEV, 1214 .entry = RDMA_NLDEV_ATTR_RES_MR_ENTRY, 1215 .id = RDMA_NLDEV_ATTR_RES_MRN, 1216 }, 1217 [RDMA_RESTRACK_PD] = { 1218 .nldev_cmd = RDMA_NLDEV_CMD_RES_PD_GET, 1219 .nldev_attr = RDMA_NLDEV_ATTR_RES_PD, 1220 .flags = NLDEV_PER_DEV, 1221 .entry = RDMA_NLDEV_ATTR_RES_PD_ENTRY, 1222 .id = RDMA_NLDEV_ATTR_RES_PDN, 1223 }, 1224 [RDMA_RESTRACK_COUNTER] = { 1225 .nldev_cmd = RDMA_NLDEV_CMD_STAT_GET, 1226 .nldev_attr = RDMA_NLDEV_ATTR_STAT_COUNTER, 1227 .entry = RDMA_NLDEV_ATTR_STAT_COUNTER_ENTRY, 1228 .id = RDMA_NLDEV_ATTR_STAT_COUNTER_ID, 1229 }, 1230 }; 1231 1232 static int res_get_common_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 1233 struct netlink_ext_ack *extack, 1234 enum rdma_restrack_type res_type, 1235 res_fill_func_t fill_func) 1236 { 1237 const struct nldev_fill_res_entry *fe = &fill_entries[res_type]; 1238 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1239 struct rdma_restrack_entry *res; 1240 struct ib_device *device; 1241 u32 index, id, port = 0; 1242 bool has_cap_net_admin; 1243 struct sk_buff *msg; 1244 int ret; 1245 1246 ret = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1247 nldev_policy, extack); 1248 if (ret || !tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !fe->id || !tb[fe->id]) 1249 return -EINVAL; 1250 1251 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1252 device = ib_device_get_by_index(sock_net(skb->sk), index); 1253 if (!device) 1254 return -EINVAL; 1255 1256 if (tb[RDMA_NLDEV_ATTR_PORT_INDEX]) { 1257 port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); 1258 if (!rdma_is_port_valid(device, port)) { 1259 ret = -EINVAL; 1260 goto err; 1261 } 1262 } 1263 1264 if ((port && fe->flags & NLDEV_PER_DEV) || 1265 (!port && ~fe->flags & NLDEV_PER_DEV)) { 1266 ret = -EINVAL; 1267 goto err; 1268 } 1269 1270 id = nla_get_u32(tb[fe->id]); 1271 res = rdma_restrack_get_byid(device, res_type, id); 1272 if (IS_ERR(res)) { 1273 ret = PTR_ERR(res); 1274 goto err; 1275 } 1276 1277 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1278 if (!msg) { 1279 ret = -ENOMEM; 1280 goto err_get; 1281 } 1282 1283 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1284 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, fe->nldev_cmd), 1285 0, 0); 1286 1287 if (fill_nldev_handle(msg, device)) { 1288 ret = -EMSGSIZE; 1289 goto err_free; 1290 } 1291 1292 has_cap_net_admin = netlink_capable(skb, CAP_NET_ADMIN); 1293 1294 ret = fill_func(msg, has_cap_net_admin, res, port); 1295 1296 rdma_restrack_put(res); 1297 if (ret) 1298 goto err_free; 1299 1300 nlmsg_end(msg, nlh); 1301 ib_device_put(device); 1302 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 1303 1304 err_free: 1305 nlmsg_free(msg); 1306 err_get: 1307 rdma_restrack_put(res); 1308 err: 1309 ib_device_put(device); 1310 return ret; 1311 } 1312 1313 static int res_get_common_dumpit(struct sk_buff *skb, 1314 struct netlink_callback *cb, 1315 enum rdma_restrack_type res_type, 1316 res_fill_func_t fill_func) 1317 { 1318 const struct nldev_fill_res_entry *fe = &fill_entries[res_type]; 1319 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1320 struct rdma_restrack_entry *res; 1321 struct rdma_restrack_root *rt; 1322 int err, ret = 0, idx = 0; 1323 struct nlattr *table_attr; 1324 struct nlattr *entry_attr; 1325 struct ib_device *device; 1326 int start = cb->args[0]; 1327 bool has_cap_net_admin; 1328 struct nlmsghdr *nlh; 1329 unsigned long id; 1330 u32 index, port = 0; 1331 bool filled = false; 1332 1333 err = nlmsg_parse_deprecated(cb->nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1334 nldev_policy, NULL); 1335 /* 1336 * Right now, we are expecting the device index to get res information, 1337 * but it is possible to extend this code to return all devices in 1338 * one shot by checking the existence of RDMA_NLDEV_ATTR_DEV_INDEX. 1339 * if it doesn't exist, we will iterate over all devices. 1340 * 1341 * But it is not needed for now. 1342 */ 1343 if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX]) 1344 return -EINVAL; 1345 1346 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1347 device = ib_device_get_by_index(sock_net(skb->sk), index); 1348 if (!device) 1349 return -EINVAL; 1350 1351 /* 1352 * If no PORT_INDEX is supplied, we will return all QPs from that device 1353 */ 1354 if (tb[RDMA_NLDEV_ATTR_PORT_INDEX]) { 1355 port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); 1356 if (!rdma_is_port_valid(device, port)) { 1357 ret = -EINVAL; 1358 goto err_index; 1359 } 1360 } 1361 1362 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 1363 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, fe->nldev_cmd), 1364 0, NLM_F_MULTI); 1365 1366 if (fill_nldev_handle(skb, device)) { 1367 ret = -EMSGSIZE; 1368 goto err; 1369 } 1370 1371 table_attr = nla_nest_start_noflag(skb, fe->nldev_attr); 1372 if (!table_attr) { 1373 ret = -EMSGSIZE; 1374 goto err; 1375 } 1376 1377 has_cap_net_admin = netlink_capable(cb->skb, CAP_NET_ADMIN); 1378 1379 rt = &device->res[res_type]; 1380 xa_lock(&rt->xa); 1381 /* 1382 * FIXME: if the skip ahead is something common this loop should 1383 * use xas_for_each & xas_pause to optimize, we can have a lot of 1384 * objects. 1385 */ 1386 xa_for_each(&rt->xa, id, res) { 1387 if (idx < start || !rdma_restrack_get(res)) 1388 goto next; 1389 1390 xa_unlock(&rt->xa); 1391 1392 filled = true; 1393 1394 entry_attr = nla_nest_start_noflag(skb, fe->entry); 1395 if (!entry_attr) { 1396 ret = -EMSGSIZE; 1397 rdma_restrack_put(res); 1398 goto msg_full; 1399 } 1400 1401 ret = fill_func(skb, has_cap_net_admin, res, port); 1402 1403 rdma_restrack_put(res); 1404 1405 if (ret) { 1406 nla_nest_cancel(skb, entry_attr); 1407 if (ret == -EMSGSIZE) 1408 goto msg_full; 1409 if (ret == -EAGAIN) 1410 goto again; 1411 goto res_err; 1412 } 1413 nla_nest_end(skb, entry_attr); 1414 again: xa_lock(&rt->xa); 1415 next: idx++; 1416 } 1417 xa_unlock(&rt->xa); 1418 1419 msg_full: 1420 nla_nest_end(skb, table_attr); 1421 nlmsg_end(skb, nlh); 1422 cb->args[0] = idx; 1423 1424 /* 1425 * No more entries to fill, cancel the message and 1426 * return 0 to mark end of dumpit. 1427 */ 1428 if (!filled) 1429 goto err; 1430 1431 ib_device_put(device); 1432 return skb->len; 1433 1434 res_err: 1435 nla_nest_cancel(skb, table_attr); 1436 1437 err: 1438 nlmsg_cancel(skb, nlh); 1439 1440 err_index: 1441 ib_device_put(device); 1442 return ret; 1443 } 1444 1445 #define RES_GET_FUNCS(name, type) \ 1446 static int nldev_res_get_##name##_dumpit(struct sk_buff *skb, \ 1447 struct netlink_callback *cb) \ 1448 { \ 1449 return res_get_common_dumpit(skb, cb, type, \ 1450 fill_res_##name##_entry); \ 1451 } \ 1452 static int nldev_res_get_##name##_doit(struct sk_buff *skb, \ 1453 struct nlmsghdr *nlh, \ 1454 struct netlink_ext_ack *extack) \ 1455 { \ 1456 return res_get_common_doit(skb, nlh, extack, type, \ 1457 fill_res_##name##_entry); \ 1458 } 1459 1460 RES_GET_FUNCS(qp, RDMA_RESTRACK_QP); 1461 RES_GET_FUNCS(cm_id, RDMA_RESTRACK_CM_ID); 1462 RES_GET_FUNCS(cq, RDMA_RESTRACK_CQ); 1463 RES_GET_FUNCS(pd, RDMA_RESTRACK_PD); 1464 RES_GET_FUNCS(mr, RDMA_RESTRACK_MR); 1465 RES_GET_FUNCS(counter, RDMA_RESTRACK_COUNTER); 1466 1467 static LIST_HEAD(link_ops); 1468 static DECLARE_RWSEM(link_ops_rwsem); 1469 1470 static const struct rdma_link_ops *link_ops_get(const char *type) 1471 { 1472 const struct rdma_link_ops *ops; 1473 1474 list_for_each_entry(ops, &link_ops, list) { 1475 if (!strcmp(ops->type, type)) 1476 goto out; 1477 } 1478 ops = NULL; 1479 out: 1480 return ops; 1481 } 1482 1483 void rdma_link_register(struct rdma_link_ops *ops) 1484 { 1485 down_write(&link_ops_rwsem); 1486 if (WARN_ON_ONCE(link_ops_get(ops->type))) 1487 goto out; 1488 list_add(&ops->list, &link_ops); 1489 out: 1490 up_write(&link_ops_rwsem); 1491 } 1492 EXPORT_SYMBOL(rdma_link_register); 1493 1494 void rdma_link_unregister(struct rdma_link_ops *ops) 1495 { 1496 down_write(&link_ops_rwsem); 1497 list_del(&ops->list); 1498 up_write(&link_ops_rwsem); 1499 } 1500 EXPORT_SYMBOL(rdma_link_unregister); 1501 1502 static int nldev_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, 1503 struct netlink_ext_ack *extack) 1504 { 1505 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1506 char ibdev_name[IB_DEVICE_NAME_MAX]; 1507 const struct rdma_link_ops *ops; 1508 char ndev_name[IFNAMSIZ]; 1509 struct net_device *ndev; 1510 char type[IFNAMSIZ]; 1511 int err; 1512 1513 err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1514 nldev_policy, extack); 1515 if (err || !tb[RDMA_NLDEV_ATTR_DEV_NAME] || 1516 !tb[RDMA_NLDEV_ATTR_LINK_TYPE] || !tb[RDMA_NLDEV_ATTR_NDEV_NAME]) 1517 return -EINVAL; 1518 1519 nla_strlcpy(ibdev_name, tb[RDMA_NLDEV_ATTR_DEV_NAME], 1520 sizeof(ibdev_name)); 1521 if (strchr(ibdev_name, '%') || strlen(ibdev_name) == 0) 1522 return -EINVAL; 1523 1524 nla_strlcpy(type, tb[RDMA_NLDEV_ATTR_LINK_TYPE], sizeof(type)); 1525 nla_strlcpy(ndev_name, tb[RDMA_NLDEV_ATTR_NDEV_NAME], 1526 sizeof(ndev_name)); 1527 1528 ndev = dev_get_by_name(sock_net(skb->sk), ndev_name); 1529 if (!ndev) 1530 return -ENODEV; 1531 1532 down_read(&link_ops_rwsem); 1533 ops = link_ops_get(type); 1534 #ifdef CONFIG_MODULES 1535 if (!ops) { 1536 up_read(&link_ops_rwsem); 1537 request_module("rdma-link-%s", type); 1538 down_read(&link_ops_rwsem); 1539 ops = link_ops_get(type); 1540 } 1541 #endif 1542 err = ops ? ops->newlink(ibdev_name, ndev) : -EINVAL; 1543 up_read(&link_ops_rwsem); 1544 dev_put(ndev); 1545 1546 return err; 1547 } 1548 1549 static int nldev_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, 1550 struct netlink_ext_ack *extack) 1551 { 1552 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1553 struct ib_device *device; 1554 u32 index; 1555 int err; 1556 1557 err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1558 nldev_policy, extack); 1559 if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX]) 1560 return -EINVAL; 1561 1562 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1563 device = ib_device_get_by_index(sock_net(skb->sk), index); 1564 if (!device) 1565 return -EINVAL; 1566 1567 if (!(device->attrs.device_cap_flags & IB_DEVICE_ALLOW_USER_UNREG)) { 1568 ib_device_put(device); 1569 return -EINVAL; 1570 } 1571 1572 ib_unregister_device_and_put(device); 1573 return 0; 1574 } 1575 1576 static int nldev_get_chardev(struct sk_buff *skb, struct nlmsghdr *nlh, 1577 struct netlink_ext_ack *extack) 1578 { 1579 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1580 char client_name[RDMA_NLDEV_ATTR_CHARDEV_TYPE_SIZE]; 1581 struct ib_client_nl_info data = {}; 1582 struct ib_device *ibdev = NULL; 1583 struct sk_buff *msg; 1584 u32 index; 1585 int err; 1586 1587 err = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, nldev_policy, 1588 extack); 1589 if (err || !tb[RDMA_NLDEV_ATTR_CHARDEV_TYPE]) 1590 return -EINVAL; 1591 1592 nla_strlcpy(client_name, tb[RDMA_NLDEV_ATTR_CHARDEV_TYPE], 1593 sizeof(client_name)); 1594 1595 if (tb[RDMA_NLDEV_ATTR_DEV_INDEX]) { 1596 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1597 ibdev = ib_device_get_by_index(sock_net(skb->sk), index); 1598 if (!ibdev) 1599 return -EINVAL; 1600 1601 if (tb[RDMA_NLDEV_ATTR_PORT_INDEX]) { 1602 data.port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); 1603 if (!rdma_is_port_valid(ibdev, data.port)) { 1604 err = -EINVAL; 1605 goto out_put; 1606 } 1607 } else { 1608 data.port = -1; 1609 } 1610 } else if (tb[RDMA_NLDEV_ATTR_PORT_INDEX]) { 1611 return -EINVAL; 1612 } 1613 1614 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1615 if (!msg) { 1616 err = -ENOMEM; 1617 goto out_put; 1618 } 1619 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1620 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, 1621 RDMA_NLDEV_CMD_GET_CHARDEV), 1622 0, 0); 1623 1624 data.nl_msg = msg; 1625 err = ib_get_client_nl_info(ibdev, client_name, &data); 1626 if (err) 1627 goto out_nlmsg; 1628 1629 err = nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_CHARDEV, 1630 huge_encode_dev(data.cdev->devt), 1631 RDMA_NLDEV_ATTR_PAD); 1632 if (err) 1633 goto out_data; 1634 err = nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_CHARDEV_ABI, data.abi, 1635 RDMA_NLDEV_ATTR_PAD); 1636 if (err) 1637 goto out_data; 1638 if (nla_put_string(msg, RDMA_NLDEV_ATTR_CHARDEV_NAME, 1639 dev_name(data.cdev))) { 1640 err = -EMSGSIZE; 1641 goto out_data; 1642 } 1643 1644 nlmsg_end(msg, nlh); 1645 put_device(data.cdev); 1646 if (ibdev) 1647 ib_device_put(ibdev); 1648 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 1649 1650 out_data: 1651 put_device(data.cdev); 1652 out_nlmsg: 1653 nlmsg_free(msg); 1654 out_put: 1655 if (ibdev) 1656 ib_device_put(ibdev); 1657 return err; 1658 } 1659 1660 static int nldev_sys_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 1661 struct netlink_ext_ack *extack) 1662 { 1663 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1664 struct sk_buff *msg; 1665 int err; 1666 1667 err = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1668 nldev_policy, extack); 1669 if (err) 1670 return err; 1671 1672 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1673 if (!msg) 1674 return -ENOMEM; 1675 1676 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1677 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, 1678 RDMA_NLDEV_CMD_SYS_GET), 1679 0, 0); 1680 1681 err = nla_put_u8(msg, RDMA_NLDEV_SYS_ATTR_NETNS_MODE, 1682 (u8)ib_devices_shared_netns); 1683 if (err) { 1684 nlmsg_free(msg); 1685 return err; 1686 } 1687 nlmsg_end(msg, nlh); 1688 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 1689 } 1690 1691 static int nldev_set_sys_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 1692 struct netlink_ext_ack *extack) 1693 { 1694 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1695 u8 enable; 1696 int err; 1697 1698 err = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1699 nldev_policy, extack); 1700 if (err || !tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]) 1701 return -EINVAL; 1702 1703 enable = nla_get_u8(tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]); 1704 /* Only 0 and 1 are supported */ 1705 if (enable > 1) 1706 return -EINVAL; 1707 1708 err = rdma_compatdev_set(enable); 1709 return err; 1710 } 1711 1712 static int nldev_stat_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 1713 struct netlink_ext_ack *extack) 1714 { 1715 u32 index, port, mode, mask = 0, qpn, cntn = 0; 1716 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1717 struct ib_device *device; 1718 struct sk_buff *msg; 1719 int ret; 1720 1721 ret = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1722 nldev_policy, extack); 1723 /* Currently only counter for QP is supported */ 1724 if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES] || 1725 !tb[RDMA_NLDEV_ATTR_DEV_INDEX] || 1726 !tb[RDMA_NLDEV_ATTR_PORT_INDEX] || !tb[RDMA_NLDEV_ATTR_STAT_MODE]) 1727 return -EINVAL; 1728 1729 if (nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_RES]) != RDMA_NLDEV_ATTR_RES_QP) 1730 return -EINVAL; 1731 1732 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1733 device = ib_device_get_by_index(sock_net(skb->sk), index); 1734 if (!device) 1735 return -EINVAL; 1736 1737 port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); 1738 if (!rdma_is_port_valid(device, port)) { 1739 ret = -EINVAL; 1740 goto err; 1741 } 1742 1743 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1744 if (!msg) { 1745 ret = -ENOMEM; 1746 goto err; 1747 } 1748 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1749 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, 1750 RDMA_NLDEV_CMD_STAT_SET), 1751 0, 0); 1752 1753 mode = nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_MODE]); 1754 if (mode == RDMA_COUNTER_MODE_AUTO) { 1755 if (tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK]) 1756 mask = nla_get_u32( 1757 tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK]); 1758 1759 ret = rdma_counter_set_auto_mode(device, port, 1760 mask ? true : false, mask); 1761 if (ret) 1762 goto err_msg; 1763 } else { 1764 if (!tb[RDMA_NLDEV_ATTR_RES_LQPN]) 1765 goto err_msg; 1766 qpn = nla_get_u32(tb[RDMA_NLDEV_ATTR_RES_LQPN]); 1767 if (tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID]) { 1768 cntn = nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID]); 1769 ret = rdma_counter_bind_qpn(device, port, qpn, cntn); 1770 } else { 1771 ret = rdma_counter_bind_qpn_alloc(device, port, 1772 qpn, &cntn); 1773 } 1774 if (ret) 1775 goto err_msg; 1776 1777 if (fill_nldev_handle(msg, device) || 1778 nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port) || 1779 nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_COUNTER_ID, cntn) || 1780 nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, qpn)) { 1781 ret = -EMSGSIZE; 1782 goto err_fill; 1783 } 1784 } 1785 1786 nlmsg_end(msg, nlh); 1787 ib_device_put(device); 1788 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 1789 1790 err_fill: 1791 rdma_counter_unbind_qpn(device, port, qpn, cntn); 1792 err_msg: 1793 nlmsg_free(msg); 1794 err: 1795 ib_device_put(device); 1796 return ret; 1797 } 1798 1799 static int nldev_stat_del_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 1800 struct netlink_ext_ack *extack) 1801 { 1802 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 1803 struct ib_device *device; 1804 struct sk_buff *msg; 1805 u32 index, port, qpn, cntn; 1806 int ret; 1807 1808 ret = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 1809 nldev_policy, extack); 1810 if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES] || 1811 !tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_PORT_INDEX] || 1812 !tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID] || 1813 !tb[RDMA_NLDEV_ATTR_RES_LQPN]) 1814 return -EINVAL; 1815 1816 if (nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_RES]) != RDMA_NLDEV_ATTR_RES_QP) 1817 return -EINVAL; 1818 1819 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1820 device = ib_device_get_by_index(sock_net(skb->sk), index); 1821 if (!device) 1822 return -EINVAL; 1823 1824 port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); 1825 if (!rdma_is_port_valid(device, port)) { 1826 ret = -EINVAL; 1827 goto err; 1828 } 1829 1830 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1831 if (!msg) { 1832 ret = -ENOMEM; 1833 goto err; 1834 } 1835 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1836 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, 1837 RDMA_NLDEV_CMD_STAT_SET), 1838 0, 0); 1839 1840 cntn = nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID]); 1841 qpn = nla_get_u32(tb[RDMA_NLDEV_ATTR_RES_LQPN]); 1842 if (fill_nldev_handle(msg, device) || 1843 nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port) || 1844 nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_COUNTER_ID, cntn) || 1845 nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, qpn)) { 1846 ret = -EMSGSIZE; 1847 goto err_fill; 1848 } 1849 1850 ret = rdma_counter_unbind_qpn(device, port, qpn, cntn); 1851 if (ret) 1852 goto err_fill; 1853 1854 nlmsg_end(msg, nlh); 1855 ib_device_put(device); 1856 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 1857 1858 err_fill: 1859 nlmsg_free(msg); 1860 err: 1861 ib_device_put(device); 1862 return ret; 1863 } 1864 1865 static int stat_get_doit_default_counter(struct sk_buff *skb, 1866 struct nlmsghdr *nlh, 1867 struct netlink_ext_ack *extack, 1868 struct nlattr *tb[]) 1869 { 1870 struct rdma_hw_stats *stats; 1871 struct nlattr *table_attr; 1872 struct ib_device *device; 1873 int ret, num_cnts, i; 1874 struct sk_buff *msg; 1875 u32 index, port; 1876 u64 v; 1877 1878 if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_PORT_INDEX]) 1879 return -EINVAL; 1880 1881 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1882 device = ib_device_get_by_index(sock_net(skb->sk), index); 1883 if (!device) 1884 return -EINVAL; 1885 1886 if (!device->ops.alloc_hw_stats || !device->ops.get_hw_stats) { 1887 ret = -EINVAL; 1888 goto err; 1889 } 1890 1891 port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); 1892 if (!rdma_is_port_valid(device, port)) { 1893 ret = -EINVAL; 1894 goto err; 1895 } 1896 1897 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1898 if (!msg) { 1899 ret = -ENOMEM; 1900 goto err; 1901 } 1902 1903 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1904 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, 1905 RDMA_NLDEV_CMD_STAT_GET), 1906 0, 0); 1907 1908 if (fill_nldev_handle(msg, device) || 1909 nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port)) { 1910 ret = -EMSGSIZE; 1911 goto err_msg; 1912 } 1913 1914 stats = device->port_data ? device->port_data[port].hw_stats : NULL; 1915 if (stats == NULL) { 1916 ret = -EINVAL; 1917 goto err_msg; 1918 } 1919 mutex_lock(&stats->lock); 1920 1921 num_cnts = device->ops.get_hw_stats(device, stats, port, 0); 1922 if (num_cnts < 0) { 1923 ret = -EINVAL; 1924 goto err_stats; 1925 } 1926 1927 table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTERS); 1928 if (!table_attr) { 1929 ret = -EMSGSIZE; 1930 goto err_stats; 1931 } 1932 for (i = 0; i < num_cnts; i++) { 1933 v = stats->value[i] + 1934 rdma_counter_get_hwstat_value(device, port, i); 1935 if (rdma_nl_stat_hwcounter_entry(msg, stats->names[i], v)) { 1936 ret = -EMSGSIZE; 1937 goto err_table; 1938 } 1939 } 1940 nla_nest_end(msg, table_attr); 1941 1942 mutex_unlock(&stats->lock); 1943 nlmsg_end(msg, nlh); 1944 ib_device_put(device); 1945 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 1946 1947 err_table: 1948 nla_nest_cancel(msg, table_attr); 1949 err_stats: 1950 mutex_unlock(&stats->lock); 1951 err_msg: 1952 nlmsg_free(msg); 1953 err: 1954 ib_device_put(device); 1955 return ret; 1956 } 1957 1958 static int stat_get_doit_qp(struct sk_buff *skb, struct nlmsghdr *nlh, 1959 struct netlink_ext_ack *extack, struct nlattr *tb[]) 1960 1961 { 1962 static enum rdma_nl_counter_mode mode; 1963 static enum rdma_nl_counter_mask mask; 1964 struct ib_device *device; 1965 struct sk_buff *msg; 1966 u32 index, port; 1967 int ret; 1968 1969 if (tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID]) 1970 return nldev_res_get_counter_doit(skb, nlh, extack); 1971 1972 if (!tb[RDMA_NLDEV_ATTR_STAT_MODE] || 1973 !tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_PORT_INDEX]) 1974 return -EINVAL; 1975 1976 index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); 1977 device = ib_device_get_by_index(sock_net(skb->sk), index); 1978 if (!device) 1979 return -EINVAL; 1980 1981 port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); 1982 if (!rdma_is_port_valid(device, port)) { 1983 ret = -EINVAL; 1984 goto err; 1985 } 1986 1987 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1988 if (!msg) { 1989 ret = -ENOMEM; 1990 goto err; 1991 } 1992 1993 nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 1994 RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, 1995 RDMA_NLDEV_CMD_STAT_GET), 1996 0, 0); 1997 1998 ret = rdma_counter_get_mode(device, port, &mode, &mask); 1999 if (ret) 2000 goto err_msg; 2001 2002 if (fill_nldev_handle(msg, device) || 2003 nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port) || 2004 nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_MODE, mode)) { 2005 ret = -EMSGSIZE; 2006 goto err_msg; 2007 } 2008 2009 if ((mode == RDMA_COUNTER_MODE_AUTO) && 2010 nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK, mask)) { 2011 ret = -EMSGSIZE; 2012 goto err_msg; 2013 } 2014 2015 nlmsg_end(msg, nlh); 2016 ib_device_put(device); 2017 return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid); 2018 2019 err_msg: 2020 nlmsg_free(msg); 2021 err: 2022 ib_device_put(device); 2023 return ret; 2024 } 2025 2026 static int nldev_stat_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 2027 struct netlink_ext_ack *extack) 2028 { 2029 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 2030 int ret; 2031 2032 ret = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 2033 nldev_policy, extack); 2034 if (ret) 2035 return -EINVAL; 2036 2037 if (!tb[RDMA_NLDEV_ATTR_STAT_RES]) 2038 return stat_get_doit_default_counter(skb, nlh, extack, tb); 2039 2040 switch (nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_RES])) { 2041 case RDMA_NLDEV_ATTR_RES_QP: 2042 ret = stat_get_doit_qp(skb, nlh, extack, tb); 2043 break; 2044 case RDMA_NLDEV_ATTR_RES_MR: 2045 ret = res_get_common_doit(skb, nlh, extack, RDMA_RESTRACK_MR, 2046 fill_stat_mr_entry); 2047 break; 2048 default: 2049 ret = -EINVAL; 2050 break; 2051 } 2052 2053 return ret; 2054 } 2055 2056 static int nldev_stat_get_dumpit(struct sk_buff *skb, 2057 struct netlink_callback *cb) 2058 { 2059 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX]; 2060 int ret; 2061 2062 ret = nlmsg_parse(cb->nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, 2063 nldev_policy, NULL); 2064 if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES]) 2065 return -EINVAL; 2066 2067 switch (nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_RES])) { 2068 case RDMA_NLDEV_ATTR_RES_QP: 2069 ret = nldev_res_get_counter_dumpit(skb, cb); 2070 break; 2071 case RDMA_NLDEV_ATTR_RES_MR: 2072 ret = res_get_common_dumpit(skb, cb, RDMA_RESTRACK_MR, 2073 fill_stat_mr_entry); 2074 break; 2075 default: 2076 ret = -EINVAL; 2077 break; 2078 } 2079 2080 return ret; 2081 } 2082 2083 static const struct rdma_nl_cbs nldev_cb_table[RDMA_NLDEV_NUM_OPS] = { 2084 [RDMA_NLDEV_CMD_GET] = { 2085 .doit = nldev_get_doit, 2086 .dump = nldev_get_dumpit, 2087 }, 2088 [RDMA_NLDEV_CMD_GET_CHARDEV] = { 2089 .doit = nldev_get_chardev, 2090 }, 2091 [RDMA_NLDEV_CMD_SET] = { 2092 .doit = nldev_set_doit, 2093 .flags = RDMA_NL_ADMIN_PERM, 2094 }, 2095 [RDMA_NLDEV_CMD_NEWLINK] = { 2096 .doit = nldev_newlink, 2097 .flags = RDMA_NL_ADMIN_PERM, 2098 }, 2099 [RDMA_NLDEV_CMD_DELLINK] = { 2100 .doit = nldev_dellink, 2101 .flags = RDMA_NL_ADMIN_PERM, 2102 }, 2103 [RDMA_NLDEV_CMD_PORT_GET] = { 2104 .doit = nldev_port_get_doit, 2105 .dump = nldev_port_get_dumpit, 2106 }, 2107 [RDMA_NLDEV_CMD_RES_GET] = { 2108 .doit = nldev_res_get_doit, 2109 .dump = nldev_res_get_dumpit, 2110 }, 2111 [RDMA_NLDEV_CMD_RES_QP_GET] = { 2112 .doit = nldev_res_get_qp_doit, 2113 .dump = nldev_res_get_qp_dumpit, 2114 }, 2115 [RDMA_NLDEV_CMD_RES_CM_ID_GET] = { 2116 .doit = nldev_res_get_cm_id_doit, 2117 .dump = nldev_res_get_cm_id_dumpit, 2118 }, 2119 [RDMA_NLDEV_CMD_RES_CQ_GET] = { 2120 .doit = nldev_res_get_cq_doit, 2121 .dump = nldev_res_get_cq_dumpit, 2122 }, 2123 [RDMA_NLDEV_CMD_RES_MR_GET] = { 2124 .doit = nldev_res_get_mr_doit, 2125 .dump = nldev_res_get_mr_dumpit, 2126 }, 2127 [RDMA_NLDEV_CMD_RES_PD_GET] = { 2128 .doit = nldev_res_get_pd_doit, 2129 .dump = nldev_res_get_pd_dumpit, 2130 }, 2131 [RDMA_NLDEV_CMD_SYS_GET] = { 2132 .doit = nldev_sys_get_doit, 2133 }, 2134 [RDMA_NLDEV_CMD_SYS_SET] = { 2135 .doit = nldev_set_sys_set_doit, 2136 }, 2137 [RDMA_NLDEV_CMD_STAT_SET] = { 2138 .doit = nldev_stat_set_doit, 2139 .flags = RDMA_NL_ADMIN_PERM, 2140 }, 2141 [RDMA_NLDEV_CMD_STAT_GET] = { 2142 .doit = nldev_stat_get_doit, 2143 .dump = nldev_stat_get_dumpit, 2144 }, 2145 [RDMA_NLDEV_CMD_STAT_DEL] = { 2146 .doit = nldev_stat_del_doit, 2147 .flags = RDMA_NL_ADMIN_PERM, 2148 }, 2149 }; 2150 2151 void __init nldev_init(void) 2152 { 2153 rdma_nl_register(RDMA_NL_NLDEV, nldev_cb_table); 2154 } 2155 2156 void __exit nldev_exit(void) 2157 { 2158 rdma_nl_unregister(RDMA_NL_NLDEV); 2159 } 2160 2161 MODULE_ALIAS_RDMA_NETLINK(RDMA_NL_NLDEV, 5); 2162