git.oblomov.eu Git - linux-2.6/blob - 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@cambridge.redhat.com>
  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 "internal.h"
  21
  22 unsigned afs_vnode_update_timeout = 10;
  23
  24 #define afs_breakring_space(server) \
  25         CIRC_SPACE((server)->cb_break_head, (server)->cb_break_tail,    \
  26                    ARRAY_SIZE((server)->cb_break))
  27
  28 //static void afs_callback_updater(struct work_struct *);
  29
  30 static struct workqueue_struct *afs_callback_update_worker;
  31
  32 /*
  33  * allow the fileserver to request callback state (re-)initialisation
  34  */
  35 void afs_init_callback_state(struct afs_server *server)
  36 {
  37         struct afs_vnode *vnode;
  38
  39         _enter("{%p}", server);
  40
  41         spin_lock(&server->cb_lock);
  42
  43         /* kill all the promises on record from this server */
  44         while (!RB_EMPTY_ROOT(&server->cb_promises)) {
  45                 vnode = rb_entry(server->cb_promises.rb_node,
  46                                  struct afs_vnode, cb_promise);
  47                 _debug("UNPROMISE { vid=%x vn=%u uq=%u}",
  48                        vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
  49                 rb_erase(&vnode->cb_promise, &server->cb_promises);
  50                 vnode->cb_promised = false;
  51         }
  52
  53         spin_unlock(&server->cb_lock);
  54         _leave("");
  55 }
  56
  57 /*
  58  * handle the data invalidation side of a callback being broken
  59  */
  60 void afs_broken_callback_work(struct work_struct *work)
  61 {
  62         struct afs_vnode *vnode =
  63                 container_of(work, struct afs_vnode, cb_broken_work);
  64
  65         _enter("");
  66
  67         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
  68                 return;
  69
  70         /* we're only interested in dealing with a broken callback on *this*
  71          * vnode and only if no-one else has dealt with it yet */
  72         if (!mutex_trylock(&vnode->validate_lock))
  73                 return; /* someone else is dealing with it */
  74
  75         if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
  76                 if (S_ISDIR(vnode->vfs_inode.i_mode))
  77                         afs_clear_permits(vnode);
  78
  79                 if (afs_vnode_fetch_status(vnode, NULL, NULL) < 0)
  80                         goto out;
  81
  82                 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
  83                         goto out;
  84
  85                 /* if the vnode's data version number changed then its contents
  86                  * are different */
  87                 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
  88                         _debug("zap data {%x:%u}",
  89                                vnode->fid.vid, vnode->fid.vnode);
  90                         invalidate_remote_inode(&vnode->vfs_inode);
  91                 }
  92         }
  93
  94 out:
  95         mutex_unlock(&vnode->validate_lock);
  96
  97         /* avoid the potential race whereby the mutex_trylock() in this
  98          * function happens again between the clear_bit() and the
  99          * mutex_unlock() */
 100         if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
 101                 _debug("requeue");
 102                 queue_work(afs_callback_update_worker, &vnode->cb_broken_work);
 103         }
 104         _leave("");
 105 }
 106
 107 /*
 108  * actually break a callback
 109  */
 110 static void afs_break_callback(struct afs_server *server,
 111                                struct afs_vnode *vnode)
 112 {
 113         _enter("");
 114
 115         set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
 116
 117         if (vnode->cb_promised) {
 118                 spin_lock(&vnode->lock);
 119
 120                 _debug("break callback");
 121
 122                 spin_lock(&server->cb_lock);
 123                 if (vnode->cb_promised) {
 124                         rb_erase(&vnode->cb_promise, &server->cb_promises);
 125                         vnode->cb_promised = false;
 126                 }
 127                 spin_unlock(&server->cb_lock);
 128
 129                 queue_work(afs_callback_update_worker, &vnode->cb_broken_work);
 130                 spin_unlock(&vnode->lock);
 131         }
 132 }
 133
 134 /*
 135  * allow the fileserver to explicitly break one callback
 136  * - happens when
 137  *   - the backing file is changed
 138  *   - a lock is released
 139  */
 140 static void afs_break_one_callback(struct afs_server *server,
 141                                    struct afs_fid *fid)
 142 {
 143         struct afs_vnode *vnode;
 144         struct rb_node *p;
 145
 146         _debug("find");
 147         spin_lock(&server->fs_lock);
 148         p = server->fs_vnodes.rb_node;
 149         while (p) {
 150                 vnode = rb_entry(p, struct afs_vnode, server_rb);
 151                 if (fid->vid < vnode->fid.vid)
 152                         p = p->rb_left;
 153                 else if (fid->vid > vnode->fid.vid)
 154                         p = p->rb_right;
 155                 else if (fid->vnode < vnode->fid.vnode)
 156                         p = p->rb_left;
 157                 else if (fid->vnode > vnode->fid.vnode)
 158                         p = p->rb_right;
 159                 else if (fid->unique < vnode->fid.unique)
 160                         p = p->rb_left;
 161                 else if (fid->unique > vnode->fid.unique)
 162                         p = p->rb_right;
 163                 else
 164                         goto found;
 165         }
 166
 167         /* not found so we just ignore it (it may have moved to another
 168          * server) */
 169 not_available:
 170         _debug("not avail");
 171         spin_unlock(&server->fs_lock);
 172         _leave("");
 173         return;
 174
 175 found:
 176         _debug("found");
 177         ASSERTCMP(server, ==, vnode->server);
 178
 179         if (!igrab(AFS_VNODE_TO_I(vnode)))
 180                 goto not_available;
 181         spin_unlock(&server->fs_lock);
 182
 183         afs_break_callback(server, vnode);
 184         iput(&vnode->vfs_inode);
 185         _leave("");
 186 }
 187
 188 /*
 189  * allow the fileserver to break callback promises
 190  */
 191 void afs_break_callbacks(struct afs_server *server, size_t count,
 192                          struct afs_callback callbacks[])
 193 {
 194         _enter("%p,%zu,", server, count);
 195
 196         ASSERT(server != NULL);
 197         ASSERTCMP(count, <=, AFSCBMAX);
 198
 199         for (; count > 0; callbacks++, count--) {
 200                 _debug("- Fid { vl=%08x n=%u u=%u }  CB { v=%u x=%u t=%u }",
 201                        callbacks->fid.vid,
 202                        callbacks->fid.vnode,
 203                        callbacks->fid.unique,
 204                        callbacks->version,
 205                        callbacks->expiry,
 206                        callbacks->type
 207                        );
 208                 afs_break_one_callback(server, &callbacks->fid);
 209         }
 210
 211         _leave("");
 212         return;
 213 }
 214
 215 /*
 216  * record the callback for breaking
 217  * - the caller must hold server->cb_lock
 218  */
 219 static void afs_do_give_up_callback(struct afs_server *server,
 220                                     struct afs_vnode *vnode)
 221 {
 222         struct afs_callback *cb;
 223
 224         _enter("%p,%p", server, vnode);
 225
 226         cb = &server->cb_break[server->cb_break_head];
 227         cb->fid         = vnode->fid;
 228         cb->version     = vnode->cb_version;
 229         cb->expiry      = vnode->cb_expiry;
 230         cb->type        = vnode->cb_type;
 231         smp_wmb();
 232         server->cb_break_head =
 233                 (server->cb_break_head + 1) &
 234                 (ARRAY_SIZE(server->cb_break) - 1);
 235
 236         /* defer the breaking of callbacks to try and collect as many as
 237          * possible to ship in one operation */
 238         switch (atomic_inc_return(&server->cb_break_n)) {
 239         case 1 ... AFSCBMAX - 1:
 240                 queue_delayed_work(afs_callback_update_worker,
 241                                    &server->cb_break_work, HZ * 2);
 242                 break;
 243         case AFSCBMAX:
 244                 afs_flush_callback_breaks(server);
 245                 break;
 246         default:
 247                 break;
 248         }
 249
 250         ASSERT(server->cb_promises.rb_node != NULL);
 251         rb_erase(&vnode->cb_promise, &server->cb_promises);
 252         vnode->cb_promised = false;
 253         _leave("");
 254 }
 255
 256 /*
 257  * discard the callback on a deleted item
 258  */
 259 void afs_discard_callback_on_delete(struct afs_vnode *vnode)
 260 {
 261         struct afs_server *server = vnode->server;
 262
 263         _enter("%d", vnode->cb_promised);
 264
 265         if (!vnode->cb_promised) {
 266                 _leave(" [not promised]");
 267                 return;
 268         }
 269
 270         ASSERT(server != NULL);
 271
 272         spin_lock(&server->cb_lock);
 273         if (vnode->cb_promised) {
 274                 ASSERT(server->cb_promises.rb_node != NULL);
 275                 rb_erase(&vnode->cb_promise, &server->cb_promises);
 276                 vnode->cb_promised = false;
 277         }
 278         spin_unlock(&server->cb_lock);
 279         _leave("");
 280 }
 281
 282 /*
 283  * give up the callback registered for a vnode on the file server when the
 284  * inode is being cleared
 285  */
 286 void afs_give_up_callback(struct afs_vnode *vnode)
 287 {
 288         struct afs_server *server = vnode->server;
 289
 290         DECLARE_WAITQUEUE(myself, current);
 291
 292         _enter("%d", vnode->cb_promised);
 293
 294         _debug("GIVE UP INODE %p", &vnode->vfs_inode);
 295
 296         if (!vnode->cb_promised) {
 297                 _leave(" [not promised]");
 298                 return;
 299         }
 300
 301         ASSERT(server != NULL);
 302
 303         spin_lock(&server->cb_lock);
 304         if (vnode->cb_promised && afs_breakring_space(server) == 0) {
 305                 add_wait_queue(&server->cb_break_waitq, &myself);
 306                 for (;;) {
 307                         set_current_state(TASK_UNINTERRUPTIBLE);
 308                         if (!vnode->cb_promised ||
 309                             afs_breakring_space(server) != 0)
 310                                 break;
 311                         spin_unlock(&server->cb_lock);
 312                         schedule();
 313                         spin_lock(&server->cb_lock);
 314                 }
 315                 remove_wait_queue(&server->cb_break_waitq, &myself);
 316                 __set_current_state(TASK_RUNNING);
 317         }
 318
 319         /* of course, it's always possible for the server to break this vnode's
 320          * callback first... */
 321         if (vnode->cb_promised)
 322                 afs_do_give_up_callback(server, vnode);
 323
 324         spin_unlock(&server->cb_lock);
 325         _leave("");
 326 }
 327
 328 /*
 329  * dispatch a deferred give up callbacks operation
 330  */
 331 void afs_dispatch_give_up_callbacks(struct work_struct *work)
 332 {
 333         struct afs_server *server =
 334                 container_of(work, struct afs_server, cb_break_work.work);
 335
 336         _enter("");
 337
 338         /* tell the fileserver to discard the callback promises it has
 339          * - in the event of ENOMEM or some other error, we just forget that we
 340          *   had callbacks entirely, and the server will call us later to break
 341          *   them
 342          */
 343         afs_fs_give_up_callbacks(server, &afs_async_call);
 344 }
 345
 346 /*
 347  * flush the outstanding callback breaks on a server
 348  */
 349 void afs_flush_callback_breaks(struct afs_server *server)
 350 {
 351         cancel_delayed_work(&server->cb_break_work);
 352         queue_delayed_work(afs_callback_update_worker,
 353                            &server->cb_break_work, 0);
 354 }
 355
 356 #if 0
 357 /*
 358  * update a bunch of callbacks
 359  */
 360 static void afs_callback_updater(struct work_struct *work)
 361 {
 362         struct afs_server *server;
 363         struct afs_vnode *vnode, *xvnode;
 364         time_t now;
 365         long timeout;
 366         int ret;
 367
 368         server = container_of(work, struct afs_server, updater);
 369
 370         _enter("");
 371
 372         now = get_seconds();
 373
 374         /* find the first vnode to update */
 375         spin_lock(&server->cb_lock);
 376         for (;;) {
 377                 if (RB_EMPTY_ROOT(&server->cb_promises)) {
 378                         spin_unlock(&server->cb_lock);
 379                         _leave(" [nothing]");
 380                         return;
 381                 }
 382
 383                 vnode = rb_entry(rb_first(&server->cb_promises),
 384                                  struct afs_vnode, cb_promise);
 385                 if (atomic_read(&vnode->usage) > 0)
 386                         break;
 387                 rb_erase(&vnode->cb_promise, &server->cb_promises);
 388                 vnode->cb_promised = false;
 389         }
 390
 391         timeout = vnode->update_at - now;
 392         if (timeout > 0) {
 393                 queue_delayed_work(afs_vnode_update_worker,
 394                                    &afs_vnode_update, timeout * HZ);
 395                 spin_unlock(&server->cb_lock);
 396                 _leave(" [nothing]");
 397                 return;
 398         }
 399
 400         list_del_init(&vnode->update);
 401         atomic_inc(&vnode->usage);
 402         spin_unlock(&server->cb_lock);
 403
 404         /* we can now perform the update */
 405         _debug("update %s", vnode->vldb.name);
 406         vnode->state = AFS_VL_UPDATING;
 407         vnode->upd_rej_cnt = 0;
 408         vnode->upd_busy_cnt = 0;
 409
 410         ret = afs_vnode_update_record(vl, &vldb);
 411         switch (ret) {
 412         case 0:
 413                 afs_vnode_apply_update(vl, &vldb);
 414                 vnode->state = AFS_VL_UPDATING;
 415                 break;
 416         case -ENOMEDIUM:
 417                 vnode->state = AFS_VL_VOLUME_DELETED;
 418                 break;
 419         default:
 420                 vnode->state = AFS_VL_UNCERTAIN;
 421                 break;
 422         }
 423
 424         /* and then reschedule */
 425         _debug("reschedule");
 426         vnode->update_at = get_seconds() + afs_vnode_update_timeout;
 427
 428         spin_lock(&server->cb_lock);
 429
 430         if (!list_empty(&server->cb_promises)) {
 431                 /* next update in 10 minutes, but wait at least 1 second more
 432                  * than the newest record already queued so that we don't spam
 433                  * the VL server suddenly with lots of requests
 434                  */
 435                 xvnode = list_entry(server->cb_promises.prev,
 436                                     struct afs_vnode, update);
 437                 if (vnode->update_at <= xvnode->update_at)
 438                         vnode->update_at = xvnode->update_at + 1;
 439                 xvnode = list_entry(server->cb_promises.next,
 440                                     struct afs_vnode, update);
 441                 timeout = xvnode->update_at - now;
 442                 if (timeout < 0)
 443                         timeout = 0;
 444         } else {
 445                 timeout = afs_vnode_update_timeout;
 446         }
 447
 448         list_add_tail(&vnode->update, &server->cb_promises);
 449
 450         _debug("timeout %ld", timeout);
 451         queue_delayed_work(afs_vnode_update_worker,
 452                            &afs_vnode_update, timeout * HZ);
 453         spin_unlock(&server->cb_lock);
 454         afs_put_vnode(vl);
 455 }
 456 #endif
 457
 458 /*
 459  * initialise the callback update process
 460  */
 461 int __init afs_callback_update_init(void)
 462 {
 463         afs_callback_update_worker =
 464                 create_singlethread_workqueue("kafs_callbackd");
 465         return afs_callback_update_worker ? 0 : -ENOMEM;
 466 }
 467
 468 /*
 469  * shut down the callback update process
 470  */
 471 void afs_callback_update_kill(void)
 472 {
 473         destroy_workqueue(afs_callback_update_worker);
 474 }