drivers/infiniband/core/restrack.c

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