1 /* vnode.c: AFS vnode management
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
17 #include <linux/pagemap.h>
20 #include "cmservice.h"
26 static void afs_vnode_cb_timed_out(struct afs_timer *timer);
28 struct afs_timer_ops afs_vnode_cb_timed_out_ops = {
29 .timed_out = afs_vnode_cb_timed_out,
32 #ifdef CONFIG_AFS_FSCACHE
33 static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
34 void *buffer, uint16_t buflen);
35 static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
37 static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
38 void *buffer, uint16_t buflen);
39 static fscache_checkaux_t afs_vnode_cache_check_aux(void *cookie_netfs_data,
42 static void afs_vnode_cache_mark_pages_cached(void *cookie_netfs_data,
43 struct address_space *mapping,
44 struct pagevec *cached_pvec);
45 static void afs_vnode_cache_now_uncached(void *cookie_netfs_data);
47 struct fscache_cookie_def afs_vnode_cache_index_def = {
49 .type = FSCACHE_COOKIE_TYPE_DATAFILE,
50 .get_key = afs_vnode_cache_get_key,
51 .get_attr = afs_vnode_cache_get_attr,
52 .get_aux = afs_vnode_cache_get_aux,
53 .check_aux = afs_vnode_cache_check_aux,
54 .mark_pages_cached = afs_vnode_cache_mark_pages_cached,
55 .now_uncached = afs_vnode_cache_now_uncached,
59 /*****************************************************************************/
61 * handle a callback timing out
62 * TODO: retain a ref to vnode struct for an outstanding callback timeout
64 static void afs_vnode_cb_timed_out(struct afs_timer *timer)
66 struct afs_server *oldserver;
67 struct afs_vnode *vnode;
69 vnode = list_entry(timer, struct afs_vnode, cb_timeout);
73 /* set the changed flag in the vnode and release the server */
74 spin_lock(&vnode->lock);
76 oldserver = xchg(&vnode->cb_server, NULL);
78 vnode->flags |= AFS_VNODE_CHANGED;
80 spin_lock(&afs_cb_hash_lock);
81 list_del_init(&vnode->cb_hash_link);
82 spin_unlock(&afs_cb_hash_lock);
84 spin_lock(&oldserver->cb_lock);
85 list_del_init(&vnode->cb_link);
86 spin_unlock(&oldserver->cb_lock);
89 spin_unlock(&vnode->lock);
91 afs_put_server(oldserver);
94 } /* end afs_vnode_cb_timed_out() */
96 /*****************************************************************************/
98 * finish off updating the recorded status of a file
99 * - starts callback expiry timer
100 * - adds to server's callback list
102 static void afs_vnode_finalise_status_update(struct afs_vnode *vnode,
103 struct afs_server *server,
106 struct afs_server *oldserver = NULL;
108 _enter("%p,%p,%d", vnode, server, ret);
110 spin_lock(&vnode->lock);
112 vnode->flags &= ~AFS_VNODE_CHANGED;
115 /* adjust the callback timeout appropriately */
116 afs_kafstimod_add_timer(&vnode->cb_timeout,
117 vnode->cb_expiry * HZ);
119 spin_lock(&afs_cb_hash_lock);
120 list_move_tail(&vnode->cb_hash_link,
121 &afs_cb_hash(server, &vnode->fid));
122 spin_unlock(&afs_cb_hash_lock);
124 /* swap ref to old callback server with that for new callback
126 oldserver = xchg(&vnode->cb_server, server);
127 if (oldserver != server) {
129 spin_lock(&oldserver->cb_lock);
130 list_del_init(&vnode->cb_link);
131 spin_unlock(&oldserver->cb_lock);
134 afs_get_server(server);
135 spin_lock(&server->cb_lock);
136 list_add_tail(&vnode->cb_link, &server->cb_promises);
137 spin_unlock(&server->cb_lock);
144 else if (ret == -ENOENT) {
145 /* the file was deleted - clear the callback timeout */
146 oldserver = xchg(&vnode->cb_server, NULL);
147 afs_kafstimod_del_timer(&vnode->cb_timeout);
149 _debug("got NOENT from server - marking file deleted");
150 vnode->flags |= AFS_VNODE_DELETED;
155 spin_unlock(&vnode->lock);
157 wake_up_all(&vnode->update_waitq);
159 afs_put_server(oldserver);
163 } /* end afs_vnode_finalise_status_update() */
165 /*****************************************************************************/
167 * fetch file status from the volume
168 * - don't issue a fetch if:
169 * - the changed bit is not set and there's a valid callback
170 * - there are any outstanding ops that will fetch the status
171 * - TODO implement local caching
173 int afs_vnode_fetch_status(struct afs_vnode *vnode)
175 struct afs_server *server;
178 DECLARE_WAITQUEUE(myself, current);
180 _enter("%s,{%u,%u,%u}",
181 vnode->volume->vlocation->vldb.name,
182 vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
184 if (!(vnode->flags & AFS_VNODE_CHANGED) && vnode->cb_server) {
185 _leave(" [unchanged]");
189 if (vnode->flags & AFS_VNODE_DELETED) {
190 _leave(" [deleted]");
194 spin_lock(&vnode->lock);
196 if (!(vnode->flags & AFS_VNODE_CHANGED)) {
197 spin_unlock(&vnode->lock);
198 _leave(" [unchanged]");
202 if (vnode->update_cnt > 0) {
203 /* someone else started a fetch */
206 set_current_state(TASK_UNINTERRUPTIBLE);
207 add_wait_queue(&vnode->update_waitq, &myself);
209 /* wait for the status to be updated */
211 if (!(vnode->flags & AFS_VNODE_CHANGED))
213 if (vnode->flags & AFS_VNODE_DELETED)
216 /* it got updated and invalidated all before we saw
218 if (vnode->update_cnt == 0) {
219 remove_wait_queue(&vnode->update_waitq,
221 set_current_state(TASK_RUNNING);
225 spin_unlock(&vnode->lock);
228 set_current_state(TASK_UNINTERRUPTIBLE);
230 spin_lock(&vnode->lock);
233 remove_wait_queue(&vnode->update_waitq, &myself);
234 spin_unlock(&vnode->lock);
235 set_current_state(TASK_RUNNING);
237 _leave(" [conflicted, %d", !!(vnode->flags & AFS_VNODE_DELETED));
238 return vnode->flags & AFS_VNODE_DELETED ? -ENOENT : 0;
242 /* okay... we're going to have to initiate the op */
245 spin_unlock(&vnode->lock);
247 /* merge AFS status fetches and clear outstanding callback on this
250 /* pick a server to query */
251 ret = afs_volume_pick_fileserver(vnode->volume, &server);
255 _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
257 ret = afs_rxfs_fetch_file_status(server, vnode, NULL);
259 } while (!afs_volume_release_fileserver(vnode->volume, server, ret));
261 /* adjust the flags */
262 afs_vnode_finalise_status_update(vnode, server, ret);
264 _leave(" = %d", ret);
266 } /* end afs_vnode_fetch_status() */
268 /*****************************************************************************/
270 * fetch file data from the volume
271 * - TODO implement caching and server failover
273 int afs_vnode_fetch_data(struct afs_vnode *vnode,
274 struct afs_rxfs_fetch_descriptor *desc)
276 struct afs_server *server;
279 _enter("%s,{%u,%u,%u}",
280 vnode->volume->vlocation->vldb.name,
285 /* this op will fetch the status */
286 spin_lock(&vnode->lock);
288 spin_unlock(&vnode->lock);
290 /* merge in AFS status fetches and clear outstanding callback on this
293 /* pick a server to query */
294 ret = afs_volume_pick_fileserver(vnode->volume, &server);
298 _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
300 ret = afs_rxfs_fetch_file_data(server, vnode, desc, NULL);
302 } while (!afs_volume_release_fileserver(vnode->volume, server, ret));
304 /* adjust the flags */
305 afs_vnode_finalise_status_update(vnode, server, ret);
307 _leave(" = %d", ret);
310 } /* end afs_vnode_fetch_data() */
312 /*****************************************************************************/
314 * break any outstanding callback on a vnode
315 * - only relevent to server that issued it
317 int afs_vnode_give_up_callback(struct afs_vnode *vnode)
319 struct afs_server *server;
322 _enter("%s,{%u,%u,%u}",
323 vnode->volume->vlocation->vldb.name,
328 spin_lock(&afs_cb_hash_lock);
329 list_del_init(&vnode->cb_hash_link);
330 spin_unlock(&afs_cb_hash_lock);
332 /* set the changed flag in the vnode and release the server */
333 spin_lock(&vnode->lock);
335 afs_kafstimod_del_timer(&vnode->cb_timeout);
337 server = xchg(&vnode->cb_server, NULL);
339 vnode->flags |= AFS_VNODE_CHANGED;
341 spin_lock(&server->cb_lock);
342 list_del_init(&vnode->cb_link);
343 spin_unlock(&server->cb_lock);
346 spin_unlock(&vnode->lock);
350 ret = afs_rxfs_give_up_callback(server, vnode);
351 afs_put_server(server);
354 _leave(" = %d", ret);
356 } /* end afs_vnode_give_up_callback() */
358 /*****************************************************************************/
360 * set the key for the index entry
362 #ifdef CONFIG_AFS_FSCACHE
363 static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
364 void *buffer, uint16_t bufmax)
366 const struct afs_vnode *vnode = cookie_netfs_data;
369 _enter("{%x,%x,%Lx},%p,%u",
370 vnode->fid.vnode, vnode->fid.unique, vnode->status.version,
373 klen = sizeof(vnode->fid.vnode);
377 memcpy(buffer, &vnode->fid.vnode, sizeof(vnode->fid.vnode));
379 _leave(" = %u", klen);
382 } /* end afs_vnode_cache_get_key() */
385 /*****************************************************************************/
387 * provide an updated file attributes
389 #ifdef CONFIG_AFS_FSCACHE
390 static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
393 const struct afs_vnode *vnode = cookie_netfs_data;
395 _enter("{%x,%x,%Lx},",
396 vnode->fid.vnode, vnode->fid.unique, vnode->status.version);
398 *size = i_size_read((struct inode *) &vnode->vfs_inode);
400 } /* end afs_vnode_cache_get_attr() */
403 /*****************************************************************************/
405 * provide new auxilliary cache data
407 #ifdef CONFIG_AFS_FSCACHE
408 static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
409 void *buffer, uint16_t bufmax)
411 const struct afs_vnode *vnode = cookie_netfs_data;
414 _enter("{%x,%x,%Lx},%p,%u",
415 vnode->fid.vnode, vnode->fid.unique, vnode->status.version,
418 dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.version);
422 memcpy(buffer, &vnode->fid.unique, sizeof(vnode->fid.unique));
423 buffer += sizeof(vnode->fid.unique);
424 memcpy(buffer, &vnode->status.version, sizeof(vnode->status.version));
426 _leave(" = %u", dlen);
429 } /* end afs_vnode_cache_get_aux() */
432 /*****************************************************************************/
434 * check that the auxilliary data indicates that the entry is still valid
436 #ifdef CONFIG_AFS_FSCACHE
437 static fscache_checkaux_t afs_vnode_cache_check_aux(void *cookie_netfs_data,
441 struct afs_vnode *vnode = cookie_netfs_data;
444 _enter("{%x,%x,%Lx},%p,%u",
445 vnode->fid.vnode, vnode->fid.unique, vnode->status.version,
448 /* check the size of the data is what we're expecting */
449 dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.version);
450 if (dlen != buflen) {
451 _leave(" = OBSOLETE [len %hx != %hx]", dlen, buflen);
452 return FSCACHE_CHECKAUX_OBSOLETE;
457 sizeof(vnode->fid.unique)
462 memcpy(&unique, buffer, sizeof(unique));
464 _leave(" = OBSOLETE [uniq %x != %x]",
465 unique, vnode->fid.unique);
466 return FSCACHE_CHECKAUX_OBSOLETE;
469 if (memcmp(buffer + sizeof(vnode->fid.unique),
470 &vnode->status.version,
471 sizeof(vnode->status.version)
474 afs_dataversion_t version;
476 memcpy(&version, buffer + sizeof(vnode->fid.unique),
479 _leave(" = OBSOLETE [vers %llx != %llx]",
480 version, vnode->status.version);
481 return FSCACHE_CHECKAUX_OBSOLETE;
484 _leave(" = SUCCESS");
485 return FSCACHE_CHECKAUX_OKAY;
487 } /* end afs_vnode_cache_check_aux() */
490 /*****************************************************************************/
492 * indication of pages that now have cache metadata retained
493 * - this function should mark the specified pages as now being cached
495 #ifdef CONFIG_AFS_FSCACHE
496 static void afs_vnode_cache_mark_pages_cached(void *cookie_netfs_data,
497 struct address_space *mapping,
498 struct pagevec *cached_pvec)
502 for (loop = 0; loop < cached_pvec->nr; loop++) {
503 struct page *page = cached_pvec->pages[loop];
505 _debug("- mark %p{%lx}", page, page->index);
507 SetPagePrivate(page);
510 } /* end afs_vnode_cache_mark_pages_cached() */
513 /*****************************************************************************/
515 * indication the cookie is no longer uncached
516 * - this function is called when the backing store currently caching a cookie
518 * - the netfs should use this to clean up any markers indicating cached pages
519 * - this is mandatory for any object that may have data
521 static void afs_vnode_cache_now_uncached(void *cookie_netfs_data)
523 struct afs_vnode *vnode = cookie_netfs_data;
528 _enter("{%x,%x,%Lx}",
529 vnode->fid.vnode, vnode->fid.unique, vnode->status.version);
531 pagevec_init(&pvec, 0);
535 /* grab a bunch of pages to clean */
536 nr_pages = pagevec_lookup(&pvec, vnode->vfs_inode.i_mapping,
538 PAGEVEC_SIZE - pagevec_count(&pvec));
542 for (loop = 0; loop < nr_pages; loop++)
543 ClearPagePrivate(pvec.pages[loop]);
545 first = pvec.pages[nr_pages - 1]->index + 1;
548 pagevec_release(&pvec);
554 } /* end afs_vnode_cache_now_uncached() */