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