fs/orangefs/pvfs2-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 "pvfs2-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_alloc(op_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 115         if (new_op) {
 116                 memset(new_op, 0, sizeof(struct orangefs_kernel_op_s));
 117
 118                 INIT_LIST_HEAD(&new_op->list);
 119                 spin_lock_init(&new_op->lock);
 120                 init_waitqueue_head(&new_op->waitq);
 121
 122                 init_waitqueue_head(&new_op->io_completion_waitq);
 123                 atomic_set(&new_op->aio_ref_count, 0);
 124
 125                 orangefs_op_initialize(new_op);
 126
 127                 /* initialize the op specific tag and upcall credentials */
 128                 spin_lock(&next_tag_value_lock);
 129                 new_op->tag = next_tag_value++;
 130                 if (next_tag_value == 0)
 131                         next_tag_value = 100;
 132                 spin_unlock(&next_tag_value_lock);
 133                 new_op->upcall.type = type;
 134                 new_op->attempts = 0;
 135                 gossip_debug(GOSSIP_CACHE_DEBUG,
 136                              "Alloced OP (%p: %llu %s)\n",
 137                              new_op,
 138                              llu(new_op->tag),
 139                              get_opname_string(new_op));
 140
 141                 new_op->upcall.uid = from_kuid(current_user_ns(),
 142                                                current_fsuid());
 143
 144                 new_op->upcall.gid = from_kgid(current_user_ns(),
 145                                                current_fsgid());
 146         } else {
 147                 gossip_err("op_alloc: kmem_cache_alloc failed!\n");
 148         }
 149         return new_op;
 150 }
 151
 152 void op_release(struct orangefs_kernel_op_s *orangefs_op)
 153 {
 154         if (orangefs_op) {
 155                 gossip_debug(GOSSIP_CACHE_DEBUG,
 156                              "Releasing OP (%p: %llu)\n",
 157                              orangefs_op,
 158                              llu(orangefs_op->tag));
 159                 orangefs_op_initialize(orangefs_op);
 160                 kmem_cache_free(op_cache, orangefs_op);
 161         } else {
 162                 gossip_err("NULL pointer in op_release\n");
 163         }
 164 }
 165
 166 int dev_req_cache_initialize(void)
 167 {
 168         dev_req_cache = kmem_cache_create("orangefs_devreqcache",
 169                                           MAX_ALIGNED_DEV_REQ_DOWNSIZE,
 170                                           0,
 171                                           ORANGEFS_CACHE_CREATE_FLAGS,
 172                                           NULL);
 173
 174         if (!dev_req_cache) {
 175                 gossip_err("Cannot create orangefs_dev_req_cache\n");
 176                 return -ENOMEM;
 177         }
 178         return 0;
 179 }
 180
 181 int dev_req_cache_finalize(void)
 182 {
 183         kmem_cache_destroy(dev_req_cache);
 184         return 0;
 185 }
 186
 187 void *dev_req_alloc(void)
 188 {
 189         void *buffer;
 190
 191         buffer = kmem_cache_alloc(dev_req_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 192         if (buffer == NULL)
 193                 gossip_err("Failed to allocate from dev_req_cache\n");
 194         else
 195                 memset(buffer, 0, sizeof(MAX_ALIGNED_DEV_REQ_DOWNSIZE));
 196         return buffer;
 197 }
 198
 199 void dev_req_release(void *buffer)
 200 {
 201         if (buffer)
 202                 kmem_cache_free(dev_req_cache, buffer);
 203         else
 204                 gossip_err("NULL pointer passed to dev_req_release\n");
 205 }
 206
 207 int kiocb_cache_initialize(void)
 208 {
 209         orangefs_kiocb_cache = kmem_cache_create("orangefs_kiocbcache",
 210                                               sizeof(struct orangefs_kiocb_s),
 211                                               0,
 212                                               ORANGEFS_CACHE_CREATE_FLAGS,
 213                                               NULL);
 214
 215         if (!orangefs_kiocb_cache) {
 216                 gossip_err("Cannot create orangefs_kiocb_cache!\n");
 217                 return -ENOMEM;
 218         }
 219         return 0;
 220 }
 221
 222 int kiocb_cache_finalize(void)
 223 {
 224         kmem_cache_destroy(orangefs_kiocb_cache);
 225         return 0;
 226 }
 227
 228 struct orangefs_kiocb_s *kiocb_alloc(void)
 229 {
 230         struct orangefs_kiocb_s *x = NULL;
 231
 232         x = kmem_cache_alloc(orangefs_kiocb_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 233         if (x == NULL)
 234                 gossip_err("kiocb_alloc: kmem_cache_alloc failed!\n");
 235         else
 236                 memset(x, 0, sizeof(struct orangefs_kiocb_s));
 237         return x;
 238 }
 239
 240 void kiocb_release(struct orangefs_kiocb_s *x)
 241 {
 242         if (x)
 243                 kmem_cache_free(orangefs_kiocb_cache, x);
 244         else
 245                 gossip_err("kiocb_release: kmem_cache_free NULL pointer!\n");
 246 }