fs/afs/cache.c

   1 /* AFS caching stuff
   2  *
   3  * Copyright (C) 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 #ifdef AFS_CACHING_SUPPORT
  13 static cachefs_match_val_t afs_cell_cache_match(void *target,
  14                                                 const void *entry);
  15 static void afs_cell_cache_update(void *source, void *entry);
  16
  17 struct cachefs_index_def afs_cache_cell_index_def = {
  18         .name                   = "cell_ix",
  19         .data_size              = sizeof(struct afs_cache_cell),
  20         .keys[0]                = { CACHEFS_INDEX_KEYS_ASCIIZ, 64 },
  21         .match                  = afs_cell_cache_match,
  22         .update                 = afs_cell_cache_update,
  23 };
  24 #endif
  25
  26 /*
  27  * match a cell record obtained from the cache
  28  */
  29 #ifdef AFS_CACHING_SUPPORT
  30 static cachefs_match_val_t afs_cell_cache_match(void *target,
  31                                                 const void *entry)
  32 {
  33         const struct afs_cache_cell *ccell = entry;
  34         struct afs_cell *cell = target;
  35
  36         _enter("{%s},{%s}", ccell->name, cell->name);
  37
  38         if (strncmp(ccell->name, cell->name, sizeof(ccell->name)) == 0) {
  39                 _leave(" = SUCCESS");
  40                 return CACHEFS_MATCH_SUCCESS;
  41         }
  42
  43         _leave(" = FAILED");
  44         return CACHEFS_MATCH_FAILED;
  45 }
  46 #endif
  47
  48 /*
  49  * update a cell record in the cache
  50  */
  51 #ifdef AFS_CACHING_SUPPORT
  52 static void afs_cell_cache_update(void *source, void *entry)
  53 {
  54         struct afs_cache_cell *ccell = entry;
  55         struct afs_cell *cell = source;
  56
  57         _enter("%p,%p", source, entry);
  58
  59         strncpy(ccell->name, cell->name, sizeof(ccell->name));
  60
  61         memcpy(ccell->vl_servers,
  62                cell->vl_addrs,
  63                min(sizeof(ccell->vl_servers), sizeof(cell->vl_addrs)));
  64
  65 }
  66 #endif
  67
  68 #ifdef AFS_CACHING_SUPPORT
  69 static cachefs_match_val_t afs_vlocation_cache_match(void *target,
  70                                                      const void *entry);
  71 static void afs_vlocation_cache_update(void *source, void *entry);
  72
  73 struct cachefs_index_def afs_vlocation_cache_index_def = {
  74         .name           = "vldb",
  75         .data_size      = sizeof(struct afs_cache_vlocation),
  76         .keys[0]        = { CACHEFS_INDEX_KEYS_ASCIIZ, 64 },
  77         .match          = afs_vlocation_cache_match,
  78         .update         = afs_vlocation_cache_update,
  79 };
  80 #endif
  81
  82 /*
  83  * match a VLDB record stored in the cache
  84  * - may also load target from entry
  85  */
  86 #ifdef AFS_CACHING_SUPPORT
  87 static cachefs_match_val_t afs_vlocation_cache_match(void *target,
  88                                                      const void *entry)
  89 {
  90         const struct afs_cache_vlocation *vldb = entry;
  91         struct afs_vlocation *vlocation = target;
  92
  93         _enter("{%s},{%s}", vlocation->vldb.name, vldb->name);
  94
  95         if (strncmp(vlocation->vldb.name, vldb->name, sizeof(vldb->name)) == 0
  96             ) {
  97                 if (!vlocation->valid ||
  98                     vlocation->vldb.rtime == vldb->rtime
  99                     ) {
 100                         vlocation->vldb = *vldb;
 101                         vlocation->valid = 1;
 102                         _leave(" = SUCCESS [c->m]");
 103                         return CACHEFS_MATCH_SUCCESS;
 104                 } else if (memcmp(&vlocation->vldb, vldb, sizeof(*vldb)) != 0) {
 105                         /* delete if VIDs for this name differ */
 106                         if (memcmp(&vlocation->vldb.vid,
 107                                    &vldb->vid,
 108                                    sizeof(vldb->vid)) != 0) {
 109                                 _leave(" = DELETE");
 110                                 return CACHEFS_MATCH_SUCCESS_DELETE;
 111                         }
 112
 113                         _leave(" = UPDATE");
 114                         return CACHEFS_MATCH_SUCCESS_UPDATE;
 115                 } else {
 116                         _leave(" = SUCCESS");
 117                         return CACHEFS_MATCH_SUCCESS;
 118                 }
 119         }
 120
 121         _leave(" = FAILED");
 122         return CACHEFS_MATCH_FAILED;
 123 }
 124 #endif
 125
 126 /*
 127  * update a VLDB record stored in the cache
 128  */
 129 #ifdef AFS_CACHING_SUPPORT
 130 static void afs_vlocation_cache_update(void *source, void *entry)
 131 {
 132         struct afs_cache_vlocation *vldb = entry;
 133         struct afs_vlocation *vlocation = source;
 134
 135         _enter("");
 136
 137         *vldb = vlocation->vldb;
 138 }
 139 #endif
 140
 141 #ifdef AFS_CACHING_SUPPORT
 142 static cachefs_match_val_t afs_volume_cache_match(void *target,
 143                                                   const void *entry);
 144 static void afs_volume_cache_update(void *source, void *entry);
 145
 146 struct cachefs_index_def afs_volume_cache_index_def = {
 147         .name           = "volume",
 148         .data_size      = sizeof(struct afs_cache_vhash),
 149         .keys[0]        = { CACHEFS_INDEX_KEYS_BIN, 1 },
 150         .keys[1]        = { CACHEFS_INDEX_KEYS_BIN, 1 },
 151         .match          = afs_volume_cache_match,
 152         .update         = afs_volume_cache_update,
 153 };
 154 #endif
 155
 156 /*
 157  * match a volume hash record stored in the cache
 158  */
 159 #ifdef AFS_CACHING_SUPPORT
 160 static cachefs_match_val_t afs_volume_cache_match(void *target,
 161                                                   const void *entry)
 162 {
 163         const struct afs_cache_vhash *vhash = entry;
 164         struct afs_volume *volume = target;
 165
 166         _enter("{%u},{%u}", volume->type, vhash->vtype);
 167
 168         if (volume->type == vhash->vtype) {
 169                 _leave(" = SUCCESS");
 170                 return CACHEFS_MATCH_SUCCESS;
 171         }
 172
 173         _leave(" = FAILED");
 174         return CACHEFS_MATCH_FAILED;
 175 }
 176 #endif
 177
 178 /*
 179  * update a volume hash record stored in the cache
 180  */
 181 #ifdef AFS_CACHING_SUPPORT
 182 static void afs_volume_cache_update(void *source, void *entry)
 183 {
 184         struct afs_cache_vhash *vhash = entry;
 185         struct afs_volume *volume = source;
 186
 187         _enter("");
 188
 189         vhash->vtype = volume->type;
 190 }
 191 #endif
 192
 193 #ifdef AFS_CACHING_SUPPORT
 194 static cachefs_match_val_t afs_vnode_cache_match(void *target,
 195                                                  const void *entry);
 196 static void afs_vnode_cache_update(void *source, void *entry);
 197
 198 struct cachefs_index_def afs_vnode_cache_index_def = {
 199         .name           = "vnode",
 200         .data_size      = sizeof(struct afs_cache_vnode),
 201         .keys[0]        = { CACHEFS_INDEX_KEYS_BIN, 4 },
 202         .match          = afs_vnode_cache_match,
 203         .update         = afs_vnode_cache_update,
 204 };
 205 #endif
 206
 207 /*
 208  * match a vnode record stored in the cache
 209  */
 210 #ifdef AFS_CACHING_SUPPORT
 211 static cachefs_match_val_t afs_vnode_cache_match(void *target,
 212                                                  const void *entry)
 213 {
 214         const struct afs_cache_vnode *cvnode = entry;
 215         struct afs_vnode *vnode = target;
 216
 217         _enter("{%x,%x,%Lx},{%x,%x,%Lx}",
 218                vnode->fid.vnode,
 219                vnode->fid.unique,
 220                vnode->status.version,
 221                cvnode->vnode_id,
 222                cvnode->vnode_unique,
 223                cvnode->data_version);
 224
 225         if (vnode->fid.vnode != cvnode->vnode_id) {
 226                 _leave(" = FAILED");
 227                 return CACHEFS_MATCH_FAILED;
 228         }
 229
 230         if (vnode->fid.unique != cvnode->vnode_unique ||
 231             vnode->status.version != cvnode->data_version) {
 232                 _leave(" = DELETE");
 233                 return CACHEFS_MATCH_SUCCESS_DELETE;
 234         }
 235
 236         _leave(" = SUCCESS");
 237         return CACHEFS_MATCH_SUCCESS;
 238 }
 239 #endif
 240
 241 /*
 242  * update a vnode record stored in the cache
 243  */
 244 #ifdef AFS_CACHING_SUPPORT
 245 static void afs_vnode_cache_update(void *source, void *entry)
 246 {
 247         struct afs_cache_vnode *cvnode = entry;
 248         struct afs_vnode *vnode = source;
 249
 250         _enter("");
 251
 252         cvnode->vnode_id        = vnode->fid.vnode;
 253         cvnode->vnode_unique    = vnode->fid.unique;
 254         cvnode->data_version    = vnode->status.version;
 255 }
 256 #endif