Merge branches 'doc.2023.05.10a', 'fixes.2023.05.11a', 'kvfree.2023.05.10a',... (2e31da75) · Commits · jan.koester / Linux

Documentation/RCU/Design/Requirements/Requirements.rst

+1 −35

Original line number	Diff line number	Diff line
		@@ -2071,41 +2071,7 @@ call.

		Because RCU avoids interrupting idle CPUs, it is illegal to execute an
		RCU read-side critical section on an idle CPU. (Kernels built with
		``CONFIG_PROVE_RCU=y`` will splat if you try it.) The RCU_NONIDLE()
		macro and ``_rcuidle`` event tracing is provided to work around this
		restriction. In addition, rcu_is_watching() may be used to test
		whether or not it is currently legal to run RCU read-side critical
		sections on this CPU. I learned of the need for diagnostics on the one
		hand and RCU_NONIDLE() on the other while inspecting idle-loop code.
		Steven Rostedt supplied ``_rcuidle`` event tracing, which is used quite
		heavily in the idle loop. However, there are some restrictions on the
		code placed within RCU_NONIDLE():

		#. Blocking is prohibited. In practice, this is not a serious
		restriction given that idle tasks are prohibited from blocking to
		begin with.
		#. Although nesting RCU_NONIDLE() is permitted, they cannot nest
		indefinitely deeply. However, given that they can be nested on the
		order of a million deep, even on 32-bit systems, this should not be a
		serious restriction. This nesting limit would probably be reached
		long after the compiler OOMed or the stack overflowed.
		#. Any code path that enters RCU_NONIDLE() must sequence out of that
		same RCU_NONIDLE(). For example, the following is grossly
		illegal:

		::

		1 RCU_NONIDLE({
		2 do_something();
		3 goto bad_idea; /* BUG!!! */
		4 do_something_else();});
		5 bad_idea:


		It is just as illegal to transfer control into the middle of
		RCU_NONIDLE()'s argument. Yes, in theory, you could transfer in
		as long as you also transferred out, but in practice you could also
		expect to get sharply worded review comments.
		``CONFIG_PROVE_RCU=y`` will splat if you try it.)

		It is similarly socially unacceptable to interrupt an ``nohz_full`` CPU
		running in userspace. RCU must therefore track ``nohz_full`` userspace

Documentation/RCU/whatisRCU.rst

+0 −1

Original line number	Diff line number	Diff line
		@@ -1117,7 +1117,6 @@ All: lockdep-checked RCU utility APIs::

		RCU_LOCKDEP_WARN
		rcu_sleep_check
		RCU_NONIDLE

		All: Unchecked RCU-protected pointer access::

Documentation/admin-guide/kernel-parameters.txt

+11 −2

Original line number	Diff line number	Diff line
		@@ -5094,8 +5094,17 @@

		rcutorture.stall_cpu_block= [KNL]
		Sleep while stalling if set. This will result
		in warnings from preemptible RCU in addition
		to any other stall-related activity.
		in warnings from preemptible RCU in addition to
		any other stall-related activity. Note that
		in kernels built with CONFIG_PREEMPTION=n and
		CONFIG_PREEMPT_COUNT=y, this parameter will
		cause the CPU to pass through a quiescent state.
		Given CONFIG_PREEMPTION=n, this will suppress
		RCU CPU stall warnings, but will instead result
		in scheduling-while-atomic splats.

		Use of this module parameter results in splats.


		rcutorture.stall_cpu_holdoff= [KNL]
		Time to wait (s) after boot before inducing stall.

include/linux/notifier.h

+10 −0

Original line number	Diff line number	Diff line
		@@ -106,12 +106,22 @@ extern void srcu_init_notifier_head(struct srcu_notifier_head *nh);
		#define RAW_NOTIFIER_INIT(name) { \
		.head = NULL }

		#ifdef CONFIG_TREE_SRCU
		#define SRCU_NOTIFIER_INIT(name, pcpu) \
		{ \
		.mutex = __MUTEX_INITIALIZER(name.mutex), \
		.head = NULL, \
		.srcuu = __SRCU_USAGE_INIT(name.srcuu), \
		.srcu = __SRCU_STRUCT_INIT(name.srcu, name.srcuu, pcpu), \
		}
		#else
		#define SRCU_NOTIFIER_INIT(name, pcpu) \
		{ \
		.mutex = __MUTEX_INITIALIZER(name.mutex), \
		.head = NULL, \
		.srcu = __SRCU_STRUCT_INIT(name.srcu, name.srcuu, pcpu), \
		}
		#endif

		#define ATOMIC_NOTIFIER_HEAD(name) \
		struct atomic_notifier_head name = \

include/linux/rcupdate.h

+8 −46

Original line number	Diff line number	Diff line
		@@ -156,31 +156,6 @@ static inline int rcu_nocb_cpu_deoffload(int cpu) { return 0; }
		static inline void rcu_nocb_flush_deferred_wakeup(void) { }
		#endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */

		/**
		* RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
		* @a: Code that RCU needs to pay attention to.
		*
		* RCU read-side critical sections are forbidden in the inner idle loop,
		* that is, between the ct_idle_enter() and the ct_idle_exit() -- RCU
		* will happily ignore any such read-side critical sections. However,
		* things like powertop need tracepoints in the inner idle loop.
		*
		* This macro provides the way out: RCU_NONIDLE(do_something_with_RCU())
		* will tell RCU that it needs to pay attention, invoke its argument
		* (in this example, calling the do_something_with_RCU() function),
		* and then tell RCU to go back to ignoring this CPU. It is permissible
		* to nest RCU_NONIDLE() wrappers, but not indefinitely (but the limit is
		* on the order of a million or so, even on 32-bit systems). It is
		* not legal to block within RCU_NONIDLE(), nor is it permissible to
		* transfer control either into or out of RCU_NONIDLE()'s statement.
		*/
		#define RCU_NONIDLE(a) \
		do { \
		ct_irq_enter_irqson(); \
		do { a; } while (0); \
		ct_irq_exit_irqson(); \
		} while (0)

		/*
		* Note a quasi-voluntary context switch for RCU-tasks's benefit.
		* This is a macro rather than an inline function to avoid #include hell.
		@@ -957,9 +932,8 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)

		/**
		* kfree_rcu() - kfree an object after a grace period.
		* @ptr: pointer to kfree for both single- and double-argument invocations.
		* @rhf: the name of the struct rcu_head within the type of @ptr,
		* but only for double-argument invocations.
		* @ptr: pointer to kfree for double-argument invocations.
		* @rhf: the name of the struct rcu_head within the type of @ptr.
		*
		* Many rcu callbacks functions just call kfree() on the base structure.
		* These functions are trivial, but their size adds up, and furthermore
		@@ -984,26 +958,18 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
		* The BUILD_BUG_ON check must not involve any function calls, hence the
		* checks are done in macros here.
		*/
		#define kfree_rcu(ptr, rhf...) kvfree_rcu(ptr, ## rhf)
		#define kfree_rcu(ptr, rhf) kvfree_rcu_arg_2(ptr, rhf)
		#define kvfree_rcu(ptr, rhf) kvfree_rcu_arg_2(ptr, rhf)

		/**
		* kvfree_rcu() - kvfree an object after a grace period.
		*
		* This macro consists of one or two arguments and it is
		* based on whether an object is head-less or not. If it
		* has a head then a semantic stays the same as it used
		* to be before:
		*
		* kvfree_rcu(ptr, rhf);
		*
		* where @ptr is a pointer to kvfree(), @rhf is the name
		* of the rcu_head structure within the type of @ptr.
		* kfree_rcu_mightsleep() - kfree an object after a grace period.
		* @ptr: pointer to kfree for single-argument invocations.
		*
		* When it comes to head-less variant, only one argument
		* is passed and that is just a pointer which has to be
		* freed after a grace period. Therefore the semantic is
		*
		* kvfree_rcu(ptr);
		* kfree_rcu_mightsleep(ptr);
		*
		* where @ptr is the pointer to be freed by kvfree().
		*
		@@ -1012,13 +978,9 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
		* annotation. Otherwise, please switch and embed the
		* rcu_head structure within the type of @ptr.
		*/
		#define kvfree_rcu(...) KVFREE_GET_MACRO(__VA_ARGS__, \
		kvfree_rcu_arg_2, kvfree_rcu_arg_1)(__VA_ARGS__)

		#define kfree_rcu_mightsleep(ptr) kvfree_rcu_arg_1(ptr)
		#define kvfree_rcu_mightsleep(ptr) kvfree_rcu_arg_1(ptr)
		#define kfree_rcu_mightsleep(ptr) kvfree_rcu_mightsleep(ptr)

		#define KVFREE_GET_MACRO(_1, _2, NAME, ...) NAME
		#define kvfree_rcu_arg_2(ptr, rhf) \
		do { \
		typeof (ptr) ___p = (ptr); \