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 }