1 // SPDX-License-Identifier: GPL-2.0 1 // SPDX-License-Identifier: GPL-2.0
2 /* 2 /*
3 * KUnit resource API for test managed resourc 3 * KUnit resource API for test managed resources (allocations, etc.).
4 * 4 *
5 * Copyright (C) 2022, Google LLC. 5 * Copyright (C) 2022, Google LLC.
6 * Author: Daniel Latypov <dlatypov@google.com 6 * Author: Daniel Latypov <dlatypov@google.com>
7 */ 7 */
8 8
9 #include <kunit/resource.h> 9 #include <kunit/resource.h>
10 #include <kunit/test.h> 10 #include <kunit/test.h>
11 #include <linux/kref.h> 11 #include <linux/kref.h>
12 12
13 /* 13 /*
14 * Used for static resources and when a kunit_ 14 * Used for static resources and when a kunit_resource * has been created by
15 * kunit_alloc_resource(). When an init funct 15 * kunit_alloc_resource(). When an init function is supplied, @data is passed
16 * into the init function; otherwise, we simpl 16 * into the init function; otherwise, we simply set the resource data field to
17 * the data value passed in. Doesn't initializ 17 * the data value passed in. Doesn't initialize res->should_kfree.
18 */ 18 */
19 int __kunit_add_resource(struct kunit *test, 19 int __kunit_add_resource(struct kunit *test,
20 kunit_resource_init_t 20 kunit_resource_init_t init,
21 kunit_resource_free_t 21 kunit_resource_free_t free,
22 struct kunit_resource 22 struct kunit_resource *res,
23 void *data) 23 void *data)
24 { 24 {
25 int ret = 0; 25 int ret = 0;
26 unsigned long flags; 26 unsigned long flags;
27 27
28 res->free = free; 28 res->free = free;
29 kref_init(&res->refcount); 29 kref_init(&res->refcount);
30 30
31 if (init) { 31 if (init) {
32 ret = init(res, data); 32 ret = init(res, data);
33 if (ret) 33 if (ret)
34 return ret; 34 return ret;
35 } else { 35 } else {
36 res->data = data; 36 res->data = data;
37 } 37 }
38 38
39 spin_lock_irqsave(&test->lock, flags); 39 spin_lock_irqsave(&test->lock, flags);
40 list_add_tail(&res->node, &test->resou 40 list_add_tail(&res->node, &test->resources);
41 /* refcount for list is established by 41 /* refcount for list is established by kref_init() */
42 spin_unlock_irqrestore(&test->lock, fl 42 spin_unlock_irqrestore(&test->lock, flags);
43 43
44 return ret; 44 return ret;
45 } 45 }
46 EXPORT_SYMBOL_GPL(__kunit_add_resource); 46 EXPORT_SYMBOL_GPL(__kunit_add_resource);
47 47
48 void kunit_remove_resource(struct kunit *test, 48 void kunit_remove_resource(struct kunit *test, struct kunit_resource *res)
49 { 49 {
50 unsigned long flags; 50 unsigned long flags;
51 bool was_linked; 51 bool was_linked;
52 52
53 spin_lock_irqsave(&test->lock, flags); 53 spin_lock_irqsave(&test->lock, flags);
54 was_linked = !list_empty(&res->node); 54 was_linked = !list_empty(&res->node);
55 list_del_init(&res->node); 55 list_del_init(&res->node);
56 spin_unlock_irqrestore(&test->lock, fl 56 spin_unlock_irqrestore(&test->lock, flags);
57 57
58 if (was_linked) 58 if (was_linked)
59 kunit_put_resource(res); 59 kunit_put_resource(res);
60 } 60 }
61 EXPORT_SYMBOL_GPL(kunit_remove_resource); 61 EXPORT_SYMBOL_GPL(kunit_remove_resource);
62 62
63 int kunit_destroy_resource(struct kunit *test, 63 int kunit_destroy_resource(struct kunit *test, kunit_resource_match_t match,
64 void *match_data) 64 void *match_data)
65 { 65 {
66 struct kunit_resource *res = kunit_fin 66 struct kunit_resource *res = kunit_find_resource(test, match,
67 67 match_data);
68 68
69 if (!res) 69 if (!res)
70 return -ENOENT; 70 return -ENOENT;
71 71
72 kunit_remove_resource(test, res); 72 kunit_remove_resource(test, res);
73 73
74 /* We have a reference also via _find( 74 /* We have a reference also via _find(); drop it. */
75 kunit_put_resource(res); 75 kunit_put_resource(res);
76 76
77 return 0; 77 return 0;
78 } 78 }
79 EXPORT_SYMBOL_GPL(kunit_destroy_resource); 79 EXPORT_SYMBOL_GPL(kunit_destroy_resource);
80 80
81 struct kunit_action_ctx { 81 struct kunit_action_ctx {
82 struct kunit_resource res; 82 struct kunit_resource res;
83 kunit_action_t *func; 83 kunit_action_t *func;
84 void *ctx; 84 void *ctx;
85 }; 85 };
86 86
87 static void __kunit_action_free(struct kunit_r 87 static void __kunit_action_free(struct kunit_resource *res)
88 { 88 {
89 struct kunit_action_ctx *action_ctx = 89 struct kunit_action_ctx *action_ctx = container_of(res, struct kunit_action_ctx, res);
90 90
91 action_ctx->func(action_ctx->ctx); 91 action_ctx->func(action_ctx->ctx);
92 } 92 }
93 93
94 94
95 int kunit_add_action(struct kunit *test, void 95 int kunit_add_action(struct kunit *test, void (*action)(void *), void *ctx)
96 { 96 {
97 struct kunit_action_ctx *action_ctx; 97 struct kunit_action_ctx *action_ctx;
98 98
99 KUNIT_ASSERT_NOT_NULL_MSG(test, action 99 KUNIT_ASSERT_NOT_NULL_MSG(test, action, "Tried to action a NULL function!");
100 100
101 action_ctx = kzalloc(sizeof(*action_ct 101 action_ctx = kzalloc(sizeof(*action_ctx), GFP_KERNEL);
102 if (!action_ctx) 102 if (!action_ctx)
103 return -ENOMEM; 103 return -ENOMEM;
104 104
105 action_ctx->func = action; 105 action_ctx->func = action;
106 action_ctx->ctx = ctx; 106 action_ctx->ctx = ctx;
107 107
108 action_ctx->res.should_kfree = true; 108 action_ctx->res.should_kfree = true;
109 /* As init is NULL, this cannot fail. 109 /* As init is NULL, this cannot fail. */
110 __kunit_add_resource(test, NULL, __kun 110 __kunit_add_resource(test, NULL, __kunit_action_free, &action_ctx->res, action_ctx);
111 111
112 return 0; 112 return 0;
113 } 113 }
114 EXPORT_SYMBOL_GPL(kunit_add_action); 114 EXPORT_SYMBOL_GPL(kunit_add_action);
115 115
116 int kunit_add_action_or_reset(struct kunit *te 116 int kunit_add_action_or_reset(struct kunit *test, void (*action)(void *),
117 void *ctx) 117 void *ctx)
118 { 118 {
119 int res = kunit_add_action(test, actio 119 int res = kunit_add_action(test, action, ctx);
120 120
121 if (res) 121 if (res)
122 action(ctx); 122 action(ctx);
123 return res; 123 return res;
124 } 124 }
125 EXPORT_SYMBOL_GPL(kunit_add_action_or_reset); 125 EXPORT_SYMBOL_GPL(kunit_add_action_or_reset);
126 126
127 static bool __kunit_action_match(struct kunit 127 static bool __kunit_action_match(struct kunit *test,
128 struct kunit_r 128 struct kunit_resource *res, void *match_data)
129 { 129 {
130 struct kunit_action_ctx *match_ctx = ( 130 struct kunit_action_ctx *match_ctx = (struct kunit_action_ctx *)match_data;
131 struct kunit_action_ctx *res_ctx = con 131 struct kunit_action_ctx *res_ctx = container_of(res, struct kunit_action_ctx, res);
132 132
133 /* Make sure this is a free function. 133 /* Make sure this is a free function. */
134 if (res->free != __kunit_action_free) 134 if (res->free != __kunit_action_free)
135 return false; 135 return false;
136 136
137 /* Both the function and context data 137 /* Both the function and context data should match. */
138 return (match_ctx->func == res_ctx->fu 138 return (match_ctx->func == res_ctx->func) && (match_ctx->ctx == res_ctx->ctx);
139 } 139 }
140 140
141 void kunit_remove_action(struct kunit *test, 141 void kunit_remove_action(struct kunit *test,
142 kunit_action_t *action 142 kunit_action_t *action,
143 void *ctx) 143 void *ctx)
144 { 144 {
145 struct kunit_action_ctx match_ctx; 145 struct kunit_action_ctx match_ctx;
146 struct kunit_resource *res; 146 struct kunit_resource *res;
147 147
148 match_ctx.func = action; 148 match_ctx.func = action;
149 match_ctx.ctx = ctx; 149 match_ctx.ctx = ctx;
150 150
151 res = kunit_find_resource(test, __kuni 151 res = kunit_find_resource(test, __kunit_action_match, &match_ctx);
152 if (res) { 152 if (res) {
153 /* Remove the free function so 153 /* Remove the free function so we don't run the action. */
154 res->free = NULL; 154 res->free = NULL;
155 kunit_remove_resource(test, re 155 kunit_remove_resource(test, res);
156 kunit_put_resource(res); 156 kunit_put_resource(res);
157 } 157 }
158 } 158 }
159 EXPORT_SYMBOL_GPL(kunit_remove_action); 159 EXPORT_SYMBOL_GPL(kunit_remove_action);
160 160
161 void kunit_release_action(struct kunit *test, 161 void kunit_release_action(struct kunit *test,
162 kunit_action_t *actio 162 kunit_action_t *action,
163 void *ctx) 163 void *ctx)
164 { 164 {
165 struct kunit_action_ctx match_ctx; 165 struct kunit_action_ctx match_ctx;
166 struct kunit_resource *res; 166 struct kunit_resource *res;
167 167
168 match_ctx.func = action; 168 match_ctx.func = action;
169 match_ctx.ctx = ctx; 169 match_ctx.ctx = ctx;
170 170
171 res = kunit_find_resource(test, __kuni 171 res = kunit_find_resource(test, __kunit_action_match, &match_ctx);
172 if (res) { 172 if (res) {
173 kunit_remove_resource(test, re 173 kunit_remove_resource(test, res);
174 /* We have to put() this here, 174 /* We have to put() this here, else free won't be called. */
175 kunit_put_resource(res); 175 kunit_put_resource(res);
176 } 176 }
177 } 177 }
178 EXPORT_SYMBOL_GPL(kunit_release_action); 178 EXPORT_SYMBOL_GPL(kunit_release_action);
179 179
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.