Merge branches 'doc.2022.08.31b', 'fixes.2022.08.31b', 'kvfree.2022.08.31b',... (5c0ec490) · Commits · EulixOS / Software / Kernel

include/linux/rcupdate.h

+37 −5

Original line number	Diff line number	Diff line
		@@ -42,7 +42,31 @@ void call_rcu(struct rcu_head *head, rcu_callback_t func);
		void rcu_barrier_tasks(void);
		void rcu_barrier_tasks_rude(void);
		void synchronize_rcu(void);

		struct rcu_gp_oldstate;
		unsigned long get_completed_synchronize_rcu(void);
		void get_completed_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp);

		// Maximum number of unsigned long values corresponding to
		// not-yet-completed RCU grace periods.
		#define NUM_ACTIVE_RCU_POLL_OLDSTATE 2

		/**
		* same_state_synchronize_rcu - Are two old-state values identical?
		* @oldstate1: First old-state value.
		* @oldstate2: Second old-state value.
		*
		* The two old-state values must have been obtained from either
		* get_state_synchronize_rcu(), start_poll_synchronize_rcu(), or
		* get_completed_synchronize_rcu(). Returns @true if the two values are
		* identical and @false otherwise. This allows structures whose lifetimes
		* are tracked by old-state values to push these values to a list header,
		* allowing those structures to be slightly smaller.
		*/
		static inline bool same_state_synchronize_rcu(unsigned long oldstate1, unsigned long oldstate2)
		{
		return oldstate1 == oldstate2;
		}

		#ifdef CONFIG_PREEMPT_RCU

		@@ -496,13 +520,21 @@ do { \
		* against NULL. Although rcu_access_pointer() may also be used in cases
		* where update-side locks prevent the value of the pointer from changing,
		* you should instead use rcu_dereference_protected() for this use case.
		* Within an RCU read-side critical section, there is little reason to
		* use rcu_access_pointer().
		*
		* It is usually best to test the rcu_access_pointer() return value
		* directly in order to avoid accidental dereferences being introduced
		* by later inattentive changes. In other words, assigning the
		* rcu_access_pointer() return value to a local variable results in an
		* accident waiting to happen.
		*
		* It is also permissible to use rcu_access_pointer() when read-side
		* access to the pointer was removed at least one grace period ago, as
		* is the case in the context of the RCU callback that is freeing up
		* the data, or after a synchronize_rcu() returns. This can be useful
		* when tearing down multi-linked structures after a grace period
		* has elapsed.
		* access to the pointer was removed at least one grace period ago, as is
		* the case in the context of the RCU callback that is freeing up the data,
		* or after a synchronize_rcu() returns. This can be useful when tearing
		* down multi-linked structures after a grace period has elapsed. However,
		* rcu_dereference_protected() is normally preferred for this use case.
		*/
		#define rcu_access_pointer(p) __rcu_access_pointer((p), __UNIQUE_ID(rcu), __rcu)

include/linux/rcutiny.h

+50 −0

Original line number	Diff line number	Diff line
		@@ -14,25 +14,75 @@

		#include <asm/param.h> /* for HZ */

		struct rcu_gp_oldstate {
		unsigned long rgos_norm;
		};

		// Maximum number of rcu_gp_oldstate values corresponding to
		// not-yet-completed RCU grace periods.
		#define NUM_ACTIVE_RCU_POLL_FULL_OLDSTATE 2

		/*
		* Are the two oldstate values the same? See the Tree RCU version for
		* docbook header.
		*/
		static inline bool same_state_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp1,
		struct rcu_gp_oldstate *rgosp2)
		{
		return rgosp1->rgos_norm == rgosp2->rgos_norm;
		}

		unsigned long get_state_synchronize_rcu(void);

		static inline void get_state_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp)
		{
		rgosp->rgos_norm = get_state_synchronize_rcu();
		}

		unsigned long start_poll_synchronize_rcu(void);

		static inline void start_poll_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp)
		{
		rgosp->rgos_norm = start_poll_synchronize_rcu();
		}

		bool poll_state_synchronize_rcu(unsigned long oldstate);

		static inline bool poll_state_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp)
		{
		return poll_state_synchronize_rcu(rgosp->rgos_norm);
		}

		static inline void cond_synchronize_rcu(unsigned long oldstate)
		{
		might_sleep();
		}

		static inline void cond_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp)
		{
		cond_synchronize_rcu(rgosp->rgos_norm);
		}

		static inline unsigned long start_poll_synchronize_rcu_expedited(void)
		{
		return start_poll_synchronize_rcu();
		}

		static inline void start_poll_synchronize_rcu_expedited_full(struct rcu_gp_oldstate *rgosp)
		{
		rgosp->rgos_norm = start_poll_synchronize_rcu_expedited();
		}

		static inline void cond_synchronize_rcu_expedited(unsigned long oldstate)
		{
		cond_synchronize_rcu(oldstate);
		}

		static inline void cond_synchronize_rcu_expedited_full(struct rcu_gp_oldstate *rgosp)
		{
		cond_synchronize_rcu_expedited(rgosp->rgos_norm);
		}

		extern void rcu_barrier(void);

		static inline void synchronize_rcu_expedited(void)

include/linux/rcutree.h

+40 −0

Original line number	Diff line number	Diff line
		@@ -40,12 +40,52 @@ bool rcu_eqs_special_set(int cpu);
		void rcu_momentary_dyntick_idle(void);
		void kfree_rcu_scheduler_running(void);
		bool rcu_gp_might_be_stalled(void);

		struct rcu_gp_oldstate {
		unsigned long rgos_norm;
		unsigned long rgos_exp;
		};

		// Maximum number of rcu_gp_oldstate values corresponding to
		// not-yet-completed RCU grace periods.
		#define NUM_ACTIVE_RCU_POLL_FULL_OLDSTATE 4

		/**
		* same_state_synchronize_rcu_full - Are two old-state values identical?
		* @rgosp1: First old-state value.
		* @rgosp2: Second old-state value.
		*
		* The two old-state values must have been obtained from either
		* get_state_synchronize_rcu_full(), start_poll_synchronize_rcu_full(),
		* or get_completed_synchronize_rcu_full(). Returns @true if the two
		* values are identical and @false otherwise. This allows structures
		* whose lifetimes are tracked by old-state values to push these values
		* to a list header, allowing those structures to be slightly smaller.
		*
		* Note that equality is judged on a bitwise basis, so that an
		* @rcu_gp_oldstate structure with an already-completed state in one field
		* will compare not-equal to a structure with an already-completed state
		* in the other field. After all, the @rcu_gp_oldstate structure is opaque
		* so how did such a situation come to pass in the first place?
		*/
		static inline bool same_state_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp1,
		struct rcu_gp_oldstate *rgosp2)
		{
		return rgosp1->rgos_norm == rgosp2->rgos_norm && rgosp1->rgos_exp == rgosp2->rgos_exp;
		}

		unsigned long start_poll_synchronize_rcu_expedited(void);
		void start_poll_synchronize_rcu_expedited_full(struct rcu_gp_oldstate *rgosp);
		void cond_synchronize_rcu_expedited(unsigned long oldstate);
		void cond_synchronize_rcu_expedited_full(struct rcu_gp_oldstate *rgosp);
		unsigned long get_state_synchronize_rcu(void);
		void get_state_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp);
		unsigned long start_poll_synchronize_rcu(void);
		void start_poll_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp);
		bool poll_state_synchronize_rcu(unsigned long oldstate);
		bool poll_state_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp);
		void cond_synchronize_rcu(unsigned long oldstate);
		void cond_synchronize_rcu_full(struct rcu_gp_oldstate *rgosp);

		bool rcu_is_idle_cpu(int cpu);

include/linux/srcutiny.h

+6 −4

Original line number	Diff line number	Diff line
		@@ -15,10 +15,10 @@

		struct srcu_struct {
		short srcu_lock_nesting[2]; /* srcu_read_lock() nesting depth. */
		unsigned short srcu_idx; /* Current reader array element in bit 0x2. */
		unsigned short srcu_idx_max; /* Furthest future srcu_idx request. */
		u8 srcu_gp_running; /* GP workqueue running? */
		u8 srcu_gp_waiting; /* GP waiting for readers? */
		unsigned long srcu_idx; /* Current reader array element in bit 0x2. */
		unsigned long srcu_idx_max; /* Furthest future srcu_idx request. */
		struct swait_queue_head srcu_wq;
		/* Last srcu_read_unlock() wakes GP. */
		struct rcu_head srcu_cb_head; / Pending callbacks: Head. */
		@@ -82,10 +82,12 @@ static inline void srcu_torture_stats_print(struct srcu_struct *ssp,
		int idx;

		idx = ((data_race(READ_ONCE(ssp->srcu_idx)) + 1) & 0x2) >> 1;
		pr_alert("%s%s Tiny SRCU per-CPU(idx=%d): (%hd,%hd)\n",
		pr_alert("%s%s Tiny SRCU per-CPU(idx=%d): (%hd,%hd) gp: %lu->%lu\n",
		tt, tf, idx,
		data_race(READ_ONCE(ssp->srcu_lock_nesting[!idx])),
		data_race(READ_ONCE(ssp->srcu_lock_nesting[idx])));
		data_race(READ_ONCE(ssp->srcu_lock_nesting[idx])),
		data_race(READ_ONCE(ssp->srcu_idx)),
		data_race(READ_ONCE(ssp->srcu_idx_max)));
		}

		#endif

kernel/rcu/rcutorture.c

+248 −42

File changed.

Preview size limit exceeded, changes collapsed.