rcu: Remove Classic RCU (c17ef453) · Commits · e / devices / android_kernel_fairphone_FP4

include/linux/rcuclassic.h

deleted100644 → 0

+0 −178

Original line number	Diff line number	Diff line
		/*
		* Read-Copy Update mechanism for mutual exclusion (classic version)
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation; either version 2 of the License, or
		* (at your option) any later version.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*
		* You should have received a copy of the GNU General Public License
		* along with this program; if not, write to the Free Software
		* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		*
		* Copyright IBM Corporation, 2001
		*
		* Author: Dipankar Sarma <dipankar@in.ibm.com>
		*
		* Based on the original work by Paul McKenney <paulmck@us.ibm.com>
		* and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
		* Papers:
		* http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
		* http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
		*
		* For detailed explanation of Read-Copy Update mechanism see -
		* Documentation/RCU
		*
		*/

		#ifndef __LINUX_RCUCLASSIC_H
		#define __LINUX_RCUCLASSIC_H

		#include <linux/cache.h>
		#include <linux/spinlock.h>
		#include <linux/threads.h>
		#include <linux/cpumask.h>
		#include <linux/seqlock.h>

		#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
		#define RCU_SECONDS_TILL_STALL_CHECK (10 * HZ) /* for rcp->jiffies_stall */
		#define RCU_SECONDS_TILL_STALL_RECHECK (30 * HZ) /* for rcp->jiffies_stall */
		#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */

		/* Global control variables for rcupdate callback mechanism. */
		struct rcu_ctrlblk {
		long cur; /* Current batch number. */
		long completed; /* Number of the last completed batch */
		long pending; /* Number of the last pending batch */
		#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
		unsigned long gp_start; /* Time at which GP started in jiffies. */
		unsigned long jiffies_stall;
		/* Time at which to check for CPU stalls. */
		#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */

		int signaled;

		spinlock_t lock ____cacheline_internodealigned_in_smp;
		DECLARE_BITMAP(cpumask, NR_CPUS); /* CPUs that need to switch for */
		/* current batch to proceed. */
		} ____cacheline_internodealigned_in_smp;

		/* Is batch a before batch b ? */
		static inline int rcu_batch_before(long a, long b)
		{
		return (a - b) < 0;
		}

		/* Is batch a after batch b ? */
		static inline int rcu_batch_after(long a, long b)
		{
		return (a - b) > 0;
		}

		/* Per-CPU data for Read-Copy UPdate. */
		struct rcu_data {
		/* 1) quiescent state handling : */
		long quiescbatch; /* Batch # for grace period */
		int passed_quiesc; /* User-mode/idle loop etc. */
		int qs_pending; /* core waits for quiesc state */

		/* 2) batch handling */
		/*
		* if nxtlist is not NULL, then:
		* batch:
		* The batch # for the last entry of nxtlist
		* [nxttail[1], NULL = nxttail[2]):
		* Entries that batch # <= batch
		* [nxttail[0], nxttail[1]):
		* Entries that batch # <= batch - 1
		* [nxtlist, *nxttail[0]):
		* Entries that batch # <= batch - 2
		* The grace period for these entries has completed, and
		* the other grace-period-completed entries may be moved
		* here temporarily in rcu_process_callbacks().
		*/
		long batch;
		struct rcu_head *nxtlist;
		struct rcu_head **nxttail[3];
		long qlen; /* # of queued callbacks */
		struct rcu_head *donelist;
		struct rcu_head **donetail;
		long blimit; /* Upper limit on a processed batch */
		int cpu;
		struct rcu_head barrier;
		};

		/*
		* Increment the quiescent state counter.
		* The counter is a bit degenerated: We do not need to know
		* how many quiescent states passed, just if there was at least
		* one since the start of the grace period. Thus just a flag.
		*/
		extern void rcu_qsctr_inc(int cpu);
		extern void rcu_bh_qsctr_inc(int cpu);

		extern int rcu_pending(int cpu);
		extern int rcu_needs_cpu(int cpu);

		#ifdef CONFIG_DEBUG_LOCK_ALLOC
		extern struct lockdep_map rcu_lock_map;
		# define rcu_read_acquire() \
		lock_acquire(&rcu_lock_map, 0, 0, 2, 1, NULL, _THIS_IP_)
		# define rcu_read_release() lock_release(&rcu_lock_map, 1, _THIS_IP_)
		#else
		# define rcu_read_acquire() do { } while (0)
		# define rcu_read_release() do { } while (0)
		#endif

		#define __rcu_read_lock() \
		do { \
		preempt_disable(); \
		__acquire(RCU); \
		rcu_read_acquire(); \
		} while (0)
		#define __rcu_read_unlock() \
		do { \
		rcu_read_release(); \
		__release(RCU); \
		preempt_enable(); \
		} while (0)
		#define __rcu_read_lock_bh() \
		do { \
		local_bh_disable(); \
		__acquire(RCU_BH); \
		rcu_read_acquire(); \
		} while (0)
		#define __rcu_read_unlock_bh() \
		do { \
		rcu_read_release(); \
		__release(RCU_BH); \
		local_bh_enable(); \
		} while (0)

		#define __synchronize_sched() synchronize_rcu()

		#define call_rcu_sched(head, func) call_rcu(head, func)

		extern void __rcu_init(void);
		#define rcu_init_sched() do { } while (0)
		extern void rcu_check_callbacks(int cpu, int user);
		extern void rcu_restart_cpu(int cpu);

		extern long rcu_batches_completed(void);
		extern long rcu_batches_completed_bh(void);

		#define rcu_enter_nohz() do { } while (0)
		#define rcu_exit_nohz() do { } while (0)

		/* A context switch is a grace period for rcuclassic. */
		static inline int rcu_blocking_is_gp(void)
		{
		return num_online_cpus() == 1;
		}

		#endif /* __LINUX_RCUCLASSIC_H */

include/linux/rcupdate.h

+1 −3

Original line number	Diff line number	Diff line
		@@ -54,9 +54,7 @@ struct rcu_head {
		/* Internal to kernel, but needed by rcupreempt.h. */
		extern int rcu_scheduler_active;

		#if defined(CONFIG_CLASSIC_RCU)
		#include <linux/rcuclassic.h>
		#elif defined(CONFIG_TREE_RCU)
		#if defined(CONFIG_TREE_RCU)
		#include <linux/rcutree.h>
		#elif defined(CONFIG_PREEMPT_RCU)
		#include <linux/rcupreempt.h>

init/Kconfig

+2 −10

Original line number	Diff line number	Diff line
		@@ -316,21 +316,13 @@ choice
		prompt "RCU Implementation"
		default TREE_RCU

		config CLASSIC_RCU
		bool "Classic RCU"
		help
		This option selects the classic RCU implementation that is
		designed for best read-side performance on non-realtime
		systems.

		Select this option if you are unsure.

		config TREE_RCU
		bool "Tree-based hierarchical RCU"
		help
		This option selects the RCU implementation that is
		designed for very large SMP system with hundreds or
		thousands of CPUs.
		thousands of CPUs. It also scales down nicely to
		smaller systems.

		config PREEMPT_RCU
		bool "Preemptible RCU"

kernel/Makefile

+0 −1

Original line number	Diff line number	Diff line
		@@ -80,7 +80,6 @@ obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
		obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
		obj-$(CONFIG_SECCOMP) += seccomp.o
		obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
		obj-$(CONFIG_CLASSIC_RCU) += rcuclassic.o
		obj-$(CONFIG_TREE_RCU) += rcutree.o
		obj-$(CONFIG_PREEMPT_RCU) += rcupreempt.o
		obj-$(CONFIG_TREE_RCU_TRACE) += rcutree_trace.o

kernel/rcuclassic.c

deleted100644 → 0

+0 −807

File deleted.

Preview size limit exceeded, changes collapsed.