d13128c70dddc2b440f29f167efe0862d8792e2e
[sfrench/cifs-2.6.git] / fs / btrfs / locking.c
1 /*
2  * Copyright (C) 2008 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18 #include <linux/sched.h>
19 #include <linux/pagemap.h>
20 #include <linux/spinlock.h>
21 #include <linux/page-flags.h>
22 #include <asm/bug.h>
23 #include "ctree.h"
24 #include "extent_io.h"
25 #include "locking.h"
26
27 static void btrfs_assert_tree_read_locked(struct extent_buffer *eb);
28
29 /*
30  * if we currently have a spinning reader or writer lock
31  * (indicated by the rw flag) this will bump the count
32  * of blocking holders and drop the spinlock.
33  */
34 void btrfs_set_lock_blocking_rw(struct extent_buffer *eb, int rw)
35 {
36         /*
37          * no lock is required.  The lock owner may change if
38          * we have a read lock, but it won't change to or away
39          * from us.  If we have the write lock, we are the owner
40          * and it'll never change.
41          */
42         if (eb->lock_nested && current->pid == eb->lock_owner)
43                 return;
44         if (rw == BTRFS_WRITE_LOCK) {
45                 if (atomic_read(&eb->blocking_writers) == 0) {
46                         WARN_ON(atomic_read(&eb->spinning_writers) != 1);
47                         atomic_dec(&eb->spinning_writers);
48                         btrfs_assert_tree_locked(eb);
49                         atomic_inc(&eb->blocking_writers);
50                         write_unlock(&eb->lock);
51                 }
52         } else if (rw == BTRFS_READ_LOCK) {
53                 btrfs_assert_tree_read_locked(eb);
54                 atomic_inc(&eb->blocking_readers);
55                 WARN_ON(atomic_read(&eb->spinning_readers) == 0);
56                 atomic_dec(&eb->spinning_readers);
57                 read_unlock(&eb->lock);
58         }
59 }
60
61 /*
62  * if we currently have a blocking lock, take the spinlock
63  * and drop our blocking count
64  */
65 void btrfs_clear_lock_blocking_rw(struct extent_buffer *eb, int rw)
66 {
67         /*
68          * no lock is required.  The lock owner may change if
69          * we have a read lock, but it won't change to or away
70          * from us.  If we have the write lock, we are the owner
71          * and it'll never change.
72          */
73         if (eb->lock_nested && current->pid == eb->lock_owner)
74                 return;
75
76         if (rw == BTRFS_WRITE_LOCK_BLOCKING) {
77                 BUG_ON(atomic_read(&eb->blocking_writers) != 1);
78                 write_lock(&eb->lock);
79                 WARN_ON(atomic_read(&eb->spinning_writers));
80                 atomic_inc(&eb->spinning_writers);
81                 /*
82                  * atomic_dec_and_test implies a barrier for waitqueue_active
83                  */
84                 if (atomic_dec_and_test(&eb->blocking_writers) &&
85                     waitqueue_active(&eb->write_lock_wq))
86                         wake_up(&eb->write_lock_wq);
87         } else if (rw == BTRFS_READ_LOCK_BLOCKING) {
88                 BUG_ON(atomic_read(&eb->blocking_readers) == 0);
89                 read_lock(&eb->lock);
90                 atomic_inc(&eb->spinning_readers);
91                 /*
92                  * atomic_dec_and_test implies a barrier for waitqueue_active
93                  */
94                 if (atomic_dec_and_test(&eb->blocking_readers) &&
95                     waitqueue_active(&eb->read_lock_wq))
96                         wake_up(&eb->read_lock_wq);
97         }
98 }
99
100 /*
101  * take a spinning read lock.  This will wait for any blocking
102  * writers
103  */
104 void btrfs_tree_read_lock(struct extent_buffer *eb)
105 {
106 again:
107         BUG_ON(!atomic_read(&eb->blocking_writers) &&
108                current->pid == eb->lock_owner);
109
110         read_lock(&eb->lock);
111         if (atomic_read(&eb->blocking_writers) &&
112             current->pid == eb->lock_owner) {
113                 /*
114                  * This extent is already write-locked by our thread. We allow
115                  * an additional read lock to be added because it's for the same
116                  * thread. btrfs_find_all_roots() depends on this as it may be
117                  * called on a partly (write-)locked tree.
118                  */
119                 BUG_ON(eb->lock_nested);
120                 eb->lock_nested = 1;
121                 read_unlock(&eb->lock);
122                 return;
123         }
124         if (atomic_read(&eb->blocking_writers)) {
125                 read_unlock(&eb->lock);
126                 wait_event(eb->write_lock_wq,
127                            atomic_read(&eb->blocking_writers) == 0);
128                 goto again;
129         }
130         atomic_inc(&eb->read_locks);
131         atomic_inc(&eb->spinning_readers);
132 }
133
134 /*
135  * take a spinning read lock.
136  * returns 1 if we get the read lock and 0 if we don't
137  * this won't wait for blocking writers
138  */
139 int btrfs_tree_read_lock_atomic(struct extent_buffer *eb)
140 {
141         if (atomic_read(&eb->blocking_writers))
142                 return 0;
143
144         read_lock(&eb->lock);
145         if (atomic_read(&eb->blocking_writers)) {
146                 read_unlock(&eb->lock);
147                 return 0;
148         }
149         atomic_inc(&eb->read_locks);
150         atomic_inc(&eb->spinning_readers);
151         return 1;
152 }
153
154 /*
155  * returns 1 if we get the read lock and 0 if we don't
156  * this won't wait for blocking writers
157  */
158 int btrfs_try_tree_read_lock(struct extent_buffer *eb)
159 {
160         if (atomic_read(&eb->blocking_writers))
161                 return 0;
162
163         if (!read_trylock(&eb->lock))
164                 return 0;
165
166         if (atomic_read(&eb->blocking_writers)) {
167                 read_unlock(&eb->lock);
168                 return 0;
169         }
170         atomic_inc(&eb->read_locks);
171         atomic_inc(&eb->spinning_readers);
172         return 1;
173 }
174
175 /*
176  * returns 1 if we get the read lock and 0 if we don't
177  * this won't wait for blocking writers or readers
178  */
179 int btrfs_try_tree_write_lock(struct extent_buffer *eb)
180 {
181         if (atomic_read(&eb->blocking_writers) ||
182             atomic_read(&eb->blocking_readers))
183                 return 0;
184
185         write_lock(&eb->lock);
186         if (atomic_read(&eb->blocking_writers) ||
187             atomic_read(&eb->blocking_readers)) {
188                 write_unlock(&eb->lock);
189                 return 0;
190         }
191         atomic_inc(&eb->write_locks);
192         atomic_inc(&eb->spinning_writers);
193         eb->lock_owner = current->pid;
194         return 1;
195 }
196
197 /*
198  * drop a spinning read lock
199  */
200 void btrfs_tree_read_unlock(struct extent_buffer *eb)
201 {
202         /*
203          * if we're nested, we have the write lock.  No new locking
204          * is needed as long as we are the lock owner.
205          * The write unlock will do a barrier for us, and the lock_nested
206          * field only matters to the lock owner.
207          */
208         if (eb->lock_nested && current->pid == eb->lock_owner) {
209                 eb->lock_nested = 0;
210                 return;
211         }
212         btrfs_assert_tree_read_locked(eb);
213         WARN_ON(atomic_read(&eb->spinning_readers) == 0);
214         atomic_dec(&eb->spinning_readers);
215         atomic_dec(&eb->read_locks);
216         read_unlock(&eb->lock);
217 }
218
219 /*
220  * drop a blocking read lock
221  */
222 void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb)
223 {
224         /*
225          * if we're nested, we have the write lock.  No new locking
226          * is needed as long as we are the lock owner.
227          * The write unlock will do a barrier for us, and the lock_nested
228          * field only matters to the lock owner.
229          */
230         if (eb->lock_nested && current->pid == eb->lock_owner) {
231                 eb->lock_nested = 0;
232                 return;
233         }
234         btrfs_assert_tree_read_locked(eb);
235         WARN_ON(atomic_read(&eb->blocking_readers) == 0);
236         /*
237          * atomic_dec_and_test implies a barrier for waitqueue_active
238          */
239         if (atomic_dec_and_test(&eb->blocking_readers) &&
240             waitqueue_active(&eb->read_lock_wq))
241                 wake_up(&eb->read_lock_wq);
242         atomic_dec(&eb->read_locks);
243 }
244
245 /*
246  * take a spinning write lock.  This will wait for both
247  * blocking readers or writers
248  */
249 void btrfs_tree_lock(struct extent_buffer *eb)
250 {
251         WARN_ON(eb->lock_owner == current->pid);
252 again:
253         wait_event(eb->read_lock_wq, atomic_read(&eb->blocking_readers) == 0);
254         wait_event(eb->write_lock_wq, atomic_read(&eb->blocking_writers) == 0);
255         write_lock(&eb->lock);
256         if (atomic_read(&eb->blocking_readers)) {
257                 write_unlock(&eb->lock);
258                 wait_event(eb->read_lock_wq,
259                            atomic_read(&eb->blocking_readers) == 0);
260                 goto again;
261         }
262         if (atomic_read(&eb->blocking_writers)) {
263                 write_unlock(&eb->lock);
264                 wait_event(eb->write_lock_wq,
265                            atomic_read(&eb->blocking_writers) == 0);
266                 goto again;
267         }
268         WARN_ON(atomic_read(&eb->spinning_writers));
269         atomic_inc(&eb->spinning_writers);
270         atomic_inc(&eb->write_locks);
271         eb->lock_owner = current->pid;
272 }
273
274 /*
275  * drop a spinning or a blocking write lock.
276  */
277 void btrfs_tree_unlock(struct extent_buffer *eb)
278 {
279         int blockers = atomic_read(&eb->blocking_writers);
280
281         BUG_ON(blockers > 1);
282
283         btrfs_assert_tree_locked(eb);
284         eb->lock_owner = 0;
285         atomic_dec(&eb->write_locks);
286
287         if (blockers) {
288                 WARN_ON(atomic_read(&eb->spinning_writers));
289                 atomic_dec(&eb->blocking_writers);
290                 /*
291                  * Make sure counter is updated before we wake up waiters.
292                  */
293                 smp_mb();
294                 if (waitqueue_active(&eb->write_lock_wq))
295                         wake_up(&eb->write_lock_wq);
296         } else {
297                 WARN_ON(atomic_read(&eb->spinning_writers) != 1);
298                 atomic_dec(&eb->spinning_writers);
299                 write_unlock(&eb->lock);
300         }
301 }
302
303 void btrfs_assert_tree_locked(struct extent_buffer *eb)
304 {
305         BUG_ON(!atomic_read(&eb->write_locks));
306 }
307
308 static void btrfs_assert_tree_read_locked(struct extent_buffer *eb)
309 {
310         BUG_ON(!atomic_read(&eb->read_locks));
311 }