Merge branches 'doc.2023.07.14b', 'fixes.2023.08.16a',... (fe24a0b6) · Commits · EulixOS / Software / Kernel

Documentation/admin-guide/kernel-parameters.txt

+55 −1

Original line number	Diff line number	Diff line
		@@ -2918,6 +2918,10 @@
		locktorture.torture_type= [KNL]
		Specify the locking implementation to test.

		locktorture.writer_fifo= [KNL]
		Run the write-side locktorture kthreads at
		sched_set_fifo() real-time priority.

		locktorture.verbose= [KNL]
		Enable additional printk() statements.

		@@ -4928,6 +4932,15 @@
		test until boot completes in order to avoid
		interference.

		rcuscale.kfree_by_call_rcu= [KNL]
		In kernels built with CONFIG_RCU_LAZY=y, test
		call_rcu() instead of kfree_rcu().

		rcuscale.kfree_mult= [KNL]
		Instead of allocating an object of size kfree_obj,
		allocate one of kfree_mult * sizeof(kfree_obj).
		Defaults to 1.

		rcuscale.kfree_rcu_test= [KNL]
		Set to measure performance of kfree_rcu() flooding.

		@@ -4953,6 +4966,12 @@
		Number of loops doing rcuscale.kfree_alloc_num number
		of allocations and frees.

		rcuscale.minruntime= [KNL]
		Set the minimum test run time in seconds. This
		does not affect the data-collection interval,
		but instead allows better measurement of things
		like CPU consumption.

		rcuscale.nreaders= [KNL]
		Set number of RCU readers. The value -1 selects
		N, where N is the number of CPUs. A value
		@@ -4967,7 +4986,7 @@
		the same as for rcuscale.nreaders.
		N, where N is the number of CPUs

		rcuscale.perf_type= [KNL]
		rcuscale.scale_type= [KNL]
		Specify the RCU implementation to test.

		rcuscale.shutdown= [KNL]
		@@ -4983,6 +5002,11 @@
		in microseconds. The default of zero says
		no holdoff.

		rcuscale.writer_holdoff_jiffies= [KNL]
		Additional write-side holdoff between grace
		periods, but in jiffies. The default of zero
		says no holdoff.

		rcutorture.fqs_duration= [KNL]
		Set duration of force_quiescent_state bursts
		in microseconds.
		@@ -5264,6 +5288,13 @@
		number avoids disturbing real-time workloads,
		but lengthens grace periods.

		rcupdate.rcu_task_lazy_lim= [KNL]
		Number of callbacks on a given CPU that will
		cancel laziness on that CPU. Use -1 to disable
		cancellation of laziness, but be advised that
		doing so increases the danger of OOM due to
		callback flooding.

		rcupdate.rcu_task_stall_info= [KNL]
		Set initial timeout in jiffies for RCU task stall
		informational messages, which give some indication
		@@ -5293,6 +5324,29 @@
		A change in value does not take effect until
		the beginning of the next grace period.

		rcupdate.rcu_tasks_lazy_ms= [KNL]
		Set timeout in milliseconds RCU Tasks asynchronous
		callback batching for call_rcu_tasks().
		A negative value will take the default. A value
		of zero will disable batching. Batching is
		always disabled for synchronize_rcu_tasks().

		rcupdate.rcu_tasks_rude_lazy_ms= [KNL]
		Set timeout in milliseconds RCU Tasks
		Rude asynchronous callback batching for
		call_rcu_tasks_rude(). A negative value
		will take the default. A value of zero will
		disable batching. Batching is always disabled
		for synchronize_rcu_tasks_rude().

		rcupdate.rcu_tasks_trace_lazy_ms= [KNL]
		Set timeout in milliseconds RCU Tasks
		Trace asynchronous callback batching for
		call_rcu_tasks_trace(). A negative value
		will take the default. A value of zero will
		disable batching. Batching is always disabled
		for synchronize_rcu_tasks_trace().

		rcupdate.rcu_self_test= [KNL]
		Run the RCU early boot self tests

include/linux/notifier.h

+0 −11

Original line number	Diff line number	Diff line
		@@ -73,9 +73,7 @@ struct raw_notifier_head {

		struct srcu_notifier_head {
		struct mutex mutex;
		#ifdef CONFIG_TREE_SRCU
		struct srcu_usage srcuu;
		#endif
		struct srcu_struct srcu;
		struct notifier_block __rcu *head;
		};
		@@ -106,7 +104,6 @@ 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), \
		@@ -114,14 +111,6 @@ extern void srcu_init_notifier_head(struct srcu_notifier_head *nh);
		.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/rculist_nulls.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -101,7 +101,7 @@ static inline void hlist_nulls_add_head_rcu(struct hlist_nulls_node *n,
		{
		struct hlist_nulls_node *first = h->first;

		n->next = first;
		WRITE_ONCE(n->next, first);
		WRITE_ONCE(n->pprev, &h->first);
		rcu_assign_pointer(hlist_nulls_first_rcu(h), n);
		if (!is_a_nulls(first))
		@@ -137,7 +137,7 @@ static inline void hlist_nulls_add_tail_rcu(struct hlist_nulls_node *n,
		last = i;

		if (last) {
		n->next = last->next;
		WRITE_ONCE(n->next, last->next);
		n->pprev = &last->next;
		rcu_assign_pointer(hlist_nulls_next_rcu(last), n);
		} else {

include/linux/rcupdate_trace.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -87,6 +87,7 @@ static inline void rcu_read_unlock_trace(void)
		void call_rcu_tasks_trace(struct rcu_head *rhp, rcu_callback_t func);
		void synchronize_rcu_tasks_trace(void);
		void rcu_barrier_tasks_trace(void);
		struct task_struct *get_rcu_tasks_trace_gp_kthread(void);
		#else
		/*
		* The BPF JIT forms these addresses even when it doesn't call these

include/linux/rcupdate_wait.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -42,6 +42,11 @@ do { \
		* call_srcu() function, with this wrapper supplying the pointer to the
		* corresponding srcu_struct.
		*
		* Note that call_rcu_hurry() should be used instead of call_rcu()
		* because in kernels built with CONFIG_RCU_LAZY=y the delay between the
		* invocation of call_rcu() and that of the corresponding RCU callback
		* can be multiple seconds.
		*
		* The first argument tells Tiny RCU's _wait_rcu_gp() not to
		* bother waiting for RCU. The reason for this is because anywhere
		* synchronize_rcu_mult() can be called is automatically already a full