locking: Introduce __cleanup() based infrastructure (54da6a09) · Commits · EulixOS / Software / Kernel

include/linux/cleanup.h

0 → 100644

+171 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		#ifndef __LINUX_GUARDS_H
		#define __LINUX_GUARDS_H

		#include <linux/compiler.h>

		/*
		* DEFINE_FREE(name, type, free):
		* simple helper macro that defines the required wrapper for a __free()
		* based cleanup function. @free is an expression using '_T' to access
		* the variable.
		*
		* __free(name):
		* variable attribute to add a scoped based cleanup to the variable.
		*
		* no_free_ptr(var):
		* like a non-atomic xchg(var, NULL), such that the cleanup function will
		* be inhibited -- provided it sanely deals with a NULL value.
		*
		* return_ptr(p):
		* returns p while inhibiting the __free().
		*
		* Ex.
		*
		* DEFINE_FREE(kfree, void *, if (_T) kfree(_T))
		*
		* struct obj *p __free(kfree) = kmalloc(...);
		* if (!p)
		* return NULL;
		*
		* if (!init_obj(p))
		* return NULL;
		*
		* return_ptr(p);
		*/

		#define DEFINE_FREE(_name, _type, _free) \
		static inline void __free_##_name(void p) { _type _T = (_type *)p; _free; }

		#define __free(_name) __cleanup(__free_##_name)

		#define no_free_ptr(p) \
		({ __auto_type __ptr = (p); (p) = NULL; __ptr; })

		#define return_ptr(p) return no_free_ptr(p)


		/*
		* DEFINE_CLASS(name, type, exit, init, init_args...):
		* helper to define the destructor and constructor for a type.
		* @exit is an expression using '_T' -- similar to FREE above.
		* @init is an expression in @init_args resulting in @type
		*
		* EXTEND_CLASS(name, ext, init, init_args...):
		* extends class @name to @name@ext with the new constructor
		*
		* CLASS(name, var)(args...):
		* declare the variable @var as an instance of the named class
		*
		* Ex.
		*
		* DEFINE_CLASS(fdget, struct fd, fdput(_T), fdget(fd), int fd)
		*
		* CLASS(fdget, f)(fd);
		* if (!f.file)
		* return -EBADF;
		*
		* // use 'f' without concern
		*/

		#define DEFINE_CLASS(_name, _type, _exit, _init, _init_args...) \
		typedef _type class_##_name##_t; \
		static inline void class_##_name##_destructor(_type *p) \
		{ _type _T = *p; _exit; } \
		static inline _type class_##_name##_constructor(_init_args) \
		{ _type t = _init; return t; }

		#define EXTEND_CLASS(_name, ext, _init, _init_args...) \
		typedef class_##_name##_t class_##_name##ext##_t; \
		static inline void class_##_name##ext##_destructor(class_##_name##_t *p)\
		{ class_##_name##_destructor(p); } \
		static inline class_##_name##_t class_##_name##ext##_constructor(_init_args) \
		{ class_##_name##_t t = _init; return t; }

		#define CLASS(_name, var) \
		class_##_name##_t var __cleanup(class_##_name##_destructor) = \
		class_##_name##_constructor


		/*
		* DEFINE_GUARD(name, type, lock, unlock):
		* trivial wrapper around DEFINE_CLASS() above specifically
		* for locks.
		*
		* guard(name):
		* an anonymous instance of the (guard) class
		*
		* scoped_guard (name, args...) { }:
		* similar to CLASS(name, scope)(args), except the variable (with the
		* explicit name 'scope') is declard in a for-loop such that its scope is
		* bound to the next (compound) statement.
		*
		*/

		#define DEFINE_GUARD(_name, _type, _lock, _unlock) \
		DEFINE_CLASS(_name, _type, _unlock, ({ _lock; _T; }), _type _T)

		#define guard(_name) \
		CLASS(_name, __UNIQUE_ID(guard))

		#define scoped_guard(_name, args...) \
		for (CLASS(_name, scope)(args), \
		done = NULL; !done; done = (void )1)

		/*
		* Additional helper macros for generating lock guards with types, either for
		* locks that don't have a native type (eg. RCU, preempt) or those that need a
		* 'fat' pointer (eg. spin_lock_irqsave).
		*
		* DEFINE_LOCK_GUARD_0(name, lock, unlock, ...)
		* DEFINE_LOCK_GUARD_1(name, type, lock, unlock, ...)
		*
		* will result in the following type:
		*
		* typedef struct {
		* type *lock; // 'type := void' for the _0 variant
		* __VA_ARGS__;
		* } class_##name##_t;
		*
		* As above, both _lock and _unlock are statements, except this time '_T' will
		* be a pointer to the above struct.
		*/

		#define __DEFINE_UNLOCK_GUARD(_name, _type, _unlock, ...) \
		typedef struct { \
		_type *lock; \
		__VA_ARGS__; \
		} class_##_name##_t; \
		\
		static inline void class_##_name##_destructor(class_##_name##_t *_T) \
		{ \
		if (_T->lock) { _unlock; } \
		}


		#define __DEFINE_LOCK_GUARD_1(_name, _type, _lock) \
		static inline class_##_name##_t class_##_name##_constructor(_type *l) \
		{ \
		class_##_name##_t _t = { .lock = l }, *_T = &_t; \
		_lock; \
		return _t; \
		}

		#define __DEFINE_LOCK_GUARD_0(_name, _lock) \
		static inline class_##_name##_t class_##_name##_constructor(void) \
		{ \
		class_##_name##_t _t = { .lock = (void*)1 }, \
		*_T __maybe_unused = &_t; \
		_lock; \
		return _t; \
		}

		#define DEFINE_LOCK_GUARD_1(_name, _type, _lock, _unlock, ...) \
		__DEFINE_UNLOCK_GUARD(_name, _type, _unlock, __VA_ARGS__) \
		__DEFINE_LOCK_GUARD_1(_name, _type, _lock)

		#define DEFINE_LOCK_GUARD_0(_name, _lock, _unlock, ...) \
		__DEFINE_UNLOCK_GUARD(_name, void, _unlock, __VA_ARGS__) \
		__DEFINE_LOCK_GUARD_0(_name, _lock)

		#endif /* __LINUX_GUARDS_H */

include/linux/compiler-clang.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -5,6 +5,15 @@

		/* Compiler specific definitions for Clang compiler */

		/*
		* Clang prior to 17 is being silly and considers many __cleanup() variables
		* as unused (because they are, their sole purpose is to go out of scope).
		*
		* https://reviews.llvm.org/D152180
		*/
		#undef __cleanup
		#define __cleanup(func) __maybe_unused __attribute__((__cleanup__(func)))

		/* same as gcc, this was present in clang-2.6 so we can assume it works
		* with any version that can compile the kernel
		*/

include/linux/compiler_attributes.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -69,6 +69,12 @@
		*/
		#define __assume_aligned(a, ...) __attribute__((__assume_aligned__(a, ## __VA_ARGS__)))

		/*
		* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-cleanup-variable-attribute
		* clang: https://clang.llvm.org/docs/AttributeReference.html#cleanup
		*/
		#define __cleanup(func) __attribute__((__cleanup__(func)))

		/*
		* Note the long name.
		*

include/linux/device.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@
		#include <linux/device/bus.h>
		#include <linux/device/class.h>
		#include <linux/device/driver.h>
		#include <linux/cleanup.h>
		#include <asm/device.h>

		struct device;
		@@ -899,6 +900,9 @@ void device_unregister(struct device *dev);
		void device_initialize(struct device *dev);
		int __must_check device_add(struct device *dev);
		void device_del(struct device *dev);

		DEFINE_FREE(device_del, struct device *, if (_T) device_del(_T))

		int device_for_each_child(struct device dev, void data,
		int (fn)(struct device dev, void *data));
		int device_for_each_child_reverse(struct device dev, void data,
		@@ -1066,6 +1070,9 @@ extern int (platform_notify_remove)(struct device dev);
		*/
		struct device get_device(struct device dev);
		void put_device(struct device *dev);

		DEFINE_FREE(put_device, struct device *, if (_T) put_device(_T))

		bool kill_device(struct device *dev);

		#ifdef CONFIG_DEVTMPFS

include/linux/file.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -10,6 +10,7 @@
		#include <linux/types.h>
		#include <linux/posix_types.h>
		#include <linux/errno.h>
		#include <linux/cleanup.h>

		struct file;

		@@ -80,6 +81,8 @@ static inline void fdput_pos(struct fd f)
		fdput(f);
		}

		DEFINE_CLASS(fd, struct fd, fdput(_T), fdget(fd), int fd)

		extern int f_dupfd(unsigned int from, struct file *file, unsigned flags);
		extern int replace_fd(unsigned fd, struct file *file, unsigned flags);
		extern void set_close_on_exec(unsigned int fd, int flag);
		@@ -88,6 +91,9 @@ extern int __get_unused_fd_flags(unsigned flags, unsigned long nofile);
		extern int get_unused_fd_flags(unsigned flags);
		extern void put_unused_fd(unsigned int fd);

		DEFINE_CLASS(get_unused_fd, int, if (_T >= 0) put_unused_fd(_T),
		get_unused_fd_flags(flags), unsigned flags)

		extern void fd_install(unsigned int fd, struct file *file);

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