/* AFS caching stuff * * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ #include <linux/sched.h> #include "internal.h" static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data, void *buffer, uint16_t buflen); static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data, void *buffer, uint16_t buflen); static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data, const void *buffer, uint16_t buflen); static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data, void *buffer, uint16_t buflen); static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data, void *buffer, uint16_t buflen); static enum fscache_checkaux afs_vlocation_cache_check_aux( void *cookie_netfs_data, const void *buffer, uint16_t buflen); static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data, void *buffer, uint16_t buflen); static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data, void *buffer, uint16_t buflen); static void afs_vnode_cache_get_attr(const void *cookie_netfs_data, uint64_t *size); static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data, void *buffer, uint16_t buflen); static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data, const void *buffer, uint16_t buflen); static void afs_vnode_cache_now_uncached(void *cookie_netfs_data); struct fscache_netfs afs_cache_netfs = { .name = "afs", .version = 0, }; struct fscache_cookie_def afs_cell_cache_index_def = { .name = "AFS.cell", .type = FSCACHE_COOKIE_TYPE_INDEX, .get_key = afs_cell_cache_get_key, .get_aux = afs_cell_cache_get_aux, .check_aux = afs_cell_cache_check_aux, }; struct fscache_cookie_def afs_vlocation_cache_index_def = { .name = "AFS.vldb", .type = FSCACHE_COOKIE_TYPE_INDEX, .get_key = afs_vlocation_cache_get_key, .get_aux = afs_vlocation_cache_get_aux, .check_aux = afs_vlocation_cache_check_aux, }; struct fscache_cookie_def afs_volume_cache_index_def = { .name = "AFS.volume", .type = FSCACHE_COOKIE_TYPE_INDEX, .get_key = afs_volume_cache_get_key, }; struct fscache_cookie_def afs_vnode_cache_index_def = { .name = "AFS.vnode", .type = FSCACHE_COOKIE_TYPE_DATAFILE, .get_key = afs_vnode_cache_get_key, .get_attr = afs_vnode_cache_get_attr, .get_aux = afs_vnode_cache_get_aux, .check_aux = afs_vnode_cache_check_aux, .now_uncached = afs_vnode_cache_now_uncached, }; /* * set the key for the index entry */ static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct afs_cell *cell = cookie_netfs_data; uint16_t klen; _enter("%p,%p,%u", cell, buffer, bufmax); klen = strlen(cell->name); if (klen > bufmax) return 0; memcpy(buffer, cell->name, klen); return klen; } /* * provide new auxilliary cache data */ static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct afs_cell *cell = cookie_netfs_data; uint16_t dlen; _enter("%p,%p,%u", cell, buffer, bufmax); dlen = cell->vl_naddrs * sizeof(cell->vl_addrs[0]); dlen = min(dlen, bufmax); dlen &= ~(sizeof(cell->vl_addrs[0]) - 1); memcpy(buffer, cell->vl_addrs, dlen); return dlen; } /* * check that the auxilliary data indicates that the entry is still valid */ static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data, const void *buffer, uint16_t buflen) { _leave(" = OKAY"); return FSCACHE_CHECKAUX_OKAY; } /*****************************************************************************/ /* * set the key for the index entry */ static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct afs_vlocation *vlocation = cookie_netfs_data; uint16_t klen; _enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax); klen = strnlen(vlocation->vldb.name, sizeof(vlocation->vldb.name)); if (klen > bufmax) return 0; memcpy(buffer, vlocation->vldb.name, klen); _leave(" = %u", klen); return klen; } /* * provide new auxilliary cache data */ static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct afs_vlocation *vlocation = cookie_netfs_data; uint16_t dlen; _enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax); dlen = sizeof(struct afs_cache_vlocation); dlen -= offsetof(struct afs_cache_vlocation, nservers); if (dlen > bufmax) return 0; memcpy(buffer, (uint8_t *)&vlocation->vldb.nservers, dlen); _leave(" = %u", dlen); return dlen; } /* * check that the auxilliary data indicates that the entry is still valid */ static enum fscache_checkaux afs_vlocation_cache_check_aux(void *cookie_netfs_data, const void *buffer, uint16_t buflen) { const struct afs_cache_vlocation *cvldb; struct afs_vlocation *vlocation = cookie_netfs_data; uint16_t dlen; _enter("{%s},%p,%u", vlocation->vldb.name, buffer, buflen); /* check the size of the data is what we're expecting */ dlen = sizeof(struct afs_cache_vlocation); dlen -= offsetof(struct afs_cache_vlocation, nservers); if (dlen != buflen) return FSCACHE_CHECKAUX_OBSOLETE; cvldb = container_of(buffer, struct afs_cache_vlocation, nservers); /* if what's on disk is more valid than what's in memory, then use the * VL record from the cache */ if (!vlocation->valid || vlocation->vldb.rtime == cvldb->rtime) { memcpy((uint8_t *)&vlocation->vldb.nservers, buffer, dlen); vlocation->valid = 1; _leave(" = SUCCESS [c->m]"); return FSCACHE_CHECKAUX_OKAY; } /* need to update the cache if the cached info differs */ if (memcmp(&vlocation->vldb, buffer, dlen) != 0) { /* delete if the volume IDs for this name differ */ if (memcmp(&vlocation->vldb.vid, &cvldb->vid, sizeof(cvldb->vid)) != 0 ) { _leave(" = OBSOLETE"); return FSCACHE_CHECKAUX_OBSOLETE; } _leave(" = UPDATE"); return FSCACHE_CHECKAUX_NEEDS_UPDATE; } _leave(" = OKAY"); return FSCACHE_CHECKAUX_OKAY; } /*****************************************************************************/ /* * set the key for the volume index entry */ static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct afs_volume *volume = cookie_netfs_data; uint16_t klen; _enter("{%u},%p,%u", volume->type, buffer, bufmax); klen = sizeof(volume->type); if (klen > bufmax) return 0; memcpy(buffer, &volume->type, sizeof(volume->type)); _leave(" = %u", klen); return klen; } /*****************************************************************************/ /* * set the key for the index entry */ static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct afs_vnode *vnode = cookie_netfs_data; uint16_t klen; _enter("{%x,%x,%llx},%p,%u", vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version, buffer, bufmax); klen = sizeof(vnode->fid.vnode); if (klen > bufmax) return 0; memcpy(buffer, &vnode->fid.vnode, sizeof(vnode->fid.vnode)); _leave(" = %u", klen); return klen; } /* * provide updated file attributes */ static void afs_vnode_cache_get_attr(const void *cookie_netfs_data, uint64_t *size) { const struct afs_vnode *vnode = cookie_netfs_data; _enter("{%x,%x,%llx},", vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version); *size = vnode->status.size; } /* * provide new auxilliary cache data */ static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct afs_vnode *vnode = cookie_netfs_data; uint16_t dlen; _enter("{%x,%x,%Lx},%p,%u", vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version, buffer, bufmax); dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version); if (dlen > bufmax) return 0; memcpy(buffer, &vnode->fid.unique, sizeof(vnode->fid.unique)); buffer += sizeof(vnode->fid.unique); memcpy(buffer, &vnode->status.data_version, sizeof(vnode->status.data_version)); _leave(" = %u", dlen); return dlen; } /* * check that the auxilliary data indicates that the entry is still valid */ static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data, const void *buffer, uint16_t buflen) { struct afs_vnode *vnode = cookie_netfs_data; uint16_t dlen; _enter("{%x,%x,%llx},%p,%u", vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version, buffer, buflen); /* check the size of the data is what we're expecting */ dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version); if (dlen != buflen) { _leave(" = OBSOLETE [len %hx != %hx]", dlen, buflen); return FSCACHE_CHECKAUX_OBSOLETE; } if (memcmp(buffer, &vnode->fid.unique, sizeof(vnode->fid.unique) ) != 0) { unsigned unique; memcpy(&unique, buffer, sizeof(unique)); _leave(" = OBSOLETE [uniq %x != %x]", unique, vnode->fid.unique); return FSCACHE_CHECKAUX_OBSOLETE; } if (memcmp(buffer + sizeof(vnode->fid.unique), &vnode->status.data_version, sizeof(vnode->status.data_version) ) != 0) { afs_dataversion_t version; memcpy(&version, buffer + sizeof(vnode->fid.unique), sizeof(version)); _leave(" = OBSOLETE [vers %llx != %llx]", version, vnode->status.data_version); return FSCACHE_CHECKAUX_OBSOLETE; } _leave(" = SUCCESS"); return FSCACHE_CHECKAUX_OKAY; } /* * indication the cookie is no longer uncached * - this function is called when the backing store currently caching a cookie * is removed * - the netfs should use this to clean up any markers indicating cached pages * - this is mandatory for any object that may have data */ static void afs_vnode_cache_now_uncached(void *cookie_netfs_data) { struct afs_vnode *vnode = cookie_netfs_data; struct pagevec pvec; pgoff_t first; int loop, nr_pages; _enter("{%x,%x,%Lx}", vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version); pagevec_init(&pvec, 0); first = 0; for (;;) { /* grab a bunch of pages to clean */ nr_pages = pagevec_lookup(&pvec, vnode->vfs_inode.i_mapping, first, PAGEVEC_SIZE - pagevec_count(&pvec)); if (!nr_pages) break; for (loop = 0; loop < nr_pages; loop++) ClearPageFsCache(pvec.pages[loop]); first = pvec.pages[nr_pages - 1]->index + 1; pvec.nr = nr_pages; pagevec_release(&pvec); cond_resched(); } _leave(""); }