Merge remote-tracking branch 'orangefs/for-next'

[karo-tx-linux.git] / fs / orangefs / orangefs-cache.c

diff --git a/fs/orangefs/orangefs-cache.c b/fs/orangefs/orangefs-cache.c
new file mode 100644 (file)
index 0000000..3b3de91
--- /dev/null
+++ b/fs/orangefs/orangefs-cache.c
@@ -0,0 +1,161 @@
+/*
+ * (C) 2001 Clemson University and The University of Chicago
+ *
+ * See COPYING in top-level directory.
+ */
+
+#include "protocol.h"
+#include "orangefs-kernel.h"
+
+/* tags assigned to kernel upcall operations */
+static __u64 next_tag_value;
+static DEFINE_SPINLOCK(next_tag_value_lock);
+
+/* the orangefs memory caches */
+
+/* a cache for orangefs upcall/downcall operations */
+static struct kmem_cache *op_cache;
+
+int op_cache_initialize(void)
+{
+       op_cache = kmem_cache_create("orangefs_op_cache",
+                                    sizeof(struct orangefs_kernel_op_s),
+                                    0,
+                                    ORANGEFS_CACHE_CREATE_FLAGS,
+                                    NULL);
+
+       if (!op_cache) {
+               gossip_err("Cannot create orangefs_op_cache\n");
+               return -ENOMEM;
+       }
+
+       /* initialize our atomic tag counter */
+       spin_lock(&next_tag_value_lock);
+       next_tag_value = 100;
+       spin_unlock(&next_tag_value_lock);
+       return 0;
+}
+
+int op_cache_finalize(void)
+{
+       kmem_cache_destroy(op_cache);
+       return 0;
+}
+
+char *get_opname_string(struct orangefs_kernel_op_s *new_op)
+{
+       if (new_op) {
+               __s32 type = new_op->upcall.type;
+
+               if (type == ORANGEFS_VFS_OP_FILE_IO)
+                       return "OP_FILE_IO";
+               else if (type == ORANGEFS_VFS_OP_LOOKUP)
+                       return "OP_LOOKUP";
+               else if (type == ORANGEFS_VFS_OP_CREATE)
+                       return "OP_CREATE";
+               else if (type == ORANGEFS_VFS_OP_GETATTR)
+                       return "OP_GETATTR";
+               else if (type == ORANGEFS_VFS_OP_REMOVE)
+                       return "OP_REMOVE";
+               else if (type == ORANGEFS_VFS_OP_MKDIR)
+                       return "OP_MKDIR";
+               else if (type == ORANGEFS_VFS_OP_READDIR)
+                       return "OP_READDIR";
+               else if (type == ORANGEFS_VFS_OP_READDIRPLUS)
+                       return "OP_READDIRPLUS";
+               else if (type == ORANGEFS_VFS_OP_SETATTR)
+                       return "OP_SETATTR";
+               else if (type == ORANGEFS_VFS_OP_SYMLINK)
+                       return "OP_SYMLINK";
+               else if (type == ORANGEFS_VFS_OP_RENAME)
+                       return "OP_RENAME";
+               else if (type == ORANGEFS_VFS_OP_STATFS)
+                       return "OP_STATFS";
+               else if (type == ORANGEFS_VFS_OP_TRUNCATE)
+                       return "OP_TRUNCATE";
+               else if (type == ORANGEFS_VFS_OP_MMAP_RA_FLUSH)
+                       return "OP_MMAP_RA_FLUSH";
+               else if (type == ORANGEFS_VFS_OP_FS_MOUNT)
+                       return "OP_FS_MOUNT";
+               else if (type == ORANGEFS_VFS_OP_FS_UMOUNT)
+                       return "OP_FS_UMOUNT";
+               else if (type == ORANGEFS_VFS_OP_GETXATTR)
+                       return "OP_GETXATTR";
+               else if (type == ORANGEFS_VFS_OP_SETXATTR)
+                       return "OP_SETXATTR";
+               else if (type == ORANGEFS_VFS_OP_LISTXATTR)
+                       return "OP_LISTXATTR";
+               else if (type == ORANGEFS_VFS_OP_REMOVEXATTR)
+                       return "OP_REMOVEXATTR";
+               else if (type == ORANGEFS_VFS_OP_PARAM)
+                       return "OP_PARAM";
+               else if (type == ORANGEFS_VFS_OP_PERF_COUNT)
+                       return "OP_PERF_COUNT";
+               else if (type == ORANGEFS_VFS_OP_CANCEL)
+                       return "OP_CANCEL";
+               else if (type == ORANGEFS_VFS_OP_FSYNC)
+                       return "OP_FSYNC";
+               else if (type == ORANGEFS_VFS_OP_FSKEY)
+                       return "OP_FSKEY";
+       }
+       return "OP_UNKNOWN?";
+}
+
+struct orangefs_kernel_op_s *op_alloc(__s32 type)
+{
+       struct orangefs_kernel_op_s *new_op = NULL;
+
+       new_op = kmem_cache_zalloc(op_cache, GFP_KERNEL);
+       if (new_op) {
+               INIT_LIST_HEAD(&new_op->list);
+               spin_lock_init(&new_op->lock);
+               init_waitqueue_head(&new_op->waitq);
+
+               atomic_set(&new_op->ref_count, 1);
+
+               init_completion(&new_op->done);
+
+               new_op->upcall.type = ORANGEFS_VFS_OP_INVALID;
+               new_op->downcall.type = ORANGEFS_VFS_OP_INVALID;
+               new_op->downcall.status = -1;
+
+               new_op->op_state = OP_VFS_STATE_UNKNOWN;
+               new_op->tag = 0;
+
+               /* initialize the op specific tag and upcall credentials */
+               spin_lock(&next_tag_value_lock);
+               new_op->tag = next_tag_value++;
+               if (next_tag_value == 0)
+                       next_tag_value = 100;
+               spin_unlock(&next_tag_value_lock);
+               new_op->upcall.type = type;
+               new_op->attempts = 0;
+               gossip_debug(GOSSIP_CACHE_DEBUG,
+                            "Alloced OP (%p: %llu %s)\n",
+                            new_op,
+                            llu(new_op->tag),
+                            get_opname_string(new_op));
+
+               new_op->upcall.uid = from_kuid(current_user_ns(),
+                                              current_fsuid());
+
+               new_op->upcall.gid = from_kgid(current_user_ns(),
+                                              current_fsgid());
+       } else {
+               gossip_err("op_alloc: kmem_cache_zalloc failed!\n");
+       }
+       return new_op;
+}
+
+void __op_release(struct orangefs_kernel_op_s *orangefs_op)
+{
+       if (orangefs_op) {
+               gossip_debug(GOSSIP_CACHE_DEBUG,
+                            "Releasing OP (%p: %llu)\n",
+                            orangefs_op,
+                            llu(orangefs_op->tag));
+               kmem_cache_free(op_cache, orangefs_op);
+       } else {
+               gossip_err("NULL pointer in op_release\n");
+       }
+}