fs/orangefs/orangefs-cache.c

   1 /*
   2  * (C) 2001 Clemson University and The University of Chicago
   3  *
   4  * See COPYING in top-level directory.
   5  */
   6
   7 #include "protocol.h"
   8 #include "orangefs-kernel.h"
   9
  10 /* tags assigned to kernel upcall operations */
  11 static __u64 next_tag_value;
  12 static DEFINE_SPINLOCK(next_tag_value_lock);
  13
  14 /* the orangefs memory caches */
  15
  16 /* a cache for orangefs upcall/downcall operations */
  17 static struct kmem_cache *op_cache;
  18
  19 /* a cache for device (/dev/pvfs2-req) communication */
  20 static struct kmem_cache *dev_req_cache;
  21
  22 /* a cache for orangefs_kiocb objects (i.e orangefs iocb structures ) */
  23 static struct kmem_cache *orangefs_kiocb_cache;
  24
  25 int op_cache_initialize(void)
  26 {
  27         op_cache = kmem_cache_create("orangefs_op_cache",
  28                                      sizeof(struct orangefs_kernel_op_s),
  29                                      0,
  30                                      ORANGEFS_CACHE_CREATE_FLAGS,
  31                                      NULL);
  32
  33         if (!op_cache) {
  34                 gossip_err("Cannot create orangefs_op_cache\n");
  35                 return -ENOMEM;
  36         }
  37
  38         /* initialize our atomic tag counter */
  39         spin_lock(&next_tag_value_lock);
  40         next_tag_value = 100;
  41         spin_unlock(&next_tag_value_lock);
  42         return 0;
  43 }
  44
  45 int op_cache_finalize(void)
  46 {
  47         kmem_cache_destroy(op_cache);
  48         return 0;
  49 }
  50
  51 char *get_opname_string(struct orangefs_kernel_op_s *new_op)
  52 {
  53         if (new_op) {
  54                 __s32 type = new_op->upcall.type;
  55
  56                 if (type == ORANGEFS_VFS_OP_FILE_IO)
  57                         return "OP_FILE_IO";
  58                 else if (type == ORANGEFS_VFS_OP_LOOKUP)
  59                         return "OP_LOOKUP";
  60                 else if (type == ORANGEFS_VFS_OP_CREATE)
  61                         return "OP_CREATE";
  62                 else if (type == ORANGEFS_VFS_OP_GETATTR)
  63                         return "OP_GETATTR";
  64                 else if (type == ORANGEFS_VFS_OP_REMOVE)
  65                         return "OP_REMOVE";
  66                 else if (type == ORANGEFS_VFS_OP_MKDIR)
  67                         return "OP_MKDIR";
  68                 else if (type == ORANGEFS_VFS_OP_READDIR)
  69                         return "OP_READDIR";
  70                 else if (type == ORANGEFS_VFS_OP_READDIRPLUS)
  71                         return "OP_READDIRPLUS";
  72                 else if (type == ORANGEFS_VFS_OP_SETATTR)
  73                         return "OP_SETATTR";
  74                 else if (type == ORANGEFS_VFS_OP_SYMLINK)
  75                         return "OP_SYMLINK";
  76                 else if (type == ORANGEFS_VFS_OP_RENAME)
  77                         return "OP_RENAME";
  78                 else if (type == ORANGEFS_VFS_OP_STATFS)
  79                         return "OP_STATFS";
  80                 else if (type == ORANGEFS_VFS_OP_TRUNCATE)
  81                         return "OP_TRUNCATE";
  82                 else if (type == ORANGEFS_VFS_OP_MMAP_RA_FLUSH)
  83                         return "OP_MMAP_RA_FLUSH";
  84                 else if (type == ORANGEFS_VFS_OP_FS_MOUNT)
  85                         return "OP_FS_MOUNT";
  86                 else if (type == ORANGEFS_VFS_OP_FS_UMOUNT)
  87                         return "OP_FS_UMOUNT";
  88                 else if (type == ORANGEFS_VFS_OP_GETXATTR)
  89                         return "OP_GETXATTR";
  90                 else if (type == ORANGEFS_VFS_OP_SETXATTR)
  91                         return "OP_SETXATTR";
  92                 else if (type == ORANGEFS_VFS_OP_LISTXATTR)
  93                         return "OP_LISTXATTR";
  94                 else if (type == ORANGEFS_VFS_OP_REMOVEXATTR)
  95                         return "OP_REMOVEXATTR";
  96                 else if (type == ORANGEFS_VFS_OP_PARAM)
  97                         return "OP_PARAM";
  98                 else if (type == ORANGEFS_VFS_OP_PERF_COUNT)
  99                         return "OP_PERF_COUNT";
 100                 else if (type == ORANGEFS_VFS_OP_CANCEL)
 101                         return "OP_CANCEL";
 102                 else if (type == ORANGEFS_VFS_OP_FSYNC)
 103                         return "OP_FSYNC";
 104                 else if (type == ORANGEFS_VFS_OP_FSKEY)
 105                         return "OP_FSKEY";
 106         }
 107         return "OP_UNKNOWN?";
 108 }
 109
 110 struct orangefs_kernel_op_s *op_alloc(__s32 type)
 111 {
 112         struct orangefs_kernel_op_s *new_op = NULL;
 113
 114         new_op = kmem_cache_zalloc(op_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 115         if (new_op) {
 116                 INIT_LIST_HEAD(&new_op->list);
 117                 spin_lock_init(&new_op->lock);
 118                 init_waitqueue_head(&new_op->waitq);
 119
 120                 atomic_set(&new_op->ref_count, 1);
 121
 122                 init_completion(&new_op->done);
 123
 124                 new_op->upcall.type = ORANGEFS_VFS_OP_INVALID;
 125                 new_op->downcall.type = ORANGEFS_VFS_OP_INVALID;
 126                 new_op->downcall.status = -1;
 127
 128                 new_op->op_state = OP_VFS_STATE_UNKNOWN;
 129                 new_op->tag = 0;
 130
 131                 /* initialize the op specific tag and upcall credentials */
 132                 spin_lock(&next_tag_value_lock);
 133                 new_op->tag = next_tag_value++;
 134                 if (next_tag_value == 0)
 135                         next_tag_value = 100;
 136                 spin_unlock(&next_tag_value_lock);
 137                 new_op->upcall.type = type;
 138                 new_op->attempts = 0;
 139                 gossip_debug(GOSSIP_CACHE_DEBUG,
 140                              "Alloced OP (%p: %llu %s)\n",
 141                              new_op,
 142                              llu(new_op->tag),
 143                              get_opname_string(new_op));
 144
 145                 new_op->upcall.uid = from_kuid(current_user_ns(),
 146                                                current_fsuid());
 147
 148                 new_op->upcall.gid = from_kgid(current_user_ns(),
 149                                                current_fsgid());
 150         } else {
 151                 gossip_err("op_alloc: kmem_cache_alloc failed!\n");
 152         }
 153         return new_op;
 154 }
 155
 156 void __op_release(struct orangefs_kernel_op_s *orangefs_op)
 157 {
 158         if (orangefs_op) {
 159                 gossip_debug(GOSSIP_CACHE_DEBUG,
 160                              "Releasing OP (%p: %llu)\n",
 161                              orangefs_op,
 162                              llu(orangefs_op->tag));
 163                 kmem_cache_free(op_cache, orangefs_op);
 164         } else {
 165                 gossip_err("NULL pointer in op_release\n");
 166         }
 167 }
 168
 169 int dev_req_cache_initialize(void)
 170 {
 171         dev_req_cache = kmem_cache_create("orangefs_devreqcache",
 172                                           MAX_DEV_REQ_DOWNSIZE,
 173                                           0,
 174                                           ORANGEFS_CACHE_CREATE_FLAGS,
 175                                           NULL);
 176
 177         if (!dev_req_cache) {
 178                 gossip_err("Cannot create orangefs_dev_req_cache\n");
 179                 return -ENOMEM;
 180         }
 181         return 0;
 182 }
 183
 184 int dev_req_cache_finalize(void)
 185 {
 186         kmem_cache_destroy(dev_req_cache);
 187         return 0;
 188 }
 189
 190 void *dev_req_alloc(void)
 191 {
 192         void *buffer;
 193
 194         buffer = kmem_cache_alloc(dev_req_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 195         if (buffer == NULL)
 196                 gossip_err("Failed to allocate from dev_req_cache\n");
 197         else
 198                 memset(buffer, 0, sizeof(MAX_DEV_REQ_DOWNSIZE));
 199         return buffer;
 200 }
 201
 202 void dev_req_release(void *buffer)
 203 {
 204         if (buffer)
 205                 kmem_cache_free(dev_req_cache, buffer);
 206         else
 207                 gossip_err("NULL pointer passed to dev_req_release\n");
 208 }
 209
 210 int kiocb_cache_initialize(void)
 211 {
 212         orangefs_kiocb_cache = kmem_cache_create("orangefs_kiocbcache",
 213                                               sizeof(struct orangefs_kiocb_s),
 214                                               0,
 215                                               ORANGEFS_CACHE_CREATE_FLAGS,
 216                                               NULL);
 217
 218         if (!orangefs_kiocb_cache) {
 219                 gossip_err("Cannot create orangefs_kiocb_cache!\n");
 220                 return -ENOMEM;
 221         }
 222         return 0;
 223 }
 224
 225 int kiocb_cache_finalize(void)
 226 {
 227         kmem_cache_destroy(orangefs_kiocb_cache);
 228         return 0;
 229 }
 230
 231 struct orangefs_kiocb_s *kiocb_alloc(void)
 232 {
 233         struct orangefs_kiocb_s *x = NULL;
 234
 235         x = kmem_cache_alloc(orangefs_kiocb_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 236         if (x == NULL)
 237                 gossip_err("kiocb_alloc: kmem_cache_alloc failed!\n");
 238         else
 239                 memset(x, 0, sizeof(struct orangefs_kiocb_s));
 240         return x;
 241 }
 242
 243 void kiocb_release(struct orangefs_kiocb_s *x)
 244 {
 245         if (x)
 246                 kmem_cache_free(orangefs_kiocb_cache, x);
 247         else
 248                 gossip_err("kiocb_release: kmem_cache_free NULL pointer!\n");
 249 }