fs/afs/callback.c

   1 /*
   2  * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved.
   3  *
   4  * This software may be freely redistributed under the terms of the
   5  * GNU General Public License.
   6  *
   7  * You should have received a copy of the GNU General Public License
   8  * along with this program; if not, write to the Free Software
   9  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  10  *
  11  * Authors: David Woodhouse <dwmw2@infradead.org>
  12  *          David Howells <dhowells@redhat.com>
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/circ_buf.h>
  20 #include <linux/sched.h>
  21 #include "internal.h"
  22
  23 /*
  24  * Allow the fileserver to request callback state (re-)initialisation.
  25  * Unfortunately, UUIDs are not guaranteed unique.
  26  */
  27 void afs_init_callback_state(struct afs_server *server)
  28 {
  29         rcu_read_lock();
  30         do {
  31                 server->cb_s_break++;
  32                 server = rcu_dereference(server->uuid_next);
  33         } while (0);
  34         rcu_read_unlock();
  35 }
  36
  37 /*
  38  * actually break a callback
  39  */
  40 void __afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason)
  41 {
  42         _enter("");
  43
  44         clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
  45         if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
  46                 vnode->cb_break++;
  47                 afs_clear_permits(vnode);
  48
  49                 if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB)
  50                         afs_lock_may_be_available(vnode);
  51
  52                 trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, true);
  53         } else {
  54                 trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, false);
  55         }
  56 }
  57
  58 void afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason)
  59 {
  60         write_seqlock(&vnode->cb_lock);
  61         __afs_break_callback(vnode, reason);
  62         write_sequnlock(&vnode->cb_lock);
  63 }
  64
  65 /*
  66  * Look up a volume by volume ID under RCU conditions.
  67  */
  68 static struct afs_volume *afs_lookup_volume_rcu(struct afs_cell *cell,
  69                                                 afs_volid_t vid)
  70 {
  71         struct afs_volume *volume = NULL;
  72         struct rb_node *p;
  73         int seq = 0;
  74
  75         do {
  76                 /* Unfortunately, rbtree walking doesn't give reliable results
  77                  * under just the RCU read lock, so we have to check for
  78                  * changes.
  79                  */
  80                 read_seqbegin_or_lock(&cell->volume_lock, &seq);
  81
  82                 p = rcu_dereference_raw(cell->volumes.rb_node);
  83                 while (p) {
  84                         volume = rb_entry(p, struct afs_volume, cell_node);
  85
  86                         if (volume->vid < vid)
  87                                 p = rcu_dereference_raw(p->rb_left);
  88                         else if (volume->vid > vid)
  89                                 p = rcu_dereference_raw(p->rb_right);
  90                         else
  91                                 break;
  92                         volume = NULL;
  93                 }
  94
  95         } while (need_seqretry(&cell->volume_lock, seq));
  96
  97         done_seqretry(&cell->volume_lock, seq);
  98         return volume;
  99 }
 100
 101 /*
 102  * allow the fileserver to explicitly break one callback
 103  * - happens when
 104  *   - the backing file is changed
 105  *   - a lock is released
 106  */
 107 static void afs_break_one_callback(struct afs_volume *volume,
 108                                    struct afs_fid *fid)
 109 {
 110         struct super_block *sb;
 111         struct afs_vnode *vnode;
 112         struct inode *inode;
 113
 114         if (fid->vnode == 0 && fid->unique == 0) {
 115                 /* The callback break applies to an entire volume. */
 116                 write_lock(&volume->cb_v_break_lock);
 117                 volume->cb_v_break++;
 118                 trace_afs_cb_break(fid, volume->cb_v_break,
 119                                    afs_cb_break_for_volume_callback, false);
 120                 write_unlock(&volume->cb_v_break_lock);
 121                 return;
 122         }
 123
 124         /* See if we can find a matching inode - even an I_NEW inode needs to
 125          * be marked as it can have its callback broken before we finish
 126          * setting up the local inode.
 127          */
 128         sb = rcu_dereference(volume->sb);
 129         if (!sb)
 130                 return;
 131
 132         inode = find_inode_rcu(sb, fid->vnode, afs_ilookup5_test_by_fid, fid);
 133         if (inode) {
 134                 vnode = AFS_FS_I(inode);
 135                 afs_break_callback(vnode, afs_cb_break_for_callback);
 136         } else {
 137                 trace_afs_cb_miss(fid, afs_cb_break_for_callback);
 138         }
 139 }
 140
 141 static void afs_break_some_callbacks(struct afs_server *server,
 142                                      struct afs_callback_break *cbb,
 143                                      size_t *_count)
 144 {
 145         struct afs_callback_break *residue = cbb;
 146         struct afs_volume *volume;
 147         afs_volid_t vid = cbb->fid.vid;
 148         size_t i;
 149
 150         volume = afs_lookup_volume_rcu(server->cell, vid);
 151
 152         /* TODO: Find all matching volumes if we couldn't match the server and
 153          * break them anyway.
 154          */
 155
 156         for (i = *_count; i > 0; cbb++, i--) {
 157                 if (cbb->fid.vid == vid) {
 158                         _debug("- Fid { vl=%08llx n=%llu u=%u }",
 159                                cbb->fid.vid,
 160                                cbb->fid.vnode,
 161                                cbb->fid.unique);
 162                         --*_count;
 163                         if (volume)
 164                                 afs_break_one_callback(volume, &cbb->fid);
 165                 } else {
 166                         *residue++ = *cbb;
 167                 }
 168         }
 169 }
 170
 171 /*
 172  * allow the fileserver to break callback promises
 173  */
 174 void afs_break_callbacks(struct afs_server *server, size_t count,
 175                          struct afs_callback_break *callbacks)
 176 {
 177         _enter("%p,%zu,", server, count);
 178
 179         ASSERT(server != NULL);
 180
 181         rcu_read_lock();
 182
 183         while (count > 0)
 184                 afs_break_some_callbacks(server, callbacks, &count);
 185
 186         rcu_read_unlock();
 187         return;
 188 }