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  * Set up an interest-in-callbacks record for a volume on a server and
  25  * register it with the server.
  26  * - Called with volume->server_sem held.
  27  */
  28 int afs_register_server_cb_interest(struct afs_vnode *vnode,
  29                                     struct afs_server_entry *entry)
  30 {
  31         struct afs_cb_interest *cbi = entry->cb_interest, *vcbi, *new, *x;
  32         struct afs_server *server = entry->server;
  33
  34 again:
  35         vcbi = vnode->cb_interest;
  36         if (vcbi) {
  37                 if (vcbi == cbi)
  38                         return 0;
  39
  40                 if (cbi && vcbi->server == cbi->server) {
  41                         write_seqlock(&vnode->cb_lock);
  42                         vnode->cb_interest = afs_get_cb_interest(cbi);
  43                         write_sequnlock(&vnode->cb_lock);
  44                         afs_put_cb_interest(afs_v2net(vnode), cbi);
  45                         return 0;
  46                 }
  47
  48                 if (!cbi && vcbi->server == server) {
  49                         afs_get_cb_interest(vcbi);
  50                         x = cmpxchg(&entry->cb_interest, cbi, vcbi);
  51                         if (x != cbi) {
  52                                 cbi = x;
  53                                 afs_put_cb_interest(afs_v2net(vnode), vcbi);
  54                                 goto again;
  55                         }
  56                         return 0;
  57                 }
  58         }
  59
  60         if (!cbi) {
  61                 new = kzalloc(sizeof(struct afs_cb_interest), GFP_KERNEL);
  62                 if (!new)
  63                         return -ENOMEM;
  64
  65                 refcount_set(&new->usage, 1);
  66                 new->sb = vnode->vfs_inode.i_sb;
  67                 new->vid = vnode->volume->vid;
  68                 new->server = afs_get_server(server);
  69                 INIT_LIST_HEAD(&new->cb_link);
  70
  71                 write_lock(&server->cb_break_lock);
  72                 list_add_tail(&new->cb_link, &server->cb_interests);
  73                 write_unlock(&server->cb_break_lock);
  74
  75                 x = cmpxchg(&entry->cb_interest, cbi, new);
  76                 if (x == cbi) {
  77                         cbi = new;
  78                 } else {
  79                         cbi = x;
  80                         afs_put_cb_interest(afs_v2net(vnode), new);
  81                 }
  82         }
  83
  84         ASSERT(cbi);
  85
  86         /* Change the server the vnode is using.  This entails scrubbing any
  87          * interest the vnode had in the previous server it was using.
  88          */
  89         write_seqlock(&vnode->cb_lock);
  90
  91         vnode->cb_interest = afs_get_cb_interest(cbi);
  92         vnode->cb_s_break = cbi->server->cb_s_break;
  93         clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
  94
  95         write_sequnlock(&vnode->cb_lock);
  96         return 0;
  97 }
  98
  99 /*
 100  * Set a vnode's interest on a server.
 101  */
 102 void afs_set_cb_interest(struct afs_vnode *vnode, struct afs_cb_interest *cbi)
 103 {
 104         struct afs_cb_interest *old_cbi = NULL;
 105
 106         if (vnode->cb_interest == cbi)
 107                 return;
 108
 109         write_seqlock(&vnode->cb_lock);
 110         if (vnode->cb_interest != cbi) {
 111                 afs_get_cb_interest(cbi);
 112                 old_cbi = vnode->cb_interest;
 113                 vnode->cb_interest = cbi;
 114         }
 115         write_sequnlock(&vnode->cb_lock);
 116         afs_put_cb_interest(afs_v2net(vnode), cbi);
 117 }
 118
 119 /*
 120  * Remove an interest on a server.
 121  */
 122 void afs_put_cb_interest(struct afs_net *net, struct afs_cb_interest *cbi)
 123 {
 124         if (cbi && refcount_dec_and_test(&cbi->usage)) {
 125                 if (!list_empty(&cbi->cb_link)) {
 126                         write_lock(&cbi->server->cb_break_lock);
 127                         list_del_init(&cbi->cb_link);
 128                         write_unlock(&cbi->server->cb_break_lock);
 129                         afs_put_server(net, cbi->server);
 130                 }
 131                 kfree(cbi);
 132         }
 133 }
 134
 135 /*
 136  * allow the fileserver to request callback state (re-)initialisation
 137  */
 138 void afs_init_callback_state(struct afs_server *server)
 139 {
 140         if (!test_and_clear_bit(AFS_SERVER_FL_NEW, &server->flags))
 141                 server->cb_s_break++;
 142 }
 143
 144 /*
 145  * actually break a callback
 146  */
 147 void afs_break_callback(struct afs_vnode *vnode)
 148 {
 149         _enter("");
 150
 151         write_seqlock(&vnode->cb_lock);
 152
 153         if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
 154                 vnode->cb_break++;
 155                 afs_clear_permits(vnode);
 156
 157                 spin_lock(&vnode->lock);
 158
 159                 _debug("break callback");
 160
 161                 if (list_empty(&vnode->granted_locks) &&
 162                     !list_empty(&vnode->pending_locks))
 163                         afs_lock_may_be_available(vnode);
 164                 spin_unlock(&vnode->lock);
 165         }
 166
 167         write_sequnlock(&vnode->cb_lock);
 168 }
 169
 170 /*
 171  * allow the fileserver to explicitly break one callback
 172  * - happens when
 173  *   - the backing file is changed
 174  *   - a lock is released
 175  */
 176 static void afs_break_one_callback(struct afs_server *server,
 177                                    struct afs_fid *fid)
 178 {
 179         struct afs_cb_interest *cbi;
 180         struct afs_iget_data data;
 181         struct afs_vnode *vnode;
 182         struct inode *inode;
 183
 184         read_lock(&server->cb_break_lock);
 185
 186         /* Step through all interested superblocks.  There may be more than one
 187          * because of cell aliasing.
 188          */
 189         list_for_each_entry(cbi, &server->cb_interests, cb_link) {
 190                 if (cbi->vid != fid->vid)
 191                         continue;
 192
 193                 data.volume = NULL;
 194                 data.fid = *fid;
 195                 inode = ilookup5_nowait(cbi->sb, fid->vnode, afs_iget5_test, &data);
 196                 if (inode) {
 197                         vnode = AFS_FS_I(inode);
 198                         afs_break_callback(vnode);
 199                         iput(inode);
 200                 }
 201         }
 202
 203         read_unlock(&server->cb_break_lock);
 204 }
 205
 206 /*
 207  * allow the fileserver to break callback promises
 208  */
 209 void afs_break_callbacks(struct afs_server *server, size_t count,
 210                          struct afs_callback callbacks[])
 211 {
 212         _enter("%p,%zu,", server, count);
 213
 214         ASSERT(server != NULL);
 215         ASSERTCMP(count, <=, AFSCBMAX);
 216
 217         for (; count > 0; callbacks++, count--) {
 218                 _debug("- Fid { vl=%08x n=%u u=%u }  CB { v=%u x=%u t=%u }",
 219                        callbacks->fid.vid,
 220                        callbacks->fid.vnode,
 221                        callbacks->fid.unique,
 222                        callbacks->version,
 223                        callbacks->expiry,
 224                        callbacks->type
 225                        );
 226                 afs_break_one_callback(server, &callbacks->fid);
 227         }
 228
 229         _leave("");
 230         return;
 231 }
 232
 233 /*
 234  * Clear the callback interests in a server list.
 235  */
 236 void afs_clear_callback_interests(struct afs_net *net, struct afs_server_list *slist)
 237 {
 238         int i;
 239
 240         for (i = 0; i < slist->nr_servers; i++) {
 241                 afs_put_cb_interest(net, slist->servers[i].cb_interest);
 242                 slist->servers[i].cb_interest = NULL;
 243         }
 244 }