Skip to content

Commit 880fe86

Browse files
walacwalac
committed
locking: Introduce __cleanup() based infrastructure
Bugzilla: https://bugzilla.redhat.com/2216526 commit 54da6a0 Author: Peter Zijlstra <peterz@infradead.org> Date: Fri May 26 12:23:48 2023 +0200 locking: Introduce __cleanup() based infrastructure Use __attribute__((__cleanup__(func))) to build: - simple auto-release pointers using __free() - 'classes' with constructor and destructor semantics for scope-based resource management. - lock guards based on the above classes. Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org> Link: https://lkml.kernel.org/r/20230612093537.614161713%40infradead.org Signed-off-by: Wander Lairson Costa <wander@redhat.com>
1 parent cf36a5c commit 880fe86

File tree

16 files changed

+272
-1
lines changed

16 files changed

+272
-1
lines changed

‎include/linux/cleanup.h‎

Lines changed: 171 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,171 @@
1+
/* SPDX-License-Identifier: GPL-2.0 */
2+
#ifndef __LINUX_GUARDS_H
3+
#define __LINUX_GUARDS_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
11+
* the variable.
12+
*
13+
* __free(name):
14+
* variable attribute to add a scoped based cleanup to the variable.
15+
*
16+
* no_free_ptr(var):
17+
* like a non-atomic xchg(var, NULL), such that the cleanup function will
18+
* be inhibited -- provided it sanely deals with a NULL value.
19+
*
20+
* return_ptr(p):
21+
* returns p while inhibiting the __free().
22+
*
23+
* Ex.
24+
*
25+
* DEFINE_FREE(kfree, void *, if (_T) kfree(_T))
26+
*
27+
* struct obj *p __free(kfree) = kmalloc(...);
28+
* if (!p)
29+
* return NULL;
30+
*
31+
* if (!init_obj(p))
32+
* return NULL;
33+
*
34+
* return_ptr(p);
35+
*/
36+
37+
#define DEFINE_FREE(_name, _type, _free) \
38+
static inline void __free_##_name(void *p) { _type _T = *(_type *)p; _free; }
39+
40+
#define __free(_name) __cleanup(__free_##_name)
41+
42+
#define no_free_ptr(p) \
43+
({ __auto_type __ptr = (p); (p) = NULL; __ptr; })
44+
45+
#define return_ptr(p) return no_free_ptr(p)
46+
47+
48+
/*
49+
* DEFINE_CLASS(name, type, exit, init, init_args...):
50+
* helper to define the destructor and constructor for a type.
51+
* @exit is an expression using '_T' -- similar to FREE above.
52+
* @init is an expression in @init_args resulting in @type
53+
*
54+
* EXTEND_CLASS(name, ext, init, init_args...):
55+
* extends class @name to @name@ext with the new constructor
56+
*
57+
* CLASS(name, var)(args...):
58+
* declare the variable @var as an instance of the named class
59+
*
60+
* Ex.
61+
*
62+
* DEFINE_CLASS(fdget, struct fd, fdput(_T), fdget(fd), int fd)
63+
*
64+
* CLASS(fdget, f)(fd);
65+
* if (!f.file)
66+
* return -EBADF;
67+
*
68+
* // use 'f' without concern
69+
*/
70+
71+
#define DEFINE_CLASS(_name, _type, _exit, _init, _init_args...) \
72+
typedef _type class_##_name##_t; \
73+
static inline void class_##_name##_destructor(_type *p) \
74+
{ _type _T = *p; _exit; } \
75+
static inline _type class_##_name##_constructor(_init_args) \
76+
{ _type t = _init; return t; }
77+
78+
#define EXTEND_CLASS(_name, ext, _init, _init_args...) \
79+
typedef class_##_name##_t class_##_name##ext##_t; \
80+
static inline void class_##_name##ext##_destructor(class_##_name##_t *p)\
81+
{ class_##_name##_destructor(p); } \
82+
static inline class_##_name##_t class_##_name##ext##_constructor(_init_args) \
83+
{ class_##_name##_t t = _init; return t; }
84+
85+
#define CLASS(_name, var) \
86+
class_##_name##_t var __cleanup(class_##_name##_destructor) = \
87+
class_##_name##_constructor
88+
89+
90+
/*
91+
* DEFINE_GUARD(name, type, lock, unlock):
92+
* trivial wrapper around DEFINE_CLASS() above specifically
93+
* for locks.
94+
*
95+
* guard(name):
96+
* an anonymous instance of the (guard) class
97+
*
98+
* scoped_guard (name, args...) { }:
99+
* similar to CLASS(name, scope)(args), except the variable (with the
100+
* explicit name 'scope') is declard in a for-loop such that its scope is
101+
* bound to the next (compound) statement.
102+
*
103+
*/
104+
105+
#define DEFINE_GUARD(_name, _type, _lock, _unlock) \
106+
DEFINE_CLASS(_name, _type, _unlock, ({ _lock; _T; }), _type _T)
107+
108+
#define guard(_name) \
109+
CLASS(_name, __UNIQUE_ID(guard))
110+
111+
#define scoped_guard(_name, args...) \
112+
for (CLASS(_name, scope)(args), \
113+
*done = NULL; !done; done = (void *)1)
114+
115+
/*
116+
* Additional helper macros for generating lock guards with types, either for
117+
* locks that don't have a native type (eg. RCU, preempt) or those that need a
118+
* 'fat' pointer (eg. spin_lock_irqsave).
119+
*
120+
* DEFINE_LOCK_GUARD_0(name, lock, unlock, ...)
121+
* DEFINE_LOCK_GUARD_1(name, type, lock, unlock, ...)
122+
*
123+
* will result in the following type:
124+
*
125+
* typedef struct {
126+
* type *lock; // 'type := void' for the _0 variant
127+
* __VA_ARGS__;
128+
* } class_##name##_t;
129+
*
130+
* As above, both _lock and _unlock are statements, except this time '_T' will
131+
* be a pointer to the above struct.
132+
*/
133+
134+
#define __DEFINE_UNLOCK_GUARD(_name, _type, _unlock, ...) \
135+
typedef struct { \
136+
_type *lock; \
137+
__VA_ARGS__; \
138+
} class_##_name##_t; \
139+
\
140+
static inline void class_##_name##_destructor(class_##_name##_t *_T) \
141+
{ \
142+
if (_T->lock) { _unlock; } \
143+
}
144+
145+
146+
#define __DEFINE_LOCK_GUARD_1(_name, _type, _lock) \
147+
static inline class_##_name##_t class_##_name##_constructor(_type *l) \
148+
{ \
149+
class_##_name##_t _t = { .lock = l }, *_T = &_t; \
150+
_lock; \
151+
return _t; \
152+
}
153+
154+
#define __DEFINE_LOCK_GUARD_0(_name, _lock) \
155+
static inline class_##_name##_t class_##_name##_constructor(void) \
156+
{ \
157+
class_##_name##_t _t = { .lock = (void*)1 }, \
158+
*_T __maybe_unused = &_t; \
159+
_lock; \
160+
return _t; \
161+
}
162+
163+
#define DEFINE_LOCK_GUARD_1(_name, _type, _lock, _unlock, ...) \
164+
__DEFINE_UNLOCK_GUARD(_name, _type, _unlock, __VA_ARGS__) \
165+
__DEFINE_LOCK_GUARD_1(_name, _type, _lock)
166+
167+
#define DEFINE_LOCK_GUARD_0(_name, _lock, _unlock, ...) \
168+
__DEFINE_UNLOCK_GUARD(_name, void, _unlock, __VA_ARGS__) \
169+
__DEFINE_LOCK_GUARD_0(_name, _lock)
170+
171+
#endif /* __LINUX_GUARDS_H */

‎include/linux/compiler-clang.h‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,15 @@
55

66
/* Compiler specific definitions for Clang compiler */
77

8+
/*
9+
* Clang prior to 17 is being silly and considers many __cleanup() variables
10+
* as unused (because they are, their sole purpose is to go out of scope).
11+
*
12+
* https://reviews.llvm.org/D152180
13+
*/
14+
#undef __cleanup
15+
#define __cleanup(func) __maybe_unused __attribute__((__cleanup__(func)))
16+
817
/* same as gcc, this was present in clang-2.6 so we can assume it works
918
* with any version that can compile the kernel
1019
*/

‎include/linux/compiler_attributes.h‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -102,6 +102,12 @@
102102
*/
103103
#define __cold __attribute__((__cold__))
104104

105+
/*
106+
* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-cleanup-variable-attribute
107+
* clang: https://clang.llvm.org/docs/AttributeReference.html#cleanup
108+
*/
109+
#define __cleanup(func) __attribute__((__cleanup__(func)))
110+
105111
/*
106112
* Note the long name.
107113
*

‎include/linux/device.h‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@
3030
#include <linux/device/bus.h>
3131
#include <linux/device/class.h>
3232
#include <linux/device/driver.h>
33+
#include <linux/cleanup.h>
3334
#include <asm/device.h>
3435

3536
struct device;
@@ -896,6 +897,9 @@ void device_unregister(struct device *dev);
896897
void device_initialize(struct device *dev);
897898
int __must_check device_add(struct device *dev);
898899
void device_del(struct device *dev);
900+
901+
DEFINE_FREE(device_del, struct device *, if (_T) device_del(_T))
902+
899903
int device_for_each_child(struct device *dev, void *data,
900904
int (*fn)(struct device *dev, void *data));
901905
int device_for_each_child_reverse(struct device *dev, void *data,
@@ -1063,6 +1067,9 @@ extern int (*platform_notify_remove)(struct device *dev);
10631067
*/
10641068
struct device *get_device(struct device *dev);
10651069
void put_device(struct device *dev);
1070+
1071+
DEFINE_FREE(put_device, struct device *, if (_T) put_device(_T))
1072+
10661073
bool kill_device(struct device *dev);
10671074

10681075
#ifdef CONFIG_DEVTMPFS

‎include/linux/file.h‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
#include <linux/types.h>
1111
#include <linux/posix_types.h>
1212
#include <linux/errno.h>
13+
#include <linux/cleanup.h>
1314

1415
struct file;
1516

@@ -82,6 +83,8 @@ static inline void fdput_pos(struct fd f)
8283
fdput(f);
8384
}
8485

86+
DEFINE_CLASS(fd, struct fd, fdput(_T), fdget(fd), int fd)
87+
8588
extern int f_dupfd(unsigned int from, struct file *file, unsigned flags);
8689
extern int replace_fd(unsigned fd, struct file *file, unsigned flags);
8790
extern void set_close_on_exec(unsigned int fd, int flag);
@@ -90,6 +93,9 @@ extern int __get_unused_fd_flags(unsigned flags, unsigned long nofile);
9093
extern int get_unused_fd_flags(unsigned flags);
9194
extern void put_unused_fd(unsigned int fd);
9295

96+
DEFINE_CLASS(get_unused_fd, int, if (_T >= 0) put_unused_fd(_T),
97+
get_unused_fd_flags(flags), unsigned flags)
98+
9399
extern void fd_install(unsigned int fd, struct file *file);
94100

95101
extern int __receive_fd(struct file *file, int __user *ufd,

‎include/linux/irqflags.h‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@
1313
#define _LINUX_TRACE_IRQFLAGS_H
1414

1515
#include <linux/typecheck.h>
16+
#include <linux/cleanup.h>
1617
#include <asm/irqflags.h>
1718
#include <asm/percpu.h>
1819

@@ -267,4 +268,10 @@ extern void warn_bogus_irq_restore(void);
267268

268269
#define irqs_disabled_flags(flags) raw_irqs_disabled_flags(flags)
269270

271+
DEFINE_LOCK_GUARD_0(irq, local_irq_disable(), local_irq_enable())
272+
DEFINE_LOCK_GUARD_0(irqsave,
273+
local_irq_save(_T->flags),
274+
local_irq_restore(_T->flags),
275+
unsigned long flags)
276+
270277
#endif

‎include/linux/mutex.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@
1919
#include <asm/processor.h>
2020
#include <linux/osq_lock.h>
2121
#include <linux/debug_locks.h>
22+
#include <linux/cleanup.h>
2223

2324
#ifdef CONFIG_DEBUG_LOCK_ALLOC
2425
# define __DEP_MAP_MUTEX_INITIALIZER(lockname) \
@@ -219,4 +220,7 @@ extern void mutex_unlock(struct mutex *lock);
219220

220221
extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
221222

223+
DEFINE_GUARD(mutex, struct mutex *, mutex_lock(_T), mutex_unlock(_T))
224+
DEFINE_FREE(mutex, struct mutex *, if (_T) mutex_unlock(_T))
225+
222226
#endif /* __LINUX_MUTEX_H */

‎include/linux/percpu.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
#include <linux/cpumask.h>
99
#include <linux/pfn.h>
1010
#include <linux/init.h>
11+
#include <linux/cleanup.h>
1112

1213
#include <asm/percpu.h>
1314

@@ -128,6 +129,9 @@ extern void __init setup_per_cpu_areas(void);
128129
extern void __percpu *__alloc_percpu_gfp(size_t size, size_t align, gfp_t gfp) __alloc_size(1);
129130
extern void __percpu *__alloc_percpu(size_t size, size_t align) __alloc_size(1);
130131
extern void free_percpu(void __percpu *__pdata);
132+
133+
DEFINE_FREE(free_percpu, void __percpu *, free_percpu(_T))
134+
131135
extern phys_addr_t per_cpu_ptr_to_phys(void *addr);
132136

133137
#define alloc_percpu_gfp(type, gfp) \

‎include/linux/preempt.h‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
*/
99

1010
#include <linux/linkage.h>
11+
#include <linux/cleanup.h>
1112
#include <linux/list.h>
1213

1314
/*
@@ -517,4 +518,8 @@ static __always_inline void preempt_enable_nested(void)
517518
preempt_enable();
518519
}
519520

521+
DEFINE_LOCK_GUARD_0(preempt, preempt_disable(), preempt_enable())
522+
DEFINE_LOCK_GUARD_0(preempt_notrace, preempt_disable_notrace(), preempt_enable_notrace())
523+
DEFINE_LOCK_GUARD_0(migrate, migrate_disable(), migrate_enable())
524+
520525
#endif /* __LINUX_PREEMPT_H */

‎include/linux/rcupdate.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@
2727
#include <linux/preempt.h>
2828
#include <linux/bottom_half.h>
2929
#include <linux/lockdep.h>
30+
#include <linux/cleanup.h>
3031
#include <asm/processor.h>
3132
#include <linux/cpumask.h>
3233
#include <linux/context_tracking_irq.h>
@@ -1093,4 +1094,6 @@ rcu_head_after_call_rcu(struct rcu_head *rhp, rcu_callback_t f)
10931094
extern int rcu_expedited;
10941095
extern int rcu_normal;
10951096

1097+
DEFINE_LOCK_GUARD_0(rcu, rcu_read_lock(), rcu_read_unlock())
1098+
10961099
#endif /* __LINUX_RCUPDATE_H */

0 commit comments

Comments
 (0)