fs/afs/vnode.c

   1 /* AFS vnode management
   2  *
   3  * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/slab.h>
  16 #include <linux/fs.h>
  17 #include "internal.h"
  18
  19 #if 0
  20 static noinline bool dump_tree_aux(struct rb_node *node, struct rb_node *parent,
  21                                    int depth, char lr)
  22 {
  23         struct afs_vnode *vnode;
  24         bool bad = false;
  25
  26         if (!node)
  27                 return false;
  28
  29         if (node->rb_left)
  30                 bad = dump_tree_aux(node->rb_left, node, depth + 2, '/');
  31
  32         vnode = rb_entry(node, struct afs_vnode, cb_promise);
  33         kdebug("%c %*.*s%c%p {%d}",
  34                rb_is_red(node) ? 'R' : 'B',
  35                depth, depth, "", lr,
  36                vnode, vnode->cb_expires_at);
  37         if (rb_parent(node) != parent) {
  38                 printk("BAD: %p != %p\n", rb_parent(node), parent);
  39                 bad = true;
  40         }
  41
  42         if (node->rb_right)
  43                 bad |= dump_tree_aux(node->rb_right, node, depth + 2, '\\');
  44
  45         return bad;
  46 }
  47
  48 static noinline void dump_tree(const char *name, struct afs_server *server)
  49 {
  50         kenter("%s", name);
  51         if (dump_tree_aux(server->cb_promises.rb_node, NULL, 0, '-'))
  52                 BUG();
  53 }
  54 #endif
  55
  56 /*
  57  * insert a vnode into the backing server's vnode tree
  58  */
  59 static void afs_install_vnode(struct afs_vnode *vnode,
  60                               struct afs_server *server)
  61 {
  62         struct afs_server *old_server = vnode->server;
  63         struct afs_vnode *xvnode;
  64         struct rb_node *parent, **p;
  65
  66         _enter("%p,%p", vnode, server);
  67
  68         if (old_server) {
  69                 spin_lock(&old_server->fs_lock);
  70                 rb_erase(&vnode->server_rb, &old_server->fs_vnodes);
  71                 spin_unlock(&old_server->fs_lock);
  72         }
  73
  74         afs_get_server(server);
  75         vnode->server = server;
  76         afs_put_server(old_server);
  77
  78         /* insert into the server's vnode tree in FID order */
  79         spin_lock(&server->fs_lock);
  80
  81         parent = NULL;
  82         p = &server->fs_vnodes.rb_node;
  83         while (*p) {
  84                 parent = *p;
  85                 xvnode = rb_entry(parent, struct afs_vnode, server_rb);
  86                 if (vnode->fid.vid < xvnode->fid.vid)
  87                         p = &(*p)->rb_left;
  88                 else if (vnode->fid.vid > xvnode->fid.vid)
  89                         p = &(*p)->rb_right;
  90                 else if (vnode->fid.vnode < xvnode->fid.vnode)
  91                         p = &(*p)->rb_left;
  92                 else if (vnode->fid.vnode > xvnode->fid.vnode)
  93                         p = &(*p)->rb_right;
  94                 else if (vnode->fid.unique < xvnode->fid.unique)
  95                         p = &(*p)->rb_left;
  96                 else if (vnode->fid.unique > xvnode->fid.unique)
  97                         p = &(*p)->rb_right;
  98                 else
  99                         BUG(); /* can't happen unless afs_iget() malfunctions */
 100         }
 101
 102         rb_link_node(&vnode->server_rb, parent, p);
 103         rb_insert_color(&vnode->server_rb, &server->fs_vnodes);
 104
 105         spin_unlock(&server->fs_lock);
 106         _leave("");
 107 }
 108
 109 /*
 110  * insert a vnode into the promising server's update/expiration tree
 111  * - caller must hold vnode->lock
 112  */
 113 static void afs_vnode_note_promise(struct afs_vnode *vnode,
 114                                    struct afs_server *server)
 115 {
 116         struct afs_server *old_server;
 117         struct afs_vnode *xvnode;
 118         struct rb_node *parent, **p;
 119
 120         _enter("%p,%p", vnode, server);
 121
 122         ASSERT(server != NULL);
 123
 124         old_server = vnode->server;
 125         if (vnode->cb_promised) {
 126                 if (server == old_server &&
 127                     vnode->cb_expires == vnode->cb_expires_at) {
 128                         _leave(" [no change]");
 129                         return;
 130                 }
 131
 132                 spin_lock(&old_server->cb_lock);
 133                 if (vnode->cb_promised) {
 134                         _debug("delete");
 135                         rb_erase(&vnode->cb_promise, &old_server->cb_promises);
 136                         vnode->cb_promised = false;
 137                 }
 138                 spin_unlock(&old_server->cb_lock);
 139         }
 140
 141         if (vnode->server != server)
 142                 afs_install_vnode(vnode, server);
 143
 144         vnode->cb_expires_at = vnode->cb_expires;
 145         _debug("PROMISE on %p {%lu}",
 146                vnode, (unsigned long) vnode->cb_expires_at);
 147
 148         /* abuse an RB-tree to hold the expiration order (we may have multiple
 149          * items with the same expiration time) */
 150         spin_lock(&server->cb_lock);
 151
 152         parent = NULL;
 153         p = &server->cb_promises.rb_node;
 154         while (*p) {
 155                 parent = *p;
 156                 xvnode = rb_entry(parent, struct afs_vnode, cb_promise);
 157                 if (vnode->cb_expires_at < xvnode->cb_expires_at)
 158                         p = &(*p)->rb_left;
 159                 else
 160                         p = &(*p)->rb_right;
 161         }
 162
 163         rb_link_node(&vnode->cb_promise, parent, p);
 164         rb_insert_color(&vnode->cb_promise, &server->cb_promises);
 165         vnode->cb_promised = true;
 166
 167         spin_unlock(&server->cb_lock);
 168         _leave("");
 169 }
 170
 171 /*
 172  * handle remote file deletion by discarding the callback promise
 173  */
 174 static void afs_vnode_deleted_remotely(struct afs_vnode *vnode)
 175 {
 176         struct afs_server *server;
 177
 178         set_bit(AFS_VNODE_DELETED, &vnode->flags);
 179
 180         server = vnode->server;
 181         if (vnode->cb_promised) {
 182                 spin_lock(&server->cb_lock);
 183                 if (vnode->cb_promised) {
 184                         rb_erase(&vnode->cb_promise, &server->cb_promises);
 185                         vnode->cb_promised = false;
 186                 }
 187                 spin_unlock(&server->cb_lock);
 188         }
 189
 190         afs_put_server(server);
 191 }
 192
 193 /*
 194  * finish off updating the recorded status of a file
 195  * - starts callback expiry timer
 196  * - adds to server's callback list
 197  */
 198 static void afs_vnode_finalise_status_update(struct afs_vnode *vnode,
 199                                              struct afs_server *server,
 200                                              int ret)
 201 {
 202         struct afs_server *oldserver = NULL;
 203
 204         _enter("%p,%p,%d", vnode, server, ret);
 205
 206         spin_lock(&vnode->lock);
 207
 208         clear_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
 209
 210         switch (ret) {
 211         case 0:
 212                 afs_vnode_note_promise(vnode, server);
 213                 break;
 214         case -ENOENT:
 215                 /* the file was deleted on the server */
 216                 _debug("got NOENT from server - marking file deleted");
 217                 afs_vnode_deleted_remotely(vnode);
 218                 break;
 219         default:
 220                 break;
 221         }
 222
 223         vnode->update_cnt--;
 224
 225         spin_unlock(&vnode->lock);
 226
 227         wake_up_all(&vnode->update_waitq);
 228
 229         afs_put_server(oldserver);
 230
 231         _leave("");
 232 }
 233
 234 /*
 235  * fetch file status from the volume
 236  * - don't issue a fetch if:
 237  *   - the changed bit is not set and there's a valid callback
 238  *   - there are any outstanding ops that will fetch the status
 239  * - TODO implement local caching
 240  */
 241 int afs_vnode_fetch_status(struct afs_vnode *vnode)
 242 {
 243         struct afs_server *server;
 244         int ret;
 245
 246         DECLARE_WAITQUEUE(myself, current);
 247
 248         _enter("%s,{%u,%u,%u}",
 249                vnode->volume->vlocation->vldb.name,
 250                vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
 251
 252         if (!test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags) &&
 253             vnode->cb_promised) {
 254                 _leave(" [unchanged]");
 255                 return 0;
 256         }
 257
 258         if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
 259                 _leave(" [deleted]");
 260                 return -ENOENT;
 261         }
 262
 263         spin_lock(&vnode->lock);
 264
 265         if (!test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags) &&
 266             vnode->cb_promised) {
 267                 spin_unlock(&vnode->lock);
 268                 _leave(" [unchanged]");
 269                 return 0;
 270         }
 271
 272         if (vnode->update_cnt > 0) {
 273                 /* someone else started a fetch */
 274                 set_current_state(TASK_UNINTERRUPTIBLE);
 275                 ASSERT(myself.func != NULL);
 276                 add_wait_queue(&vnode->update_waitq, &myself);
 277
 278                 /* wait for the status to be updated */
 279                 for (;;) {
 280                         if (!test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags))
 281                                 break;
 282                         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
 283                                 break;
 284
 285                         /* check to see if it got updated and invalidated all
 286                          * before we saw it */
 287                         if (vnode->update_cnt == 0) {
 288                                 remove_wait_queue(&vnode->update_waitq,
 289                                                   &myself);
 290                                 set_current_state(TASK_RUNNING);
 291                                 goto get_anyway;
 292                         }
 293
 294                         spin_unlock(&vnode->lock);
 295
 296                         schedule();
 297                         set_current_state(TASK_UNINTERRUPTIBLE);
 298
 299                         spin_lock(&vnode->lock);
 300                 }
 301
 302                 remove_wait_queue(&vnode->update_waitq, &myself);
 303                 spin_unlock(&vnode->lock);
 304                 set_current_state(TASK_RUNNING);
 305
 306                 return test_bit(AFS_VNODE_DELETED, &vnode->flags) ?
 307                         -ENOENT : 0;
 308         }
 309
 310 get_anyway:
 311         /* okay... we're going to have to initiate the op */
 312         vnode->update_cnt++;
 313
 314         spin_unlock(&vnode->lock);
 315
 316         /* merge AFS status fetches and clear outstanding callback on this
 317          * vnode */
 318         do {
 319                 /* pick a server to query */
 320                 server = afs_volume_pick_fileserver(vnode);
 321                 if (IS_ERR(server))
 322                         return PTR_ERR(server);
 323
 324                 _debug("USING SERVER: %p{%08x}",
 325                        server, ntohl(server->addr.s_addr));
 326
 327                 ret = afs_fs_fetch_file_status(server, vnode, NULL,
 328                                                &afs_sync_call);
 329
 330         } while (!afs_volume_release_fileserver(vnode, server, ret));
 331
 332         /* adjust the flags */
 333         afs_vnode_finalise_status_update(vnode, server, ret);
 334
 335         _leave(" = %d", ret);
 336         return ret;
 337 }
 338
 339 /*
 340  * fetch file data from the volume
 341  * - TODO implement caching and server failover
 342  */
 343 int afs_vnode_fetch_data(struct afs_vnode *vnode, off_t offset, size_t length,
 344                          struct page *page)
 345 {
 346         struct afs_server *server;
 347         int ret;
 348
 349         _enter("%s,{%u,%u,%u}",
 350                vnode->volume->vlocation->vldb.name,
 351                vnode->fid.vid,
 352                vnode->fid.vnode,
 353                vnode->fid.unique);
 354
 355         /* this op will fetch the status */
 356         spin_lock(&vnode->lock);
 357         vnode->update_cnt++;
 358         spin_unlock(&vnode->lock);
 359
 360         /* merge in AFS status fetches and clear outstanding callback on this
 361          * vnode */
 362         do {
 363                 /* pick a server to query */
 364                 server = afs_volume_pick_fileserver(vnode);
 365                 if (IS_ERR(server))
 366                         return PTR_ERR(server);
 367
 368                 _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
 369
 370                 ret = afs_fs_fetch_data(server, vnode, offset, length, page,
 371                                         NULL, &afs_sync_call);
 372
 373         } while (!afs_volume_release_fileserver(vnode, server, ret));
 374
 375         /* adjust the flags */
 376         afs_vnode_finalise_status_update(vnode, server, ret);
 377
 378         _leave(" = %d", ret);
 379         return ret;
 380 }