| 1 | |
| 2 | *
|
| 3 | * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
|
| 4 | * Written by David Howells ([email protected])
|
| 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 <linux/pagemap.h>
|
| 18 | #include "volume.h"
|
| 19 | #include "cell.h"
|
| 20 | #include "cmservice.h"
|
| 21 | #include "fsclient.h"
|
| 22 | #include "vlclient.h"
|
| 23 | #include "vnode.h"
|
| 24 | #include "internal.h"
|
| 25 |
|
| 26 | static void afs_vnode_cb_timed_out(struct afs_timer *timer);
|
| 27 |
|
| 28 | struct afs_timer_ops afs_vnode_cb_timed_out_ops = {
|
| 29 | .timed_out = afs_vnode_cb_timed_out,
|
| 30 | };
|
| 31 |
|
| 32 | #ifdef AFS_CACHING_SUPPORT
|
| 33 | static cachefs_match_val_t afs_vnode_cache_match(void *target,
|
| 34 | const void *entry);
|
| 35 | static void afs_vnode_cache_update(void *source, void *entry);
|
| 36 |
|
| 37 | struct cachefs_index_def afs_vnode_cache_index_def = {
|
| 38 | .name = "vnode",
|
| 39 | .data_size = sizeof(struct afs_cache_vnode),
|
| 40 | .keys[0] = { CACHEFS_INDEX_KEYS_BIN, 4 },
|
| 41 | .match = afs_vnode_cache_match,
|
| 42 | .update = afs_vnode_cache_update,
|
| 43 | };
|
| 44 | #endif
|
| 45 |
|
| 46 |
|
| 47 | |
| 48 | * handle a callback timing out
|
| 49 | * TODO: retain a ref to vnode struct for an outstanding callback timeout
|
| 50 |
|
| 51 | static void afs_vnode_cb_timed_out(struct afs_timer *timer)
|
| 52 | {
|
| 53 | struct afs_server *oldserver;
|
| 54 | struct afs_vnode *vnode;
|
| 55 |
|
| 56 | vnode = list_entry(timer, struct afs_vnode, cb_timeout);
|
| 57 |
|
| 58 | _enter("%p", vnode);
|
| 59 |
|
| 60 |
|
| 61 | spin_lock(&vnode->lock);
|
| 62 |
|
| 63 | oldserver = xchg(&vnode->cb_server, NULL);
|
| 64 | if (oldserver) {
|
| 65 | vnode->flags |= AFS_VNODE_CHANGED;
|
| 66 |
|
| 67 | spin_lock(&afs_cb_hash_lock);
|
| 68 | list_del_init(&vnode->cb_hash_link);
|
| 69 | spin_unlock(&afs_cb_hash_lock);
|
| 70 |
|
| 71 | spin_lock(&oldserver->cb_lock);
|
| 72 | list_del_init(&vnode->cb_link);
|
| 73 | spin_unlock(&oldserver->cb_lock);
|
| 74 | }
|
| 75 |
|
| 76 | spin_unlock(&vnode->lock);
|
| 77 |
|
| 78 | afs_put_server(oldserver);
|
| 79 |
|
| 80 | _leave("");
|
| 81 | }
|
| 82 |
|
| 83 |
|
| 84 | |
| 85 | * finish off updating the recorded status of a file
|
| 86 | * - starts callback expiry timer
|
| 87 | * - adds to server's callback list
|
| 88 |
|
| 89 | static void afs_vnode_finalise_status_update(struct afs_vnode *vnode,
|
| 90 | struct afs_server *server,
|
| 91 | int ret)
|
| 92 | {
|
| 93 | struct afs_server *oldserver = NULL;
|
| 94 |
|
| 95 | _enter("%p,%p,%d", vnode, server, ret);
|
| 96 |
|
| 97 | spin_lock(&vnode->lock);
|
| 98 |
|
| 99 | vnode->flags &= ~AFS_VNODE_CHANGED;
|
| 100 |
|
| 101 | if (ret == 0) {
|
| 102 |
|
| 103 | afs_kafstimod_add_timer(&vnode->cb_timeout,
|
| 104 | vnode->cb_expiry * HZ);
|
| 105 |
|
| 106 | spin_lock(&afs_cb_hash_lock);
|
| 107 | list_move_tail(&vnode->cb_hash_link,
|
| 108 | &afs_cb_hash(server, &vnode->fid));
|
| 109 | spin_unlock(&afs_cb_hash_lock);
|
| 110 |
|
| 111 | |
| 112 | * server
|
| 113 | oldserver = xchg(&vnode->cb_server, server);
|
| 114 | if (oldserver != server) {
|
| 115 | if (oldserver) {
|
| 116 | spin_lock(&oldserver->cb_lock);
|
| 117 | list_del_init(&vnode->cb_link);
|
| 118 | spin_unlock(&oldserver->cb_lock);
|
| 119 | }
|
| 120 |
|
| 121 | afs_get_server(server);
|
| 122 | spin_lock(&server->cb_lock);
|
| 123 | list_add_tail(&vnode->cb_link, &server->cb_promises);
|
| 124 | spin_unlock(&server->cb_lock);
|
| 125 | }
|
| 126 | else {
|
| 127 |
|
| 128 | oldserver = NULL;
|
| 129 | }
|
| 130 | }
|
| 131 | else if (ret == -ENOENT) {
|
| 132 |
|
| 133 | oldserver = xchg(&vnode->cb_server, NULL);
|
| 134 | afs_kafstimod_del_timer(&vnode->cb_timeout);
|
| 135 |
|
| 136 | _debug("got NOENT from server - marking file deleted");
|
| 137 | vnode->flags |= AFS_VNODE_DELETED;
|
| 138 | }
|
| 139 |
|
| 140 | vnode->update_cnt--;
|
| 141 |
|
| 142 | spin_unlock(&vnode->lock);
|
| 143 |
|
| 144 | wake_up_all(&vnode->update_waitq);
|
| 145 |
|
| 146 | afs_put_server(oldserver);
|
| 147 |
|
| 148 | _leave("");
|
| 149 |
|
| 150 | }
|
| 151 |
|
| 152 |
|
| 153 | |
| 154 | * fetch file status from the volume
|
| 155 | * - don't issue a fetch if:
|
| 156 | * - the changed bit is not set and there's a valid callback
|
| 157 | * - there are any outstanding ops that will fetch the status
|
| 158 | * - TODO implement local caching
|
| 159 |
|
| 160 | int afs_vnode_fetch_status(struct afs_vnode *vnode)
|
| 161 | {
|
| 162 | struct afs_server *server;
|
| 163 | int ret;
|
| 164 |
|
| 165 | DECLARE_WAITQUEUE(myself, current);
|
| 166 |
|
| 167 | _enter("%s,{%u,%u,%u}",
|
| 168 | vnode->volume->vlocation->vldb.name,
|
| 169 | vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
|
| 170 |
|
| 171 | if (!(vnode->flags & AFS_VNODE_CHANGED) && vnode->cb_server) {
|
| 172 | _leave(" [unchanged]");
|
| 173 | return 0;
|
| 174 | }
|
| 175 |
|
| 176 | if (vnode->flags & AFS_VNODE_DELETED) {
|
| 177 | _leave(" [deleted]");
|
| 178 | return -ENOENT;
|
| 179 | }
|
| 180 |
|
| 181 | spin_lock(&vnode->lock);
|
| 182 |
|
| 183 | if (!(vnode->flags & AFS_VNODE_CHANGED)) {
|
| 184 | spin_unlock(&vnode->lock);
|
| 185 | _leave(" [unchanged]");
|
| 186 | return 0;
|
| 187 | }
|
| 188 |
|
| 189 | if (vnode->update_cnt > 0) {
|
| 190 |
|
| 191 | set_current_state(TASK_UNINTERRUPTIBLE);
|
| 192 | add_wait_queue(&vnode->update_waitq, &myself);
|
| 193 |
|
| 194 |
|
| 195 | for (;;) {
|
| 196 | if (!(vnode->flags & AFS_VNODE_CHANGED))
|
| 197 | break;
|
| 198 | if (vnode->flags & AFS_VNODE_DELETED)
|
| 199 | break;
|
| 200 |
|
| 201 | |
| 202 | * it
|
| 203 | if (vnode->update_cnt == 0) {
|
| 204 | remove_wait_queue(&vnode->update_waitq,
|
| 205 | &myself);
|
| 206 | set_current_state(TASK_RUNNING);
|
| 207 | goto get_anyway;
|
| 208 | }
|
| 209 |
|
| 210 | spin_unlock(&vnode->lock);
|
| 211 |
|
| 212 | schedule();
|
| 213 | set_current_state(TASK_UNINTERRUPTIBLE);
|
| 214 |
|
| 215 | spin_lock(&vnode->lock);
|
| 216 | }
|
| 217 |
|
| 218 | remove_wait_queue(&vnode->update_waitq, &myself);
|
| 219 | spin_unlock(&vnode->lock);
|
| 220 | set_current_state(TASK_RUNNING);
|
| 221 |
|
| 222 | return vnode->flags & AFS_VNODE_DELETED ? -ENOENT : 0;
|
| 223 | }
|
| 224 |
|
| 225 | get_anyway:
|
| 226 |
|
| 227 | vnode->update_cnt++;
|
| 228 |
|
| 229 | spin_unlock(&vnode->lock);
|
| 230 |
|
| 231 | |
| 232 | * vnode
|
| 233 | do {
|
| 234 |
|
| 235 | ret = afs_volume_pick_fileserver(vnode->volume, &server);
|
| 236 | if (ret<0)
|
| 237 | return ret;
|
| 238 |
|
| 239 | _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
|
| 240 |
|
| 241 | ret = afs_rxfs_fetch_file_status(server, vnode, NULL);
|
| 242 |
|
| 243 | } while (!afs_volume_release_fileserver(vnode->volume, server, ret));
|
| 244 |
|
| 245 |
|
| 246 | afs_vnode_finalise_status_update(vnode, server, ret);
|
| 247 |
|
| 248 | _leave(" = %d", ret);
|
| 249 | return ret;
|
| 250 | }
|
| 251 |
|
| 252 |
|
| 253 | |
| 254 | * fetch file data from the volume
|
| 255 | * - TODO implement caching and server failover
|
| 256 |
|
| 257 | int afs_vnode_fetch_data(struct afs_vnode *vnode,
|
| 258 | struct afs_rxfs_fetch_descriptor *desc)
|
| 259 | {
|
| 260 | struct afs_server *server;
|
| 261 | int ret;
|
| 262 |
|
| 263 | _enter("%s,{%u,%u,%u}",
|
| 264 | vnode->volume->vlocation->vldb.name,
|
| 265 | vnode->fid.vid,
|
| 266 | vnode->fid.vnode,
|
| 267 | vnode->fid.unique);
|
| 268 |
|
| 269 |
|
| 270 | spin_lock(&vnode->lock);
|
| 271 | vnode->update_cnt++;
|
| 272 | spin_unlock(&vnode->lock);
|
| 273 |
|
| 274 | |
| 275 | * vnode
|
| 276 | do {
|
| 277 |
|
| 278 | ret = afs_volume_pick_fileserver(vnode->volume, &server);
|
| 279 | if (ret < 0)
|
| 280 | return ret;
|
| 281 |
|
| 282 | _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
|
| 283 |
|
| 284 | ret = afs_rxfs_fetch_file_data(server, vnode, desc, NULL);
|
| 285 |
|
| 286 | } while (!afs_volume_release_fileserver(vnode->volume, server, ret));
|
| 287 |
|
| 288 |
|
| 289 | afs_vnode_finalise_status_update(vnode, server, ret);
|
| 290 |
|
| 291 | _leave(" = %d", ret);
|
| 292 | return ret;
|
| 293 |
|
| 294 | }
|
| 295 |
|
| 296 |
|
| 297 | |
| 298 | * break any outstanding callback on a vnode
|
| 299 | * - only relevent to server that issued it
|
| 300 |
|
| 301 | int afs_vnode_give_up_callback(struct afs_vnode *vnode)
|
| 302 | {
|
| 303 | struct afs_server *server;
|
| 304 | int ret;
|
| 305 |
|
| 306 | _enter("%s,{%u,%u,%u}",
|
| 307 | vnode->volume->vlocation->vldb.name,
|
| 308 | vnode->fid.vid,
|
| 309 | vnode->fid.vnode,
|
| 310 | vnode->fid.unique);
|
| 311 |
|
| 312 | spin_lock(&afs_cb_hash_lock);
|
| 313 | list_del_init(&vnode->cb_hash_link);
|
| 314 | spin_unlock(&afs_cb_hash_lock);
|
| 315 |
|
| 316 |
|
| 317 | spin_lock(&vnode->lock);
|
| 318 |
|
| 319 | afs_kafstimod_del_timer(&vnode->cb_timeout);
|
| 320 |
|
| 321 | server = xchg(&vnode->cb_server, NULL);
|
| 322 | if (server) {
|
| 323 | vnode->flags |= AFS_VNODE_CHANGED;
|
| 324 |
|
| 325 | spin_lock(&server->cb_lock);
|
| 326 | list_del_init(&vnode->cb_link);
|
| 327 | spin_unlock(&server->cb_lock);
|
| 328 | }
|
| 329 |
|
| 330 | spin_unlock(&vnode->lock);
|
| 331 |
|
| 332 | ret = 0;
|
| 333 | if (server) {
|
| 334 | ret = afs_rxfs_give_up_callback(server, vnode);
|
| 335 | afs_put_server(server);
|
| 336 | }
|
| 337 |
|
| 338 | _leave(" = %d", ret);
|
| 339 | return ret;
|
| 340 | }
|
| 341 |
|
| 342 |
|
| 343 | |
| 344 | * match a vnode record stored in the cache
|
| 345 |
|
| 346 | #ifdef AFS_CACHING_SUPPORT
|
| 347 | static cachefs_match_val_t afs_vnode_cache_match(void *target,
|
| 348 | const void *entry)
|
| 349 | {
|
| 350 | const struct afs_cache_vnode *cvnode = entry;
|
| 351 | struct afs_vnode *vnode = target;
|
| 352 |
|
| 353 | _enter("{%x,%x,%Lx},{%x,%x,%Lx}",
|
| 354 | vnode->fid.vnode,
|
| 355 | vnode->fid.unique,
|
| 356 | vnode->status.version,
|
| 357 | cvnode->vnode_id,
|
| 358 | cvnode->vnode_unique,
|
| 359 | cvnode->data_version);
|
| 360 |
|
| 361 | if (vnode->fid.vnode != cvnode->vnode_id) {
|
| 362 | _leave(" = FAILED");
|
| 363 | return CACHEFS_MATCH_FAILED;
|
| 364 | }
|
| 365 |
|
| 366 | if (vnode->fid.unique != cvnode->vnode_unique ||
|
| 367 | vnode->status.version != cvnode->data_version) {
|
| 368 | _leave(" = DELETE");
|
| 369 | return CACHEFS_MATCH_SUCCESS_DELETE;
|
| 370 | }
|
| 371 |
|
| 372 | _leave(" = SUCCESS");
|
| 373 | return CACHEFS_MATCH_SUCCESS;
|
| 374 | }
|
| 375 | #endif
|
| 376 |
|
| 377 |
|
| 378 | |
| 379 | * update a vnode record stored in the cache
|
| 380 |
|
| 381 | #ifdef AFS_CACHING_SUPPORT
|
| 382 | static void afs_vnode_cache_update(void *source, void *entry)
|
| 383 | {
|
| 384 | struct afs_cache_vnode *cvnode = entry;
|
| 385 | struct afs_vnode *vnode = source;
|
| 386 |
|
| 387 | _enter("");
|
| 388 |
|
| 389 | cvnode->vnode_id = vnode->fid.vnode;
|
| 390 | cvnode->vnode_unique = vnode->fid.unique;
|
| 391 | cvnode->data_version = vnode->status.version;
|
| 392 |
|
| 393 | }
|
| 394 | #endif
|