Orangefs: clean up slab allocation.

A couple of caches were no longer needed:

 - iov_iter improvements to orangefs_devreq_write_iter eliminated
   the need for the dev_req_cache.

 - removal (months ago) of the old AIO code eliminated the need
   for the kiocb_cache.

Also, deobfuscation of use of GFP_KERNEL when calling kmem_cache_(z)alloc
for remaining caches.

Signed-off-by: Mike Marshall <hubcap@omnibond.com>

4 files changed, 6 insertions, 124 deletions

diff --git a/fs/orangefs/orangefs-cache.c b/fs/orangefs/orangefs-cache.c
index e72ac2083ac0..3b3de91406ca 100644
--- a/fs/orangefs/orangefs-cache.c
+++ b/fs/orangefs/orangefs-cache.c
@@ -16,12 +16,6 @@ static DEFINE_SPINLOCK(next_tag_value_lock);
 /* a cache for orangefs upcall/downcall operations */
 static struct kmem_cache *op_cache;
 
-/* a cache for device (/dev/pvfs2-req) communication */
-static struct kmem_cache *dev_req_cache;
-
-/* a cache for orangefs_kiocb objects (i.e orangefs iocb structures ) */
-static struct kmem_cache *orangefs_kiocb_cache;
-
 int op_cache_initialize(void)
 {
         op_cache = kmem_cache_create("orangefs_op_cache",
@@ -111,7 +105,7 @@ struct orangefs_kernel_op_s *op_alloc(__s32 type)
 {
         struct orangefs_kernel_op_s *new_op = NULL;
 
-        new_op = kmem_cache_zalloc(op_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
+        new_op = kmem_cache_zalloc(op_cache, GFP_KERNEL);
         if (new_op) {
                 INIT_LIST_HEAD(&new_op->list);
                 spin_lock_init(&new_op->lock);
@@ -148,7 +142,7 @@ struct orangefs_kernel_op_s *op_alloc(__s32 type)
                 new_op->upcall.gid = from_kgid(current_user_ns(),
                                                current_fsgid());
         } else {
-                gossip_err("op_alloc: kmem_cache_alloc failed!\n");
+                gossip_err("op_alloc: kmem_cache_zalloc failed!\n");
         }
         return new_op;
 }
@@ -165,85 +159,3 @@ void __op_release(struct orangefs_kernel_op_s *orangefs_op)
                 gossip_err("NULL pointer in op_release\n");
         }
 }
-
-int dev_req_cache_initialize(void)
-{
-        dev_req_cache = kmem_cache_create("orangefs_devreqcache",
-                                          MAX_DEV_REQ_DOWNSIZE,
-                                          0,
-                                          ORANGEFS_CACHE_CREATE_FLAGS,
-                                          NULL);
-
-        if (!dev_req_cache) {
-                gossip_err("Cannot create orangefs_dev_req_cache\n");
-                return -ENOMEM;
-        }
-        return 0;
-}
-
-int dev_req_cache_finalize(void)
-{
-        kmem_cache_destroy(dev_req_cache);
-        return 0;
-}
-
-void *dev_req_alloc(void)
-{
-        void *buffer;
-
-        buffer = kmem_cache_alloc(dev_req_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
-        if (buffer == NULL)
-                gossip_err("Failed to allocate from dev_req_cache\n");
-        else
-                memset(buffer, 0, sizeof(MAX_DEV_REQ_DOWNSIZE));
-        return buffer;
-}
-
-void dev_req_release(void *buffer)
-{
-        if (buffer)
-                kmem_cache_free(dev_req_cache, buffer);
-        else
-                gossip_err("NULL pointer passed to dev_req_release\n");
-}
-
-int kiocb_cache_initialize(void)
-{
-        orangefs_kiocb_cache = kmem_cache_create("orangefs_kiocbcache",
-                                              sizeof(struct orangefs_kiocb_s),
-                                              0,
-                                              ORANGEFS_CACHE_CREATE_FLAGS,
-                                              NULL);
-
-        if (!orangefs_kiocb_cache) {
-                gossip_err("Cannot create orangefs_kiocb_cache!\n");
-                return -ENOMEM;
-        }
-        return 0;
-}
-
-int kiocb_cache_finalize(void)
-{
-        kmem_cache_destroy(orangefs_kiocb_cache);
-        return 0;
-}
-
-struct orangefs_kiocb_s *kiocb_alloc(void)
-{
-        struct orangefs_kiocb_s *x = NULL;
-
-        x = kmem_cache_alloc(orangefs_kiocb_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
-        if (x == NULL)
-                gossip_err("kiocb_alloc: kmem_cache_alloc failed!\n");
-        else
-                memset(x, 0, sizeof(struct orangefs_kiocb_s));
-        return x;
-}
-
-void kiocb_release(struct orangefs_kiocb_s *x)
-{
-        if (x)
-                kmem_cache_free(orangefs_kiocb_cache, x);
-        else
-                gossip_err("kiocb_release: kmem_cache_free NULL pointer!\n");
-}
diff --git a/fs/orangefs/orangefs-kernel.h b/fs/orangefs/orangefs-kernel.h
index 3e258554688d..d4db96223dac 100644
--- a/fs/orangefs/orangefs-kernel.h
+++ b/fs/orangefs/orangefs-kernel.h
@@ -128,7 +128,6 @@ struct client_debug_mask {
 #define ORANGEFS_CACHE_CREATE_FLAGS 0
 #endif /* ((defined ORANGEFS_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) */
 
-#define ORANGEFS_CACHE_ALLOC_FLAGS (GFP_KERNEL)
 #define ORANGEFS_GFP_FLAGS (GFP_KERNEL)
 #define ORANGEFS_BUFMAP_GFP_FLAGS (GFP_KERNEL)
 
@@ -207,9 +206,6 @@ struct orangefs_kernel_op_s {
 
         /* VFS aio fields */
 
-        /* used by the async I/O code to stash the orangefs_kiocb_s structure */
-        void *priv;
-
         int attempts;
 
         struct list_head list;
@@ -217,6 +213,7 @@ struct orangefs_kernel_op_s {
 
 #define set_op_state_waiting(op)     ((op)->op_state = OP_VFS_STATE_WAITING)
 #define set_op_state_inprogress(op)  ((op)->op_state = OP_VFS_STATE_INPROGR)
+#define set_op_state_given_up(op)  ((op)->op_state = OP_VFS_STATE_GIVEN_UP)
 static inline void set_op_state_serviced(struct orangefs_kernel_op_s *op)
 {
         op->op_state = OP_VFS_STATE_SERVICED;
@@ -453,19 +450,9 @@ int op_cache_finalize(void);
 struct orangefs_kernel_op_s *op_alloc(__s32 type);
 char *get_opname_string(struct orangefs_kernel_op_s *new_op);
 
-int dev_req_cache_initialize(void);
-int dev_req_cache_finalize(void);
-void *dev_req_alloc(void);
-void dev_req_release(void *);
-
 int orangefs_inode_cache_initialize(void);
 int orangefs_inode_cache_finalize(void);
 
-int kiocb_cache_initialize(void);
-int kiocb_cache_finalize(void);
-struct orangefs_kiocb_s *kiocb_alloc(void);
-void kiocb_release(struct orangefs_kiocb_s *ptr);
-
 /*
  * defined in orangefs-mod.c
  */
diff --git a/fs/orangefs/orangefs-mod.c b/fs/orangefs/orangefs-mod.c
index e07874e26372..7639ab2df711 100644
--- a/fs/orangefs/orangefs-mod.c
+++ b/fs/orangefs/orangefs-mod.c
@@ -140,24 +140,16 @@ static int __init orangefs_init(void)
         if (ret < 0)
                 goto err;
 
-        ret = dev_req_cache_initialize();
-        if (ret < 0)
-                goto cleanup_op;
-
         ret = orangefs_inode_cache_initialize();
         if (ret < 0)
-                goto cleanup_req;
-
-        ret = kiocb_cache_initialize();
-        if (ret  < 0)
-                goto cleanup_inode;
+                goto cleanup_op;
 
         /* Initialize the orangefsdev subsystem. */
         ret = orangefs_dev_init();
         if (ret < 0) {
                 gossip_err("orangefs: could not initialize device subsystem %d!\n",
                            ret);
-                goto cleanup_kiocb;
+                goto cleanup_inode;
         }
 
         htable_ops_in_progress =
@@ -214,15 +206,9 @@ cleanup_progress_table:
 cleanup_device:
         orangefs_dev_cleanup();
 
-cleanup_kiocb:
-        kiocb_cache_finalize();
-
 cleanup_inode:
         orangefs_inode_cache_finalize();
 
-cleanup_req:
-        dev_req_cache_finalize();
-
 cleanup_op:
         op_cache_finalize();
 
@@ -247,9 +233,7 @@ static void __exit orangefs_exit(void)
         for (i = 0; i < hash_table_size; i++)
                 BUG_ON(!list_empty(&htable_ops_in_progress[i]));
 
-        kiocb_cache_finalize();
         orangefs_inode_cache_finalize();
-        dev_req_cache_finalize();
         op_cache_finalize();
 
         kfree(htable_ops_in_progress);
diff --git a/fs/orangefs/super.c b/fs/orangefs/super.c
index a32981239ea6..93cc352be360 100644
--- a/fs/orangefs/super.c
+++ b/fs/orangefs/super.c
@@ -92,8 +92,7 @@ static struct inode *orangefs_alloc_inode(struct super_block *sb)
 {
         struct orangefs_inode_s *orangefs_inode;
 
-        orangefs_inode = kmem_cache_alloc(orangefs_inode_cache,
-                                       ORANGEFS_CACHE_ALLOC_FLAGS);
+        orangefs_inode = kmem_cache_alloc(orangefs_inode_cache, GFP_KERNEL);
         if (orangefs_inode == NULL) {
                 gossip_err("Failed to allocate orangefs_inode\n");
                 return NULL;