4d5ecb222af9e0f83a377b71aa97f520ba8d1aa2
[linux-2.6.git] / include / linux / srcu.h
1 /*
2  * Sleepable Read-Copy Update mechanism for mutual exclusion
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17  *
18  * Copyright (C) IBM Corporation, 2006
19  *
20  * Author: Paul McKenney <paulmck@us.ibm.com>
21  *
22  * For detailed explanation of Read-Copy Update mechanism see -
23  *              Documentation/RCU/ *.txt
24  *
25  */
26
27 #ifndef _LINUX_SRCU_H
28 #define _LINUX_SRCU_H
29
30 struct srcu_struct_array {
31         int c[2];
32 };
33
34 struct srcu_struct {
35         int completed;
36         struct srcu_struct_array __percpu *per_cpu_ref;
37         struct mutex mutex;
38 #ifdef CONFIG_DEBUG_LOCK_ALLOC
39         struct lockdep_map dep_map;
40 #endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
41 };
42
43 #ifndef CONFIG_PREEMPT
44 #define srcu_barrier() barrier()
45 #else /* #ifndef CONFIG_PREEMPT */
46 #define srcu_barrier()
47 #endif /* #else #ifndef CONFIG_PREEMPT */
48
49 #ifdef CONFIG_DEBUG_LOCK_ALLOC
50
51 int __init_srcu_struct(struct srcu_struct *sp, const char *name,
52                        struct lock_class_key *key);
53
54 #define init_srcu_struct(sp) \
55 ({ \
56         static struct lock_class_key __srcu_key; \
57         \
58         __init_srcu_struct((sp), #sp, &__srcu_key); \
59 })
60
61 # define srcu_read_acquire(sp) \
62                 lock_acquire(&(sp)->dep_map, 0, 0, 2, 1, NULL, _THIS_IP_)
63 # define srcu_read_release(sp) \
64                 lock_release(&(sp)->dep_map, 1, _THIS_IP_)
65
66 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
67
68 int init_srcu_struct(struct srcu_struct *sp);
69
70 # define srcu_read_acquire(sp)  do { } while (0)
71 # define srcu_read_release(sp)  do { } while (0)
72
73 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
74
75 void cleanup_srcu_struct(struct srcu_struct *sp);
76 int __srcu_read_lock(struct srcu_struct *sp) __acquires(sp);
77 void __srcu_read_unlock(struct srcu_struct *sp, int idx) __releases(sp);
78 void synchronize_srcu(struct srcu_struct *sp);
79 void synchronize_srcu_expedited(struct srcu_struct *sp);
80 long srcu_batches_completed(struct srcu_struct *sp);
81
82 #ifdef CONFIG_DEBUG_LOCK_ALLOC
83
84 /**
85  * srcu_read_lock_held - might we be in SRCU read-side critical section?
86  *
87  * If CONFIG_PROVE_LOCKING is selected and enabled, returns nonzero iff in
88  * an SRCU read-side critical section.  In absence of CONFIG_PROVE_LOCKING,
89  * this assumes we are in an SRCU read-side critical section unless it can
90  * prove otherwise.
91  */
92 static inline int srcu_read_lock_held(struct srcu_struct *sp)
93 {
94         if (debug_locks)
95                 return lock_is_held(&sp->dep_map);
96         return 1;
97 }
98
99 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
100
101 static inline int srcu_read_lock_held(struct srcu_struct *sp)
102 {
103         return 1;
104 }
105
106 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
107
108 /**
109  * srcu_dereference - fetch SRCU-protected pointer with checking
110  *
111  * Makes rcu_dereference_check() do the dirty work.
112  */
113 #define srcu_dereference(p, sp) \
114                 rcu_dereference_check(p, srcu_read_lock_held(sp))
115
116 /**
117  * srcu_read_lock - register a new reader for an SRCU-protected structure.
118  * @sp: srcu_struct in which to register the new reader.
119  *
120  * Enter an SRCU read-side critical section.  Note that SRCU read-side
121  * critical sections may be nested.
122  */
123 static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
124 {
125         int retval = __srcu_read_lock(sp);
126
127         srcu_read_acquire(sp);
128         return retval;
129 }
130
131 /**
132  * srcu_read_unlock - unregister a old reader from an SRCU-protected structure.
133  * @sp: srcu_struct in which to unregister the old reader.
134  * @idx: return value from corresponding srcu_read_lock().
135  *
136  * Exit an SRCU read-side critical section.
137  */
138 static inline void srcu_read_unlock(struct srcu_struct *sp, int idx)
139         __releases(sp)
140 {
141         srcu_read_release(sp);
142         __srcu_read_unlock(sp, idx);
143 }
144
145 #endif