1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB 2 /* 3 * Copyright (c) 2017-2018 Mellanox Technologies. All rights reserved. 4 */ 5 6 #include <rdma/rdma_cm.h> 7 #include <rdma/ib_verbs.h> 8 #include <rdma/restrack.h> 9 #include <rdma/rdma_counter.h> 10 #include <linux/mutex.h> 11 #include <linux/sched/task.h> 12 #include <linux/pid_namespace.h> 13 14 #include "cma_priv.h" 15 #include "restrack.h" 16 17 /** 18 * rdma_restrack_init() - initialize and allocate resource tracking 19 * @dev: IB device 20 * 21 * Return: 0 on success 22 */ 23 int rdma_restrack_init(struct ib_device *dev) 24 { 25 struct rdma_restrack_root *rt; 26 int i; 27 28 dev->res = kcalloc(RDMA_RESTRACK_MAX, sizeof(*rt), GFP_KERNEL); 29 if (!dev->res) 30 return -ENOMEM; 31 32 rt = dev->res; 33 34 for (i = 0; i < RDMA_RESTRACK_MAX; i++) 35 xa_init_flags(&rt[i].xa, XA_FLAGS_ALLOC); 36 37 return 0; 38 } 39 40 static const char *type2str(enum rdma_restrack_type type) 41 { 42 static const char * const names[RDMA_RESTRACK_MAX] = { 43 [RDMA_RESTRACK_PD] = "PD", 44 [RDMA_RESTRACK_CQ] = "CQ", 45 [RDMA_RESTRACK_QP] = "QP", 46 [RDMA_RESTRACK_CM_ID] = "CM_ID", 47 [RDMA_RESTRACK_MR] = "MR", 48 [RDMA_RESTRACK_CTX] = "CTX", 49 [RDMA_RESTRACK_COUNTER] = "COUNTER", 50 [RDMA_RESTRACK_SRQ] = "SRQ", 51 }; 52 53 return names[type]; 54 }; 55 56 /** 57 * rdma_restrack_clean() - clean resource tracking 58 * @dev: IB device 59 */ 60 void rdma_restrack_clean(struct ib_device *dev) 61 { 62 struct rdma_restrack_root *rt = dev->res; 63 struct rdma_restrack_entry *e; 64 char buf[TASK_COMM_LEN]; 65 bool found = false; 66 const char *owner; 67 int i; 68 69 for (i = 0 ; i < RDMA_RESTRACK_MAX; i++) { 70 struct xarray *xa = &dev->res[i].xa; 71 72 if (!xa_empty(xa)) { 73 unsigned long index; 74 75 if (!found) { 76 pr_err("restrack: %s", CUT_HERE); 77 dev_err(&dev->dev, "BUG: RESTRACK detected leak of resources\n"); 78 } 79 xa_for_each(xa, index, e) { 80 if (rdma_is_kernel_res(e)) { 81 owner = e->kern_name; 82 } else { 83 /* 84 * There is no need to call get_task_struct here, 85 * because we can be here only if there are more 86 * get_task_struct() call than put_task_struct(). 87 */ 88 get_task_comm(buf, e->task); 89 owner = buf; 90 } 91 92 pr_err("restrack: %s %s object allocated by %s is not freed\n", 93 rdma_is_kernel_res(e) ? "Kernel" : 94 "User", 95 type2str(e->type), owner); 96 } 97 found = true; 98 } 99 xa_destroy(xa); 100 } 101 if (found) 102 pr_err("restrack: %s", CUT_HERE); 103 104 kfree(rt); 105 } 106 107 /** 108 * rdma_restrack_count() - the current usage of specific object 109 * @dev: IB device 110 * @type: actual type of object to operate 111 */ 112 int rdma_restrack_count(struct ib_device *dev, enum rdma_restrack_type type) 113 { 114 struct rdma_restrack_root *rt = &dev->res[type]; 115 struct rdma_restrack_entry *e; 116 XA_STATE(xas, &rt->xa, 0); 117 u32 cnt = 0; 118 119 xa_lock(&rt->xa); 120 xas_for_each(&xas, e, U32_MAX) 121 cnt++; 122 xa_unlock(&rt->xa); 123 return cnt; 124 } 125 EXPORT_SYMBOL(rdma_restrack_count); 126 127 static struct ib_device *res_to_dev(struct rdma_restrack_entry *res) 128 { 129 switch (res->type) { 130 case RDMA_RESTRACK_PD: 131 return container_of(res, struct ib_pd, res)->device; 132 case RDMA_RESTRACK_CQ: 133 return container_of(res, struct ib_cq, res)->device; 134 case RDMA_RESTRACK_QP: 135 return container_of(res, struct ib_qp, res)->device; 136 case RDMA_RESTRACK_CM_ID: 137 return container_of(res, struct rdma_id_private, 138 res)->id.device; 139 case RDMA_RESTRACK_MR: 140 return container_of(res, struct ib_mr, res)->device; 141 case RDMA_RESTRACK_CTX: 142 return container_of(res, struct ib_ucontext, res)->device; 143 case RDMA_RESTRACK_COUNTER: 144 return container_of(res, struct rdma_counter, res)->device; 145 case RDMA_RESTRACK_SRQ: 146 return container_of(res, struct ib_srq, res)->device; 147 default: 148 WARN_ONCE(true, "Wrong resource tracking type %u\n", res->type); 149 return NULL; 150 } 151 } 152 153 /** 154 * rdma_restrack_attach_task() - attach the task onto this resource, 155 * valid for user space restrack entries. 156 * @res: resource entry 157 * @task: the task to attach 158 */ 159 static void rdma_restrack_attach_task(struct rdma_restrack_entry *res, 160 struct task_struct *task) 161 { 162 if (WARN_ON_ONCE(!task)) 163 return; 164 165 if (res->task) 166 put_task_struct(res->task); 167 get_task_struct(task); 168 res->task = task; 169 res->user = true; 170 } 171 172 /** 173 * rdma_restrack_set_name() - set the task for this resource 174 * @res: resource entry 175 * @caller: kernel name, the current task will be used if the caller is NULL. 176 */ 177 void rdma_restrack_set_name(struct rdma_restrack_entry *res, const char *caller) 178 { 179 if (caller) { 180 res->kern_name = caller; 181 return; 182 } 183 184 rdma_restrack_attach_task(res, current); 185 } 186 EXPORT_SYMBOL(rdma_restrack_set_name); 187 188 /** 189 * rdma_restrack_parent_name() - set the restrack name properties based 190 * on parent restrack 191 * @dst: destination resource entry 192 * @parent: parent resource entry 193 */ 194 void rdma_restrack_parent_name(struct rdma_restrack_entry *dst, 195 const struct rdma_restrack_entry *parent) 196 { 197 if (rdma_is_kernel_res(parent)) 198 dst->kern_name = parent->kern_name; 199 else 200 rdma_restrack_attach_task(dst, parent->task); 201 } 202 EXPORT_SYMBOL(rdma_restrack_parent_name); 203 204 /** 205 * rdma_restrack_new() - Initializes new restrack entry to allow _put() interface 206 * to release memory in fully automatic way. 207 * @res: Entry to initialize 208 * @type: REstrack type 209 */ 210 void rdma_restrack_new(struct rdma_restrack_entry *res, 211 enum rdma_restrack_type type) 212 { 213 kref_init(&res->kref); 214 init_completion(&res->comp); 215 res->type = type; 216 } 217 EXPORT_SYMBOL(rdma_restrack_new); 218 219 /** 220 * rdma_restrack_add() - add object to the reource tracking database 221 * @res: resource entry 222 */ 223 void rdma_restrack_add(struct rdma_restrack_entry *res) 224 { 225 struct ib_device *dev = res_to_dev(res); 226 struct rdma_restrack_root *rt; 227 int ret = 0; 228 229 if (!dev) 230 return; 231 232 if (res->no_track) 233 goto out; 234 235 rt = &dev->res[res->type]; 236 237 if (res->type == RDMA_RESTRACK_QP) { 238 /* Special case to ensure that LQPN points to right QP */ 239 struct ib_qp *qp = container_of(res, struct ib_qp, res); 240 241 WARN_ONCE(qp->qp_num >> 24 || qp->port >> 8, 242 "QP number 0x%0X and port 0x%0X", qp->qp_num, 243 qp->port); 244 res->id = qp->qp_num; 245 if (qp->qp_type == IB_QPT_SMI || qp->qp_type == IB_QPT_GSI) 246 res->id |= qp->port << 24; 247 ret = xa_insert(&rt->xa, res->id, res, GFP_KERNEL); 248 if (ret) 249 res->id = 0; 250 } else if (res->type == RDMA_RESTRACK_COUNTER) { 251 /* Special case to ensure that cntn points to right counter */ 252 struct rdma_counter *counter; 253 254 counter = container_of(res, struct rdma_counter, res); 255 ret = xa_insert(&rt->xa, counter->id, res, GFP_KERNEL); 256 res->id = ret ? 0 : counter->id; 257 } else { 258 ret = xa_alloc_cyclic(&rt->xa, &res->id, res, xa_limit_32b, 259 &rt->next_id, GFP_KERNEL); 260 ret = (ret < 0) ? ret : 0; 261 } 262 263 out: 264 if (!ret) 265 res->valid = true; 266 } 267 EXPORT_SYMBOL(rdma_restrack_add); 268 269 int __must_check rdma_restrack_get(struct rdma_restrack_entry *res) 270 { 271 return kref_get_unless_zero(&res->kref); 272 } 273 EXPORT_SYMBOL(rdma_restrack_get); 274 275 /** 276 * rdma_restrack_get_byid() - translate from ID to restrack object 277 * @dev: IB device 278 * @type: resource track type 279 * @id: ID to take a look 280 * 281 * Return: Pointer to restrack entry or -ENOENT in case of error. 282 */ 283 struct rdma_restrack_entry * 284 rdma_restrack_get_byid(struct ib_device *dev, 285 enum rdma_restrack_type type, u32 id) 286 { 287 struct rdma_restrack_root *rt = &dev->res[type]; 288 struct rdma_restrack_entry *res; 289 290 xa_lock(&rt->xa); 291 res = xa_load(&rt->xa, id); 292 if (!res || !rdma_restrack_get(res)) 293 res = ERR_PTR(-ENOENT); 294 xa_unlock(&rt->xa); 295 296 return res; 297 } 298 EXPORT_SYMBOL(rdma_restrack_get_byid); 299 300 static void restrack_release(struct kref *kref) 301 { 302 struct rdma_restrack_entry *res; 303 304 res = container_of(kref, struct rdma_restrack_entry, kref); 305 if (res->task) { 306 put_task_struct(res->task); 307 res->task = NULL; 308 } 309 complete(&res->comp); 310 } 311 312 int rdma_restrack_put(struct rdma_restrack_entry *res) 313 { 314 return kref_put(&res->kref, restrack_release); 315 } 316 EXPORT_SYMBOL(rdma_restrack_put); 317 318 /** 319 * rdma_restrack_del() - delete object from the reource tracking database 320 * @res: resource entry 321 */ 322 void rdma_restrack_del(struct rdma_restrack_entry *res) 323 { 324 struct rdma_restrack_entry *old; 325 struct rdma_restrack_root *rt; 326 struct ib_device *dev; 327 328 if (!res->valid) { 329 if (res->task) { 330 put_task_struct(res->task); 331 res->task = NULL; 332 } 333 return; 334 } 335 336 if (res->no_track) 337 goto out; 338 339 dev = res_to_dev(res); 340 if (WARN_ON(!dev)) 341 return; 342 343 rt = &dev->res[res->type]; 344 345 old = xa_erase(&rt->xa, res->id); 346 if (res->type == RDMA_RESTRACK_MR || res->type == RDMA_RESTRACK_QP) 347 return; 348 WARN_ON(old != res); 349 350 out: 351 res->valid = false; 352 rdma_restrack_put(res); 353 wait_for_completion(&res->comp); 354 } 355 EXPORT_SYMBOL(rdma_restrack_del); 356