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 = 0;
225 
226 	if (!dev)
227 		return;
228 
229 	if (res->no_track)
230 		goto out;
231 
232 	rt = &dev->res[res->type];
233 
234 	if (res->type == RDMA_RESTRACK_QP) {
235 		/* Special case to ensure that LQPN points to right QP */
236 		struct ib_qp *qp = container_of(res, struct ib_qp, res);
237 
238 		WARN_ONCE(qp->qp_num >> 24 || qp->port >> 8,
239 			  "QP number 0x%0X and port 0x%0X", qp->qp_num,
240 			  qp->port);
241 		res->id = qp->qp_num;
242 		if (qp->qp_type == IB_QPT_SMI || qp->qp_type == IB_QPT_GSI)
243 			res->id |= qp->port << 24;
244 		ret = xa_insert(&rt->xa, res->id, res, GFP_KERNEL);
245 		if (ret)
246 			res->id = 0;
247 	} else if (res->type == RDMA_RESTRACK_COUNTER) {
248 		/* Special case to ensure that cntn points to right counter */
249 		struct rdma_counter *counter;
250 
251 		counter = container_of(res, struct rdma_counter, res);
252 		ret = xa_insert(&rt->xa, counter->id, res, GFP_KERNEL);
253 		res->id = ret ? 0 : counter->id;
254 	} else {
255 		ret = xa_alloc_cyclic(&rt->xa, &res->id, res, xa_limit_32b,
256 				      &rt->next_id, GFP_KERNEL);
257 		ret = (ret < 0) ? ret : 0;
258 	}
259 
260 out:
261 	if (!ret)
262 		res->valid = true;
263 }
264 EXPORT_SYMBOL(rdma_restrack_add);
265 
266 int __must_check rdma_restrack_get(struct rdma_restrack_entry *res)
267 {
268 	return kref_get_unless_zero(&res->kref);
269 }
270 EXPORT_SYMBOL(rdma_restrack_get);
271 
272 /**
273  * rdma_restrack_get_byid() - translate from ID to restrack object
274  * @dev: IB device
275  * @type: resource track type
276  * @id: ID to take a look
277  *
278  * Return: Pointer to restrack entry or -ENOENT in case of error.
279  */
280 struct rdma_restrack_entry *
281 rdma_restrack_get_byid(struct ib_device *dev,
282 		       enum rdma_restrack_type type, u32 id)
283 {
284 	struct rdma_restrack_root *rt = &dev->res[type];
285 	struct rdma_restrack_entry *res;
286 
287 	xa_lock(&rt->xa);
288 	res = xa_load(&rt->xa, id);
289 	if (!res || !rdma_restrack_get(res))
290 		res = ERR_PTR(-ENOENT);
291 	xa_unlock(&rt->xa);
292 
293 	return res;
294 }
295 EXPORT_SYMBOL(rdma_restrack_get_byid);
296 
297 static void restrack_release(struct kref *kref)
298 {
299 	struct rdma_restrack_entry *res;
300 
301 	res = container_of(kref, struct rdma_restrack_entry, kref);
302 	if (res->task) {
303 		put_task_struct(res->task);
304 		res->task = NULL;
305 	}
306 	complete(&res->comp);
307 }
308 
309 int rdma_restrack_put(struct rdma_restrack_entry *res)
310 {
311 	return kref_put(&res->kref, restrack_release);
312 }
313 EXPORT_SYMBOL(rdma_restrack_put);
314 
315 /**
316  * rdma_restrack_del() - delete object from the reource tracking database
317  * @res:  resource entry
318  */
319 void rdma_restrack_del(struct rdma_restrack_entry *res)
320 {
321 	struct rdma_restrack_entry *old;
322 	struct rdma_restrack_root *rt;
323 	struct ib_device *dev;
324 
325 	if (!res->valid) {
326 		if (res->task) {
327 			put_task_struct(res->task);
328 			res->task = NULL;
329 		}
330 		return;
331 	}
332 
333 	if (res->no_track)
334 		goto out;
335 
336 	dev = res_to_dev(res);
337 	if (WARN_ON(!dev))
338 		return;
339 
340 	rt = &dev->res[res->type];
341 
342 	old = xa_erase(&rt->xa, res->id);
343 	if (res->type == RDMA_RESTRACK_MR || res->type == RDMA_RESTRACK_QP)
344 		return;
345 	WARN_ON(old != res);
346 
347 out:
348 	res->valid = false;
349 	rdma_restrack_put(res);
350 	wait_for_completion(&res->comp);
351 }
352 EXPORT_SYMBOL(rdma_restrack_del);
353