2 * Copyright (C) 2008 Oracle. All rights reserved.
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.
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.
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.
18 #include <linux/sched.h>
19 #include <linux/gfp.h>
20 #include <linux/pagemap.h>
21 #include <linux/spinlock.h>
22 #include <linux/page-flags.h>
25 #include "extent_io.h"
28 static inline void spin_nested(struct extent_buffer
*eb
)
34 * Setting a lock to blocking will drop the spinlock and set the
35 * flag that forces other procs who want the lock to wait. After
36 * this you can safely schedule with the lock held.
38 void btrfs_set_lock_blocking(struct extent_buffer
*eb
)
40 if (!test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
)) {
41 set_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
);
42 spin_unlock(&eb
->lock
);
44 /* exit with the spin lock released and the bit set */
48 * clearing the blocking flag will take the spinlock again.
49 * After this you can't safely schedule
51 void btrfs_clear_lock_blocking(struct extent_buffer
*eb
)
53 if (test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
)) {
55 clear_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
);
56 smp_mb__after_clear_bit();
58 /* exit with the spin lock held */
62 * unfortunately, many of the places that currently set a lock to blocking
63 * don't end up blocking for very long, and often they don't block
64 * at all. For a dbench 50 run, if we don't spin on the blocking bit
65 * at all, the context switch rate can jump up to 400,000/sec or more.
67 * So, we're still stuck with this crummy spin on the blocking bit,
68 * at least until the most common causes of the short blocks
71 static int btrfs_spin_on_block(struct extent_buffer
*eb
)
75 for (i
= 0; i
< 512; i
++) {
76 if (!test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
))
86 * This is somewhat different from trylock. It will take the
87 * spinlock but if it finds the lock is set to blocking, it will
88 * return without the lock held.
90 * returns 1 if it was able to take the lock and zero otherwise
92 * After this call, scheduling is not safe without first calling
93 * btrfs_set_lock_blocking()
95 int btrfs_try_spin_lock(struct extent_buffer
*eb
)
99 if (btrfs_spin_on_block(eb
)) {
101 if (!test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
))
103 spin_unlock(&eb
->lock
);
105 /* spin for a bit on the BLOCKING flag */
106 for (i
= 0; i
< 2; i
++) {
108 if (!btrfs_spin_on_block(eb
))
112 if (!test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
))
114 spin_unlock(&eb
->lock
);
120 * the autoremove wake function will return 0 if it tried to wake up
121 * a process that was already awake, which means that process won't
122 * count as an exclusive wakeup. The waitq code will continue waking
123 * procs until it finds one that was actually sleeping.
125 * For btrfs, this isn't quite what we want. We want a single proc
126 * to be notified that the lock is ready for taking. If that proc
127 * already happen to be awake, great, it will loop around and try for
130 * So, btrfs_wake_function always returns 1, even when the proc that we
131 * tried to wake up was already awake.
133 static int btrfs_wake_function(wait_queue_t
*wait
, unsigned mode
,
136 autoremove_wake_function(wait
, mode
, sync
, key
);
141 * returns with the extent buffer spinlocked.
143 * This will spin and/or wait as required to take the lock, and then
144 * return with the spinlock held.
146 * After this call, scheduling is not safe without first calling
147 * btrfs_set_lock_blocking()
149 int btrfs_tree_lock(struct extent_buffer
*eb
)
152 wait
.func
= btrfs_wake_function
;
154 if (!btrfs_spin_on_block(eb
))
160 /* nobody is blocking, exit with the spinlock held */
161 if (!test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
))
165 * we have the spinlock, but the real owner is blocking.
168 spin_unlock(&eb
->lock
);
171 * spin for a bit, and if the blocking flag goes away,
175 if (btrfs_spin_on_block(eb
))
178 prepare_to_wait_exclusive(&eb
->lock_wq
, &wait
,
179 TASK_UNINTERRUPTIBLE
);
181 if (test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
))
184 finish_wait(&eb
->lock_wq
, &wait
);
190 * Very quick trylock, this does not spin or schedule. It returns
191 * 1 with the spinlock held if it was able to take the lock, or it
192 * returns zero if it was unable to take the lock.
194 * After this call, scheduling is not safe without first calling
195 * btrfs_set_lock_blocking()
197 int btrfs_try_tree_lock(struct extent_buffer
*eb
)
199 if (spin_trylock(&eb
->lock
)) {
200 if (test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
)) {
202 * we've got the spinlock, but the real owner is
203 * blocking. Drop the spinlock and return failure
205 spin_unlock(&eb
->lock
);
210 /* someone else has the spinlock giveup */
214 int btrfs_tree_unlock(struct extent_buffer
*eb
)
217 * if we were a blocking owner, we don't have the spinlock held
218 * just clear the bit and look for waiters
220 if (test_and_clear_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
))
221 smp_mb__after_clear_bit();
223 spin_unlock(&eb
->lock
);
225 if (waitqueue_active(&eb
->lock_wq
))
226 wake_up(&eb
->lock_wq
);
230 void btrfs_assert_tree_locked(struct extent_buffer
*eb
)
232 if (!test_bit(EXTENT_BUFFER_BLOCKING
, &eb
->bflags
))
233 assert_spin_locked(&eb
->lock
);
This page took 0.03648 seconds and 6 git commands to generate.