Btrfs: calc file extent num_bytes correctly in file clone
[linux-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 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         if (rw == BTRFS_WRITE_LOCK) {
37                 if (atomic_read(&eb->blocking_writers) == 0) {
38                         WARN_ON(atomic_read(&eb->spinning_writers) != 1);
39                         atomic_dec(&eb->spinning_writers);
40                         btrfs_assert_tree_locked(eb);
41                         atomic_inc(&eb->blocking_writers);
42                         write_unlock(&eb->lock);
43                 }
44         } else if (rw == BTRFS_READ_LOCK) {
45                 btrfs_assert_tree_read_locked(eb);
46                 atomic_inc(&eb->blocking_readers);
47                 WARN_ON(atomic_read(&eb->spinning_readers) == 0);
48                 atomic_dec(&eb->spinning_readers);
49                 read_unlock(&eb->lock);
50         }
51         return;
52 }
53
54 /*
55  * if we currently have a blocking lock, take the spinlock
56  * and drop our blocking count
57  */
58 void btrfs_clear_lock_blocking_rw(struct extent_buffer *eb, int rw)
59 {
60         if (rw == BTRFS_WRITE_LOCK_BLOCKING) {
61                 BUG_ON(atomic_read(&eb->blocking_writers) != 1);
62                 write_lock(&eb->lock);
63                 WARN_ON(atomic_read(&eb->spinning_writers));
64                 atomic_inc(&eb->spinning_writers);
65                 if (atomic_dec_and_test(&eb->blocking_writers))
66                         wake_up(&eb->write_lock_wq);
67         } else if (rw == BTRFS_READ_LOCK_BLOCKING) {
68                 BUG_ON(atomic_read(&eb->blocking_readers) == 0);
69                 read_lock(&eb->lock);
70                 atomic_inc(&eb->spinning_readers);
71                 if (atomic_dec_and_test(&eb->blocking_readers))
72                         wake_up(&eb->read_lock_wq);
73         }
74         return;
75 }
76
77 /*
78  * take a spinning read lock.  This will wait for any blocking
79  * writers
80  */
81 void btrfs_tree_read_lock(struct extent_buffer *eb)
82 {
83 again:
84         wait_event(eb->write_lock_wq, atomic_read(&eb->blocking_writers) == 0);
85         read_lock(&eb->lock);
86         if (atomic_read(&eb->blocking_writers)) {
87                 read_unlock(&eb->lock);
88                 wait_event(eb->write_lock_wq,
89                            atomic_read(&eb->blocking_writers) == 0);
90                 goto again;
91         }
92         atomic_inc(&eb->read_locks);
93         atomic_inc(&eb->spinning_readers);
94 }
95
96 /*
97  * returns 1 if we get the read lock and 0 if we don't
98  * this won't wait for blocking writers
99  */
100 int btrfs_try_tree_read_lock(struct extent_buffer *eb)
101 {
102         if (atomic_read(&eb->blocking_writers))
103                 return 0;
104
105         read_lock(&eb->lock);
106         if (atomic_read(&eb->blocking_writers)) {
107                 read_unlock(&eb->lock);
108                 return 0;
109         }
110         atomic_inc(&eb->read_locks);
111         atomic_inc(&eb->spinning_readers);
112         return 1;
113 }
114
115 /*
116  * returns 1 if we get the read lock and 0 if we don't
117  * this won't wait for blocking writers or readers
118  */
119 int btrfs_try_tree_write_lock(struct extent_buffer *eb)
120 {
121         if (atomic_read(&eb->blocking_writers) ||
122             atomic_read(&eb->blocking_readers))
123                 return 0;
124         write_lock(&eb->lock);
125         if (atomic_read(&eb->blocking_writers) ||
126             atomic_read(&eb->blocking_readers)) {
127                 write_unlock(&eb->lock);
128                 return 0;
129         }
130         atomic_inc(&eb->write_locks);
131         atomic_inc(&eb->spinning_writers);
132         return 1;
133 }
134
135 /*
136  * drop a spinning read lock
137  */
138 void btrfs_tree_read_unlock(struct extent_buffer *eb)
139 {
140         btrfs_assert_tree_read_locked(eb);
141         WARN_ON(atomic_read(&eb->spinning_readers) == 0);
142         atomic_dec(&eb->spinning_readers);
143         atomic_dec(&eb->read_locks);
144         read_unlock(&eb->lock);
145 }
146
147 /*
148  * drop a blocking read lock
149  */
150 void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb)
151 {
152         btrfs_assert_tree_read_locked(eb);
153         WARN_ON(atomic_read(&eb->blocking_readers) == 0);
154         if (atomic_dec_and_test(&eb->blocking_readers))
155                 wake_up(&eb->read_lock_wq);
156         atomic_dec(&eb->read_locks);
157 }
158
159 /*
160  * take a spinning write lock.  This will wait for both
161  * blocking readers or writers
162  */
163 int btrfs_tree_lock(struct extent_buffer *eb)
164 {
165 again:
166         wait_event(eb->read_lock_wq, atomic_read(&eb->blocking_readers) == 0);
167         wait_event(eb->write_lock_wq, atomic_read(&eb->blocking_writers) == 0);
168         write_lock(&eb->lock);
169         if (atomic_read(&eb->blocking_readers)) {
170                 write_unlock(&eb->lock);
171                 wait_event(eb->read_lock_wq,
172                            atomic_read(&eb->blocking_readers) == 0);
173                 goto again;
174         }
175         if (atomic_read(&eb->blocking_writers)) {
176                 write_unlock(&eb->lock);
177                 wait_event(eb->write_lock_wq,
178                            atomic_read(&eb->blocking_writers) == 0);
179                 goto again;
180         }
181         WARN_ON(atomic_read(&eb->spinning_writers));
182         atomic_inc(&eb->spinning_writers);
183         atomic_inc(&eb->write_locks);
184         return 0;
185 }
186
187 /*
188  * drop a spinning or a blocking write lock.
189  */
190 int btrfs_tree_unlock(struct extent_buffer *eb)
191 {
192         int blockers = atomic_read(&eb->blocking_writers);
193
194         BUG_ON(blockers > 1);
195
196         btrfs_assert_tree_locked(eb);
197         atomic_dec(&eb->write_locks);
198
199         if (blockers) {
200                 WARN_ON(atomic_read(&eb->spinning_writers));
201                 atomic_dec(&eb->blocking_writers);
202                 smp_wmb();
203                 wake_up(&eb->write_lock_wq);
204         } else {
205                 WARN_ON(atomic_read(&eb->spinning_writers) != 1);
206                 atomic_dec(&eb->spinning_writers);
207                 write_unlock(&eb->lock);
208         }
209         return 0;
210 }
211
212 void btrfs_assert_tree_locked(struct extent_buffer *eb)
213 {
214         BUG_ON(!atomic_read(&eb->write_locks));
215 }
216
217 void btrfs_assert_tree_read_locked(struct extent_buffer *eb)
218 {
219         BUG_ON(!atomic_read(&eb->read_locks));
220 }