xref: /linux/include/kunit/resource.h (revision 06d07429858317ded2db7986113a9e0129cd599b)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * KUnit resource API for test managed resources (allocations, etc.).
4  *
5  * Copyright (C) 2022, Google LLC.
6  * Author: Daniel Latypov <dlatypov@google.com>
7  */
8 
9 #ifndef _KUNIT_RESOURCE_H
10 #define _KUNIT_RESOURCE_H
11 
12 #include <kunit/test.h>
13 
14 #include <linux/kref.h>
15 #include <linux/list.h>
16 #include <linux/slab.h>
17 #include <linux/spinlock.h>
18 
19 struct kunit_resource;
20 
21 typedef int (*kunit_resource_init_t)(struct kunit_resource *, void *);
22 typedef void (*kunit_resource_free_t)(struct kunit_resource *);
23 
24 /**
25  * struct kunit_resource - represents a *test managed resource*
26  * @data: for the user to store arbitrary data.
27  * @name: optional name
28  * @free: a user supplied function to free the resource.
29  *
30  * Represents a *test managed resource*, a resource which will automatically be
31  * cleaned up at the end of a test case. This cleanup is performed by the 'free'
32  * function. The struct kunit_resource itself is freed automatically with
33  * kfree() if it was allocated by KUnit (e.g., by kunit_alloc_resource()), but
34  * must be freed by the user otherwise.
35  *
36  * Resources are reference counted so if a resource is retrieved via
37  * kunit_alloc_and_get_resource() or kunit_find_resource(), we need
38  * to call kunit_put_resource() to reduce the resource reference count
39  * when finished with it.  Note that kunit_alloc_resource() does not require a
40  * kunit_resource_put() because it does not retrieve the resource itself.
41  *
42  * Example:
43  *
44  * .. code-block:: c
45  *
46  *	struct kunit_kmalloc_params {
47  *		size_t size;
48  *		gfp_t gfp;
49  *	};
50  *
51  *	static int kunit_kmalloc_init(struct kunit_resource *res, void *context)
52  *	{
53  *		struct kunit_kmalloc_params *params = context;
54  *		res->data = kmalloc(params->size, params->gfp);
55  *
56  *		if (!res->data)
57  *			return -ENOMEM;
58  *
59  *		return 0;
60  *	}
61  *
62  *	static void kunit_kmalloc_free(struct kunit_resource *res)
63  *	{
64  *		kfree(res->data);
65  *	}
66  *
67  *	void *kunit_kmalloc(struct kunit *test, size_t size, gfp_t gfp)
68  *	{
69  *		struct kunit_kmalloc_params params;
70  *
71  *		params.size = size;
72  *		params.gfp = gfp;
73  *
74  *		return kunit_alloc_resource(test, kunit_kmalloc_init,
75  *			kunit_kmalloc_free, gfp, &params);
76  *	}
77  *
78  * Resources can also be named, with lookup/removal done on a name
79  * basis also.  kunit_add_named_resource(), kunit_find_named_resource()
80  * and kunit_destroy_named_resource().  Resource names must be
81  * unique within the test instance.
82  */
83 struct kunit_resource {
84 	void *data;
85 	const char *name;
86 	kunit_resource_free_t free;
87 
88 	/* private: internal use only. */
89 	struct kref refcount;
90 	struct list_head node;
91 	bool should_kfree;
92 };
93 
94 /**
95  * kunit_get_resource() - Hold resource for use.  Should not need to be used
96  *			  by most users as we automatically get resources
97  *			  retrieved by kunit_find_resource*().
98  * @res: resource
99  */
kunit_get_resource(struct kunit_resource * res)100 static inline void kunit_get_resource(struct kunit_resource *res)
101 {
102 	kref_get(&res->refcount);
103 }
104 
105 /*
106  * Called when refcount reaches zero via kunit_put_resource();
107  * should not be called directly.
108  */
kunit_release_resource(struct kref * kref)109 static inline void kunit_release_resource(struct kref *kref)
110 {
111 	struct kunit_resource *res = container_of(kref, struct kunit_resource,
112 						  refcount);
113 
114 	if (res->free)
115 		res->free(res);
116 
117 	/* 'res' is valid here, as if should_kfree is set, res->free may not free
118 	 * 'res' itself, just res->data
119 	 */
120 	if (res->should_kfree)
121 		kfree(res);
122 }
123 
124 /**
125  * kunit_put_resource() - When caller is done with retrieved resource,
126  *			  kunit_put_resource() should be called to drop
127  *			  reference count.  The resource list maintains
128  *			  a reference count on resources, so if no users
129  *			  are utilizing a resource and it is removed from
130  *			  the resource list, it will be freed via the
131  *			  associated free function (if any).  Only
132  *			  needs to be used if we alloc_and_get() or
133  *			  find() resource.
134  * @res: resource
135  */
kunit_put_resource(struct kunit_resource * res)136 static inline void kunit_put_resource(struct kunit_resource *res)
137 {
138 	kref_put(&res->refcount, kunit_release_resource);
139 }
140 
141 /**
142  * __kunit_add_resource() - Internal helper to add a resource.
143  *
144  * res->should_kfree is not initialised.
145  * @test: The test context object.
146  * @init: a user-supplied function to initialize the result (if needed).  If
147  *        none is supplied, the resource data value is simply set to @data.
148  *	  If an init function is supplied, @data is passed to it instead.
149  * @free: a user-supplied function to free the resource (if needed).
150  * @res: The resource.
151  * @data: value to pass to init function or set in resource data field.
152  */
153 int __kunit_add_resource(struct kunit *test,
154 			 kunit_resource_init_t init,
155 			 kunit_resource_free_t free,
156 			 struct kunit_resource *res,
157 			 void *data);
158 
159 /**
160  * kunit_add_resource() - Add a *test managed resource*.
161  * @test: The test context object.
162  * @init: a user-supplied function to initialize the result (if needed).  If
163  *        none is supplied, the resource data value is simply set to @data.
164  *	  If an init function is supplied, @data is passed to it instead.
165  * @free: a user-supplied function to free the resource (if needed).
166  * @res: The resource.
167  * @data: value to pass to init function or set in resource data field.
168  */
kunit_add_resource(struct kunit * test,kunit_resource_init_t init,kunit_resource_free_t free,struct kunit_resource * res,void * data)169 static inline int kunit_add_resource(struct kunit *test,
170 				     kunit_resource_init_t init,
171 				     kunit_resource_free_t free,
172 				     struct kunit_resource *res,
173 				     void *data)
174 {
175 	res->should_kfree = false;
176 	return __kunit_add_resource(test, init, free, res, data);
177 }
178 
179 static inline struct kunit_resource *
180 kunit_find_named_resource(struct kunit *test, const char *name);
181 
182 /**
183  * kunit_add_named_resource() - Add a named *test managed resource*.
184  * @test: The test context object.
185  * @init: a user-supplied function to initialize the resource data, if needed.
186  * @free: a user-supplied function to free the resource data, if needed.
187  * @res: The resource.
188  * @name: name to be set for resource.
189  * @data: value to pass to init function or set in resource data field.
190  */
kunit_add_named_resource(struct kunit * test,kunit_resource_init_t init,kunit_resource_free_t free,struct kunit_resource * res,const char * name,void * data)191 static inline int kunit_add_named_resource(struct kunit *test,
192 					   kunit_resource_init_t init,
193 					   kunit_resource_free_t free,
194 					   struct kunit_resource *res,
195 					   const char *name,
196 					   void *data)
197 {
198 	struct kunit_resource *existing;
199 
200 	if (!name)
201 		return -EINVAL;
202 
203 	existing = kunit_find_named_resource(test, name);
204 	if (existing) {
205 		kunit_put_resource(existing);
206 		return -EEXIST;
207 	}
208 
209 	res->name = name;
210 	res->should_kfree = false;
211 
212 	return __kunit_add_resource(test, init, free, res, data);
213 }
214 
215 /**
216  * kunit_alloc_and_get_resource() - Allocates and returns a *test managed resource*.
217  * @test: The test context object.
218  * @init: a user supplied function to initialize the resource.
219  * @free: a user supplied function to free the resource (if needed).
220  * @internal_gfp: gfp to use for internal allocations, if unsure, use GFP_KERNEL
221  * @context: for the user to pass in arbitrary data to the init function.
222  *
223  * Allocates a *test managed resource*, a resource which will automatically be
224  * cleaned up at the end of a test case. See &struct kunit_resource for an
225  * example.
226  *
227  * This is effectively identical to kunit_alloc_resource, but returns the
228  * struct kunit_resource pointer, not just the 'data' pointer. It therefore
229  * also increments the resource's refcount, so kunit_put_resource() should be
230  * called when you've finished with it.
231  *
232  * Note: KUnit needs to allocate memory for a kunit_resource object. You must
233  * specify an @internal_gfp that is compatible with the use context of your
234  * resource.
235  */
236 static inline struct kunit_resource *
kunit_alloc_and_get_resource(struct kunit * test,kunit_resource_init_t init,kunit_resource_free_t free,gfp_t internal_gfp,void * context)237 kunit_alloc_and_get_resource(struct kunit *test,
238 			     kunit_resource_init_t init,
239 			     kunit_resource_free_t free,
240 			     gfp_t internal_gfp,
241 			     void *context)
242 {
243 	struct kunit_resource *res;
244 	int ret;
245 
246 	res = kzalloc(sizeof(*res), internal_gfp);
247 	if (!res)
248 		return NULL;
249 
250 	res->should_kfree = true;
251 
252 	ret = __kunit_add_resource(test, init, free, res, context);
253 	if (!ret) {
254 		/*
255 		 * bump refcount for get; kunit_resource_put() should be called
256 		 * when done.
257 		 */
258 		kunit_get_resource(res);
259 		return res;
260 	}
261 	return NULL;
262 }
263 
264 /**
265  * kunit_alloc_resource() - Allocates a *test managed resource*.
266  * @test: The test context object.
267  * @init: a user supplied function to initialize the resource.
268  * @free: a user supplied function to free the resource (if needed).
269  * @internal_gfp: gfp to use for internal allocations, if unsure, use GFP_KERNEL
270  * @context: for the user to pass in arbitrary data to the init function.
271  *
272  * Allocates a *test managed resource*, a resource which will automatically be
273  * cleaned up at the end of a test case. See &struct kunit_resource for an
274  * example.
275  *
276  * Note: KUnit needs to allocate memory for a kunit_resource object. You must
277  * specify an @internal_gfp that is compatible with the use context of your
278  * resource.
279  */
kunit_alloc_resource(struct kunit * test,kunit_resource_init_t init,kunit_resource_free_t free,gfp_t internal_gfp,void * context)280 static inline void *kunit_alloc_resource(struct kunit *test,
281 					 kunit_resource_init_t init,
282 					 kunit_resource_free_t free,
283 					 gfp_t internal_gfp,
284 					 void *context)
285 {
286 	struct kunit_resource *res;
287 
288 	res = kzalloc(sizeof(*res), internal_gfp);
289 	if (!res)
290 		return NULL;
291 
292 	res->should_kfree = true;
293 	if (!__kunit_add_resource(test, init, free, res, context))
294 		return res->data;
295 
296 	return NULL;
297 }
298 
299 typedef bool (*kunit_resource_match_t)(struct kunit *test,
300 				       struct kunit_resource *res,
301 				       void *match_data);
302 
303 /**
304  * kunit_resource_name_match() - Match a resource with the same name.
305  * @test: Test case to which the resource belongs.
306  * @res: The resource.
307  * @match_name: The name to match against.
308  */
kunit_resource_name_match(struct kunit * test,struct kunit_resource * res,void * match_name)309 static inline bool kunit_resource_name_match(struct kunit *test,
310 					     struct kunit_resource *res,
311 					     void *match_name)
312 {
313 	return res->name && strcmp(res->name, match_name) == 0;
314 }
315 
316 /**
317  * kunit_find_resource() - Find a resource using match function/data.
318  * @test: Test case to which the resource belongs.
319  * @match: match function to be applied to resources/match data.
320  * @match_data: data to be used in matching.
321  */
322 static inline struct kunit_resource *
kunit_find_resource(struct kunit * test,kunit_resource_match_t match,void * match_data)323 kunit_find_resource(struct kunit *test,
324 		    kunit_resource_match_t match,
325 		    void *match_data)
326 {
327 	struct kunit_resource *res, *found = NULL;
328 	unsigned long flags;
329 
330 	spin_lock_irqsave(&test->lock, flags);
331 
332 	list_for_each_entry_reverse(res, &test->resources, node) {
333 		if (match(test, res, (void *)match_data)) {
334 			found = res;
335 			kunit_get_resource(found);
336 			break;
337 		}
338 	}
339 
340 	spin_unlock_irqrestore(&test->lock, flags);
341 
342 	return found;
343 }
344 
345 /**
346  * kunit_find_named_resource() - Find a resource using match name.
347  * @test: Test case to which the resource belongs.
348  * @name: match name.
349  */
350 static inline struct kunit_resource *
kunit_find_named_resource(struct kunit * test,const char * name)351 kunit_find_named_resource(struct kunit *test,
352 			  const char *name)
353 {
354 	return kunit_find_resource(test, kunit_resource_name_match,
355 				   (void *)name);
356 }
357 
358 /**
359  * kunit_destroy_resource() - Find a kunit_resource and destroy it.
360  * @test: Test case to which the resource belongs.
361  * @match: Match function. Returns whether a given resource matches @match_data.
362  * @match_data: Data passed into @match.
363  *
364  * RETURNS:
365  * 0 if kunit_resource is found and freed, -ENOENT if not found.
366  */
367 int kunit_destroy_resource(struct kunit *test,
368 			   kunit_resource_match_t match,
369 			   void *match_data);
370 
kunit_destroy_named_resource(struct kunit * test,const char * name)371 static inline int kunit_destroy_named_resource(struct kunit *test,
372 					       const char *name)
373 {
374 	return kunit_destroy_resource(test, kunit_resource_name_match,
375 				      (void *)name);
376 }
377 
378 /**
379  * kunit_remove_resource() - remove resource from resource list associated with
380  *			     test.
381  * @test: The test context object.
382  * @res: The resource to be removed.
383  *
384  * Note that the resource will not be immediately freed since it is likely
385  * the caller has a reference to it via alloc_and_get() or find();
386  * in this case a final call to kunit_put_resource() is required.
387  */
388 void kunit_remove_resource(struct kunit *test, struct kunit_resource *res);
389 
390 /* A 'deferred action' function to be used with kunit_add_action. */
391 typedef void (kunit_action_t)(void *);
392 
393 /**
394  * KUNIT_DEFINE_ACTION_WRAPPER() - Wrap a function for use as a deferred action.
395  *
396  * @wrapper: The name of the new wrapper function define.
397  * @orig: The original function to wrap.
398  * @arg_type: The type of the argument accepted by @orig.
399  *
400  * Defines a wrapper for a function which accepts a single, pointer-sized
401  * argument. This wrapper can then be passed to kunit_add_action() and
402  * similar. This should be used in preference to casting a function
403  * directly to kunit_action_t, as casting function pointers will break
404  * control flow integrity (CFI), leading to crashes.
405  */
406 #define KUNIT_DEFINE_ACTION_WRAPPER(wrapper, orig, arg_type)	\
407 	static void wrapper(void *in)				\
408 	{							\
409 		arg_type arg = (arg_type)in;			\
410 		orig(arg);					\
411 	}
412 
413 
414 /**
415  * kunit_add_action() - Call a function when the test ends.
416  * @test: Test case to associate the action with.
417  * @action: The function to run on test exit
418  * @ctx: Data passed into @func
419  *
420  * Defer the execution of a function until the test exits, either normally or
421  * due to a failure.  @ctx is passed as additional context. All functions
422  * registered with kunit_add_action() will execute in the opposite order to that
423  * they were registered in.
424  *
425  * This is useful for cleaning up allocated memory and resources, as these
426  * functions are called even if the test aborts early due to, e.g., a failed
427  * assertion.
428  *
429  * See also: devm_add_action() for the devres equivalent.
430  *
431  * Returns:
432  *   0 on success, an error if the action could not be deferred.
433  */
434 int kunit_add_action(struct kunit *test, kunit_action_t *action, void *ctx);
435 
436 /**
437  * kunit_add_action_or_reset() - Call a function when the test ends.
438  * @test: Test case to associate the action with.
439  * @action: The function to run on test exit
440  * @ctx: Data passed into @func
441  *
442  * Defer the execution of a function until the test exits, either normally or
443  * due to a failure.  @ctx is passed as additional context. All functions
444  * registered with kunit_add_action() will execute in the opposite order to that
445  * they were registered in.
446  *
447  * This is useful for cleaning up allocated memory and resources, as these
448  * functions are called even if the test aborts early due to, e.g., a failed
449  * assertion.
450  *
451  * If the action cannot be created (e.g., due to the system being out of memory),
452  * then action(ctx) will be called immediately, and an error will be returned.
453  *
454  * See also: devm_add_action_or_reset() for the devres equivalent.
455  *
456  * Returns:
457  *   0 on success, an error if the action could not be deferred.
458  */
459 int kunit_add_action_or_reset(struct kunit *test, kunit_action_t *action,
460 			      void *ctx);
461 
462 /**
463  * kunit_remove_action() - Cancel a matching deferred action.
464  * @test: Test case the action is associated with.
465  * @action: The deferred function to cancel.
466  * @ctx: The context passed to the deferred function to trigger.
467  *
468  * Prevent an action deferred via kunit_add_action() from executing when the
469  * test terminates.
470  *
471  * If the function/context pair was deferred multiple times, only the most
472  * recent one will be cancelled.
473  *
474  * See also: devm_remove_action() for the devres equivalent.
475  */
476 void kunit_remove_action(struct kunit *test,
477 			 kunit_action_t *action,
478 			 void *ctx);
479 
480 /**
481  * kunit_release_action() - Run a matching action call immediately.
482  * @test: Test case the action is associated with.
483  * @action: The deferred function to trigger.
484  * @ctx: The context passed to the deferred function to trigger.
485  *
486  * Execute a function deferred via kunit_add_action()) immediately, rather than
487  * when the test ends.
488  *
489  * If the function/context pair was deferred multiple times, it will only be
490  * executed once here. The most recent deferral will no longer execute when
491  * the test ends.
492  *
493  * kunit_release_action(test, func, ctx);
494  * is equivalent to
495  * func(ctx);
496  * kunit_remove_action(test, func, ctx);
497  *
498  * See also: devm_release_action() for the devres equivalent.
499  */
500 void kunit_release_action(struct kunit *test,
501 			  kunit_action_t *action,
502 			  void *ctx);
503 #endif /* _KUNIT_RESOURCE_H */
504