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  * Remove an interest on a server.
 101  */
 102 void afs_put_cb_interest(struct afs_net *net, struct afs_cb_interest *cbi)
 103 {
 104         if (cbi && refcount_dec_and_test(&cbi->usage)) {
 105                 if (!list_empty(&cbi->cb_link)) {
 106                         write_lock(&cbi->server->cb_break_lock);
 107                         list_del_init(&cbi->cb_link);
 108                         write_unlock(&cbi->server->cb_break_lock);
 109                         afs_put_server(net, cbi->server);
 110                 }
 111                 kfree(cbi);
 112         }
 113 }
 114
 115 /*
 116  * allow the fileserver to request callback state (re-)initialisation
 117  */
 118 void afs_init_callback_state(struct afs_server *server)
 119 {
 120         if (!test_and_clear_bit(AFS_SERVER_FL_NEW, &server->flags))
 121                 server->cb_s_break++;
 122 }
 123
 124 /*
 125  * actually break a callback
 126  */
 127 void afs_break_callback(struct afs_vnode *vnode)
 128 {
 129         _enter("");
 130
 131         write_seqlock(&vnode->cb_lock);
 132
 133         clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
 134         if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
 135                 vnode->cb_break++;
 136                 afs_clear_permits(vnode);
 137
 138                 spin_lock(&vnode->lock);
 139
 140                 _debug("break callback");
 141
 142                 if (list_empty(&vnode->granted_locks) &&
 143                     !list_empty(&vnode->pending_locks))
 144                         afs_lock_may_be_available(vnode);
 145                 spin_unlock(&vnode->lock);
 146         }
 147
 148         write_sequnlock(&vnode->cb_lock);
 149 }
 150
 151 /*
 152  * allow the fileserver to explicitly break one callback
 153  * - happens when
 154  *   - the backing file is changed
 155  *   - a lock is released
 156  */
 157 static void afs_break_one_callback(struct afs_server *server,
 158                                    struct afs_fid *fid)
 159 {
 160         struct afs_cb_interest *cbi;
 161         struct afs_iget_data data;
 162         struct afs_vnode *vnode;
 163         struct inode *inode;
 164
 165         read_lock(&server->cb_break_lock);
 166
 167         /* Step through all interested superblocks.  There may be more than one
 168          * because of cell aliasing.
 169          */
 170         list_for_each_entry(cbi, &server->cb_interests, cb_link) {
 171                 if (cbi->vid != fid->vid)
 172                         continue;
 173
 174                 data.volume = NULL;
 175                 data.fid = *fid;
 176                 inode = ilookup5_nowait(cbi->sb, fid->vnode, afs_iget5_test, &data);
 177                 if (inode) {
 178                         vnode = AFS_FS_I(inode);
 179                         afs_break_callback(vnode);
 180                         iput(inode);
 181                 }
 182         }
 183
 184         read_unlock(&server->cb_break_lock);
 185 }
 186
 187 /*
 188  * allow the fileserver to break callback promises
 189  */
 190 void afs_break_callbacks(struct afs_server *server, size_t count,
 191                          struct afs_callback_break *callbacks)
 192 {
 193         _enter("%p,%zu,", server, count);
 194
 195         ASSERT(server != NULL);
 196         ASSERTCMP(count, <=, AFSCBMAX);
 197
 198         for (; count > 0; callbacks++, count--) {
 199                 _debug("- Fid { vl=%08x n=%u u=%u }  CB { v=%u x=%u t=%u }",
 200                        callbacks->fid.vid,
 201                        callbacks->fid.vnode,
 202                        callbacks->fid.unique,
 203                        callbacks->cb.version,
 204                        callbacks->cb.expiry,
 205                        callbacks->cb.type
 206                        );
 207                 afs_break_one_callback(server, &callbacks->fid);
 208         }
 209
 210         _leave("");
 211         return;
 212 }
 213
 214 /*
 215  * Clear the callback interests in a server list.
 216  */
 217 void afs_clear_callback_interests(struct afs_net *net, struct afs_server_list *slist)
 218 {
 219         int i;
 220
 221         for (i = 0; i < slist->nr_servers; i++) {
 222                 afs_put_cb_interest(net, slist->servers[i].cb_interest);
 223                 slist->servers[i].cb_interest = NULL;
 224         }
 225 }