1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_CLEANUP_H
3 #define _LINUX_CLEANUP_H
4
5 #include <linux/compiler.h>
6
7 /*
8 * DEFINE_FREE(name, type, free):
9 * simple helper macro that defines the required wrapper for a __free()
10 * based cleanup function. @free is an expression using '_T' to access the
11 * variable. @free should typically include a NULL test before calling a
12 * function, see the example below.
13 *
14 * __free(name):
15 * variable attribute to add a scoped based cleanup to the variable.
16 *
17 * no_free_ptr(var):
18 * like a non-atomic xchg(var, NULL), such that the cleanup function will
19 * be inhibited -- provided it sanely deals with a NULL value.
20 *
21 * NOTE: this has __must_check semantics so that it is harder to accidentally
22 * leak the resource.
23 *
24 * return_ptr(p):
25 * returns p while inhibiting the __free().
26 *
27 * Ex.
28 *
29 * DEFINE_FREE(kfree, void *, if (_T) kfree(_T))
30 *
31 * void *alloc_obj(...)
32 * {
33 * struct obj *p __free(kfree) = kmalloc(...);
34 * if (!p)
35 * return NULL;
36 *
37 * if (!init_obj(p))
38 * return NULL;
39 *
40 * return_ptr(p);
41 * }
42 *
43 * NOTE: the DEFINE_FREE()'s @free expression includes a NULL test even though
44 * kfree() is fine to be called with a NULL value. This is on purpose. This way
45 * the compiler sees the end of our alloc_obj() function as:
46 *
47 * tmp = p;
48 * p = NULL;
49 * if (p)
50 * kfree(p);
51 * return tmp;
52 *
53 * And through the magic of value-propagation and dead-code-elimination, it
54 * eliminates the actual cleanup call and compiles into:
55 *
56 * return p;
57 *
58 * Without the NULL test it turns into a mess and the compiler can't help us.
59 */
60
61 #define DEFINE_FREE(_name, _type, _free) \
62 static inline void __free_##_name(void *p) { _type _T = *(_type *)p; _free; }
63
64 #define __free(_name) __cleanup(__free_##_name)
65
66 #define __get_and_null(p, nullvalue) \
67 ({ \
68 __auto_type __ptr = &(p); \
69 __auto_type __val = *__ptr; \
70 *__ptr = nullvalue; \
71 __val; \
72 })
73
74 static inline __must_check
75 const volatile void * __must_check_fn(const volatile void *val)
76 { return val; }
77
78 #define no_free_ptr(p) \
79 ((typeof(p)) __must_check_fn(__get_and_null(p, NULL)))
80
81 #define return_ptr(p) return no_free_ptr(p)
82
83
84 /*
85 * DEFINE_CLASS(name, type, exit, init, init_args...):
86 * helper to define the destructor and constructor for a type.
87 * @exit is an expression using '_T' -- similar to FREE above.
88 * @init is an expression in @init_args resulting in @type
89 *
90 * EXTEND_CLASS(name, ext, init, init_args...):
91 * extends class @name to @name@ext with the new constructor
92 *
93 * CLASS(name, var)(args...):
94 * declare the variable @var as an instance of the named class
95 *
96 * Ex.
97 *
98 * DEFINE_CLASS(fdget, struct fd, fdput(_T), fdget(fd), int fd)
99 *
100 * CLASS(fdget, f)(fd);
101 * if (!f.file)
102 * return -EBADF;
103 *
104 * // use 'f' without concern
105 */
106
107 #define DEFINE_CLASS(_name, _type, _exit, _init, _init_args...) \
108 typedef _type class_##_name##_t; \
109 static inline void class_##_name##_destructor(_type *p) \
110 { _type _T = *p; _exit; } \
111 static inline _type class_##_name##_constructor(_init_args) \
112 { _type t = _init; return t; }
113
114 #define EXTEND_CLASS(_name, ext, _init, _init_args...) \
115 typedef class_##_name##_t class_##_name##ext##_t; \
116 static inline void class_##_name##ext##_destructor(class_##_name##_t *p)\
117 { class_##_name##_destructor(p); } \
118 static inline class_##_name##_t class_##_name##ext##_constructor(_init_args) \
119 { class_##_name##_t t = _init; return t; }
120
121 #define CLASS(_name, var) \
122 class_##_name##_t var __cleanup(class_##_name##_destructor) = \
123 class_##_name##_constructor
124
125
126 /*
127 * DEFINE_GUARD(name, type, lock, unlock):
128 * trivial wrapper around DEFINE_CLASS() above specifically
129 * for locks.
130 *
131 * DEFINE_GUARD_COND(name, ext, condlock)
132 * wrapper around EXTEND_CLASS above to add conditional lock
133 * variants to a base class, eg. mutex_trylock() or
134 * mutex_lock_interruptible().
135 *
136 * guard(name):
137 * an anonymous instance of the (guard) class, not recommended for
138 * conditional locks.
139 *
140 * scoped_guard (name, args...) { }:
141 * similar to CLASS(name, scope)(args), except the variable (with the
142 * explicit name 'scope') is declard in a for-loop such that its scope is
143 * bound to the next (compound) statement.
144 *
145 * for conditional locks the loop body is skipped when the lock is not
146 * acquired.
147 *
148 * scoped_cond_guard (name, fail, args...) { }:
149 * similar to scoped_guard(), except it does fail when the lock
150 * acquire fails.
151 *
152 */
153
154 #define DEFINE_GUARD(_name, _type, _lock, _unlock) \
155 DEFINE_CLASS(_name, _type, if (_T) { _unlock; }, ({ _lock; _T; }), _type _T); \
156 static inline void * class_##_name##_lock_ptr(class_##_name##_t *_T) \
157 { return *_T; }
158
159 #define DEFINE_GUARD_COND(_name, _ext, _condlock) \
160 EXTEND_CLASS(_name, _ext, \
161 ({ void *_t = _T; if (_T && !(_condlock)) _t = NULL; _t; }), \
162 class_##_name##_t _T) \
163 static inline void * class_##_name##_ext##_lock_ptr(class_##_name##_t *_T) \
164 { return class_##_name##_lock_ptr(_T); }
165
166 #define guard(_name) \
167 CLASS(_name, __UNIQUE_ID(guard))
168
169 #define __guard_ptr(_name) class_##_name##_lock_ptr
170
171 #define scoped_guard(_name, args...) \
172 for (CLASS(_name, scope)(args), \
173 *done = NULL; __guard_ptr(_name)(&scope) && !done; done = (void *)1)
174
175 #define scoped_cond_guard(_name, _fail, args...) \
176 for (CLASS(_name, scope)(args), \
177 *done = NULL; !done; done = (void *)1) \
178 if (!__guard_ptr(_name)(&scope)) _fail; \
179 else
180
181 /*
182 * Additional helper macros for generating lock guards with types, either for
183 * locks that don't have a native type (eg. RCU, preempt) or those that need a
184 * 'fat' pointer (eg. spin_lock_irqsave).
185 *
186 * DEFINE_LOCK_GUARD_0(name, lock, unlock, ...)
187 * DEFINE_LOCK_GUARD_1(name, type, lock, unlock, ...)
188 * DEFINE_LOCK_GUARD_1_COND(name, ext, condlock)
189 *
190 * will result in the following type:
191 *
192 * typedef struct {
193 * type *lock; // 'type := void' for the _0 variant
194 * __VA_ARGS__;
195 * } class_##name##_t;
196 *
197 * As above, both _lock and _unlock are statements, except this time '_T' will
198 * be a pointer to the above struct.
199 */
200
201 #define __DEFINE_UNLOCK_GUARD(_name, _type, _unlock, ...) \
202 typedef struct { \
203 _type *lock; \
204 __VA_ARGS__; \
205 } class_##_name##_t; \
206 \
207 static inline void class_##_name##_destructor(class_##_name##_t *_T) \
208 { \
209 if (_T->lock) { _unlock; } \
210 } \
211 \
212 static inline void *class_##_name##_lock_ptr(class_##_name##_t *_T) \
213 { \
214 return _T->lock; \
215 }
216
217
218 #define __DEFINE_LOCK_GUARD_1(_name, _type, _lock) \
219 static inline class_##_name##_t class_##_name##_constructor(_type *l) \
220 { \
221 class_##_name##_t _t = { .lock = l }, *_T = &_t; \
222 _lock; \
223 return _t; \
224 }
225
226 #define __DEFINE_LOCK_GUARD_0(_name, _lock) \
227 static inline class_##_name##_t class_##_name##_constructor(void) \
228 { \
229 class_##_name##_t _t = { .lock = (void*)1 }, \
230 *_T __maybe_unused = &_t; \
231 _lock; \
232 return _t; \
233 }
234
235 #define DEFINE_LOCK_GUARD_1(_name, _type, _lock, _unlock, ...) \
236 __DEFINE_UNLOCK_GUARD(_name, _type, _unlock, __VA_ARGS__) \
237 __DEFINE_LOCK_GUARD_1(_name, _type, _lock)
238
239 #define DEFINE_LOCK_GUARD_0(_name, _lock, _unlock, ...) \
240 __DEFINE_UNLOCK_GUARD(_name, void, _unlock, __VA_ARGS__) \
241 __DEFINE_LOCK_GUARD_0(_name, _lock)
242
243 #define DEFINE_LOCK_GUARD_1_COND(_name, _ext, _condlock) \
244 EXTEND_CLASS(_name, _ext, \
245 ({ class_##_name##_t _t = { .lock = l }, *_T = &_t;\
246 if (_T->lock && !(_condlock)) _T->lock = NULL; \
247 _t; }), \
248 typeof_member(class_##_name##_t, lock) l) \
249 static inline void * class_##_name##_ext##_lock_ptr(class_##_name##_t *_T) \
250 { return class_##_name##_lock_ptr(_T); }
251
252
253 #endif /* _LINUX_CLEANUP_H */
254
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.