Commit 04f2933d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'core_guards_for_6.5_rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/peterz/queue 

Pull scope-based resource management infrastructure from Peter Zijlstra:
 "These are the first few patches in the Scope-based Resource Management
  series that introduce the infrastructure but not any conversions as of
  yet.

  Adding the infrastructure now allows multiple people to start using
  them.

  Of note is that Sparse will need some work since it doesn't yet
  understand this attribute and might have decl-after-stmt issues"

* tag 'core_guards_for_6.5_rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/peterz/queue:
  kbuild: Drop -Wdeclaration-after-statement
  locking: Introduce __cleanup() based infrastructure
  apparmor: Free up __cleanup() name
  dmaengine: ioat: Free up __cleanup() name
parents 03275585 b5ec6fd2

Makefile

+1 −5
Original line number Diff line number Diff line
@@ -449,8 +449,7 @@ HOSTRUSTC = rustc 
HOSTPKG_CONFIG	= pkg-config



KBUILD_USERHOSTCFLAGS := -Wall -Wmissing-prototypes -Wstrict-prototypes \

			 -O2 -fomit-frame-pointer -std=gnu11 \

			 -Wdeclaration-after-statement

			 -O2 -fomit-frame-pointer -std=gnu11

KBUILD_USERCFLAGS  := $(KBUILD_USERHOSTCFLAGS) $(USERCFLAGS)

KBUILD_USERLDFLAGS := $(USERLDFLAGS)
@@ -1014,9 +1013,6 @@ endif 
# arch Makefile may override CC so keep this after arch Makefile is included

NOSTDINC_FLAGS += -nostdinc



# warn about C99 declaration after statement

KBUILD_CFLAGS += -Wdeclaration-after-statement



# Variable Length Arrays (VLAs) should not be used anywhere in the kernel

KBUILD_CFLAGS += -Wvla

arch/arm64/kernel/vdso32/Makefile

+0 −2
Original line number Diff line number Diff line
@@ -65,11 +65,9 @@ VDSO_CFLAGS += -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \ 
               -fno-strict-aliasing -fno-common \

               -Werror-implicit-function-declaration \

               -Wno-format-security \

               -Wdeclaration-after-statement \

               -std=gnu11

VDSO_CFLAGS  += -O2

# Some useful compiler-dependent flags from top-level Makefile

VDSO_CFLAGS += $(call cc32-option,-Wdeclaration-after-statement,)

VDSO_CFLAGS += $(call cc32-option,-Wno-pointer-sign)

VDSO_CFLAGS += -fno-strict-overflow

VDSO_CFLAGS += $(call cc32-option,-Werror=strict-prototypes)

drivers/dma/ioat/dma.c

+6 −6
Original line number Diff line number Diff line
@@ -584,11 +584,11 @@ desc_get_errstat(struct ioatdma_chan *ioat_chan, struct ioat_ring_ent *desc) 
}



/**

 * __cleanup - reclaim used descriptors

 * __ioat_cleanup - reclaim used descriptors

 * @ioat_chan: channel (ring) to clean

 * @phys_complete: zeroed (or not) completion address (from status)

 */

static void __cleanup(struct ioatdma_chan *ioat_chan, dma_addr_t phys_complete)

static void __ioat_cleanup(struct ioatdma_chan *ioat_chan, dma_addr_t phys_complete)

{

	struct ioatdma_device *ioat_dma = ioat_chan->ioat_dma;

	struct ioat_ring_ent *desc;
@@ -675,7 +675,7 @@ static void ioat_cleanup(struct ioatdma_chan *ioat_chan) 
	spin_lock_bh(&ioat_chan->cleanup_lock);



	if (ioat_cleanup_preamble(ioat_chan, &phys_complete))

		__cleanup(ioat_chan, phys_complete);

		__ioat_cleanup(ioat_chan, phys_complete);



	if (is_ioat_halted(*ioat_chan->completion)) {

		u32 chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
@@ -712,7 +712,7 @@ static void ioat_restart_channel(struct ioatdma_chan *ioat_chan) 


	ioat_quiesce(ioat_chan, 0);

	if (ioat_cleanup_preamble(ioat_chan, &phys_complete))

		__cleanup(ioat_chan, phys_complete);

		__ioat_cleanup(ioat_chan, phys_complete);



	__ioat_restart_chan(ioat_chan);

}
@@ -786,7 +786,7 @@ static void ioat_eh(struct ioatdma_chan *ioat_chan) 


	/* cleanup so tail points to descriptor that caused the error */

	if (ioat_cleanup_preamble(ioat_chan, &phys_complete))

		__cleanup(ioat_chan, phys_complete);

		__ioat_cleanup(ioat_chan, phys_complete);



	chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);

	pci_read_config_dword(pdev, IOAT_PCI_CHANERR_INT_OFFSET, &chanerr_int);
@@ -943,7 +943,7 @@ void ioat_timer_event(struct timer_list *t) 
		/* timer restarted in ioat_cleanup_preamble

		 * and IOAT_COMPLETION_ACK cleared

		 */

		__cleanup(ioat_chan, phys_complete);

		__ioat_cleanup(ioat_chan, phys_complete);

		goto unlock_out;

	}

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

 */