fs/fscache/fsdef.c

   1 /* Filesystem index definition
   2  *
   3  * Copyright (C) 2004-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 #define FSCACHE_DEBUG_LEVEL CACHE
  13 #include <linux/module.h>
  14 #include "internal.h"
  15
  16 static uint16_t fscache_fsdef_netfs_get_key(const void *cookie_netfs_data,
  17                                             void *buffer, uint16_t bufmax);
  18
  19 static uint16_t fscache_fsdef_netfs_get_aux(const void *cookie_netfs_data,
  20                                             void *buffer, uint16_t bufmax);
  21
  22 static
  23 enum fscache_checkaux fscache_fsdef_netfs_check_aux(void *cookie_netfs_data,
  24                                                     const void *data,
  25                                                     uint16_t datalen);
  26
  27 /*
  28  * The root index is owned by FS-Cache itself.
  29  *
  30  * When a netfs requests caching facilities, FS-Cache will, if one doesn't
  31  * already exist, create an entry in the root index with the key being the name
  32  * of the netfs ("AFS" for example), and the auxiliary data holding the index
  33  * structure version supplied by the netfs:
  34  *
  35  *                                   FSDEF
  36  *                                     |
  37  *                               +-----------+
  38  *                               |           |
  39  *                              NFS         AFS
  40  *                             [v=1]       [v=1]
  41  *
  42  * If an entry with the appropriate name does already exist, the version is
  43  * compared.  If the version is different, the entire subtree from that entry
  44  * will be discarded and a new entry created.
  45  *
  46  * The new entry will be an index, and a cookie referring to it will be passed
  47  * to the netfs.  This is then the root handle by which the netfs accesses the
  48  * cache.  It can create whatever objects it likes in that index, including
  49  * further indices.
  50  */
  51 static struct fscache_cookie_def fscache_fsdef_index_def = {
  52         .name           = ".FS-Cache",
  53         .type           = FSCACHE_COOKIE_TYPE_INDEX,
  54 };
  55
  56 struct fscache_cookie fscache_fsdef_index = {
  57         .usage          = ATOMIC_INIT(1),
  58         .n_active       = ATOMIC_INIT(1),
  59         .lock           = __SPIN_LOCK_UNLOCKED(fscache_fsdef_index.lock),
  60         .backing_objects = HLIST_HEAD_INIT,
  61         .def            = &fscache_fsdef_index_def,
  62 };
  63 EXPORT_SYMBOL(fscache_fsdef_index);
  64
  65 /*
  66  * Definition of an entry in the root index.  Each entry is an index, keyed to
  67  * a specific netfs and only applicable to a particular version of the index
  68  * structure used by that netfs.
  69  */
  70 struct fscache_cookie_def fscache_fsdef_netfs_def = {
  71         .name           = "FSDEF.netfs",
  72         .type           = FSCACHE_COOKIE_TYPE_INDEX,
  73         .get_key        = fscache_fsdef_netfs_get_key,
  74         .get_aux        = fscache_fsdef_netfs_get_aux,
  75         .check_aux      = fscache_fsdef_netfs_check_aux,
  76 };
  77
  78 /*
  79  * get the key data for an FSDEF index record - this is the name of the netfs
  80  * for which this entry is created
  81  */
  82 static uint16_t fscache_fsdef_netfs_get_key(const void *cookie_netfs_data,
  83                                             void *buffer, uint16_t bufmax)
  84 {
  85         const struct fscache_netfs *netfs = cookie_netfs_data;
  86         unsigned klen;
  87
  88         _enter("{%s.%u},", netfs->name, netfs->version);
  89
  90         klen = strlen(netfs->name);
  91         if (klen > bufmax)
  92                 return 0;
  93
  94         memcpy(buffer, netfs->name, klen);
  95         return klen;
  96 }
  97
  98 /*
  99  * get the auxiliary data for an FSDEF index record - this is the index
 100  * structure version number of the netfs for which this version is created
 101  */
 102 static uint16_t fscache_fsdef_netfs_get_aux(const void *cookie_netfs_data,
 103                                             void *buffer, uint16_t bufmax)
 104 {
 105         const struct fscache_netfs *netfs = cookie_netfs_data;
 106         unsigned dlen;
 107
 108         _enter("{%s.%u},", netfs->name, netfs->version);
 109
 110         dlen = sizeof(uint32_t);
 111         if (dlen > bufmax)
 112                 return 0;
 113
 114         memcpy(buffer, &netfs->version, dlen);
 115         return dlen;
 116 }
 117
 118 /*
 119  * check that the index structure version number stored in the auxiliary data
 120  * matches the one the netfs gave us
 121  */
 122 static enum fscache_checkaux fscache_fsdef_netfs_check_aux(
 123         void *cookie_netfs_data,
 124         const void *data,
 125         uint16_t datalen)
 126 {
 127         struct fscache_netfs *netfs = cookie_netfs_data;
 128         uint32_t version;
 129
 130         _enter("{%s},,%hu", netfs->name, datalen);
 131
 132         if (datalen != sizeof(version)) {
 133                 _leave(" = OBSOLETE [dl=%d v=%zu]", datalen, sizeof(version));
 134                 return FSCACHE_CHECKAUX_OBSOLETE;
 135         }
 136
 137         memcpy(&version, data, sizeof(version));
 138         if (version != netfs->version) {
 139                 _leave(" = OBSOLETE [ver=%x net=%x]", version, netfs->version);
 140                 return FSCACHE_CHECKAUX_OBSOLETE;
 141         }
 142
 143         _leave(" = OKAY");
 144         return FSCACHE_CHECKAUX_OKAY;
 145 }