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 */
23int 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
40static 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 */
59void 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 */
111int 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}
124EXPORT_SYMBOL(rdma_restrack_count);
125
126static 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 */
156static 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 */
174void 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}
183EXPORT_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 */
191void 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}
199EXPORT_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 */
207void 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}
214EXPORT_SYMBOL(rdma_restrack_new);
215
216/**
217 * rdma_restrack_add() - add object to the reource tracking database
218 * @res:  resource entry
219 */
220void 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		ret = (ret < 0) ? ret : 0;
248	}
249
250	if (!ret)
251		res->valid = true;
252}
253EXPORT_SYMBOL(rdma_restrack_add);
254
255int __must_check rdma_restrack_get(struct rdma_restrack_entry *res)
256{
257	return kref_get_unless_zero(&res->kref);
258}
259EXPORT_SYMBOL(rdma_restrack_get);
260
261/**
262 * rdma_restrack_get_byid() - translate from ID to restrack object
263 * @dev: IB device
264 * @type: resource track type
265 * @id: ID to take a look
266 *
267 * Return: Pointer to restrack entry or -ENOENT in case of error.
268 */
269struct rdma_restrack_entry *
270rdma_restrack_get_byid(struct ib_device *dev,
271		       enum rdma_restrack_type type, u32 id)
272{
273	struct rdma_restrack_root *rt = &dev->res[type];
274	struct rdma_restrack_entry *res;
275
276	xa_lock(&rt->xa);
277	res = xa_load(&rt->xa, id);
278	if (!res || !rdma_restrack_get(res))
279		res = ERR_PTR(-ENOENT);
280	xa_unlock(&rt->xa);
281
282	return res;
283}
284EXPORT_SYMBOL(rdma_restrack_get_byid);
285
286static void restrack_release(struct kref *kref)
287{
288	struct rdma_restrack_entry *res;
289
290	res = container_of(kref, struct rdma_restrack_entry, kref);
291	if (res->task) {
292		put_task_struct(res->task);
293		res->task = NULL;
294	}
295	complete(&res->comp);
296}
297
298int rdma_restrack_put(struct rdma_restrack_entry *res)
299{
300	return kref_put(&res->kref, restrack_release);
301}
302EXPORT_SYMBOL(rdma_restrack_put);
303
304/**
305 * rdma_restrack_del() - delete object from the reource tracking database
306 * @res:  resource entry
307 */
308void rdma_restrack_del(struct rdma_restrack_entry *res)
309{
310	struct rdma_restrack_entry *old;
311	struct rdma_restrack_root *rt;
312	struct ib_device *dev;
313
314	if (!res->valid) {
315		if (res->task) {
316			put_task_struct(res->task);
317			res->task = NULL;
318		}
319		return;
320	}
321
322	dev = res_to_dev(res);
323	if (WARN_ON(!dev))
324		return;
325
326	rt = &dev->res[res->type];
327
328	old = xa_erase(&rt->xa, res->id);
329	if (res->type == RDMA_RESTRACK_MR || res->type == RDMA_RESTRACK_QP)
330		return;
331	WARN_ON(old != res);
332	res->valid = false;
333
334	rdma_restrack_put(res);
335	wait_for_completion(&res->comp);
336}
337EXPORT_SYMBOL(rdma_restrack_del);
338