Initial pass at a file API getf/releasef hooks

git-svn-id: https://outreach.scidac.gov/svn/spl/trunk@50 7e1ea52c-4ff2-0310-8f11-9dd32ca42a1c

modules/spl/Makefile.in

@@ -17,6 +17,7 @@ spl-objs += spl-vnode.o
 spl-objs += spl-err.o
 spl-objs += spl-time.o
 spl-objs += spl-kobj.o
+spl-objs += spl-file.o
 spl-objs += spl-generic.o
 
 splmodule := spl.ko

modules/spl/spl-file.c

@@ -0,0 +1,169 @@
+#include <sys/sysmacros.h>
+#include <sys/file.h>
+#include "config.h"
+
+/* File interface */
+
+static spinlock_t file_lock = SPIN_LOCK_UNLOCKED;
+static LIST_HEAD(file_list);
+static kmem_cache_t *file_cache;
+
+/* Function must be called while holding the file_lock */
+static file_t *
+file_find(int fd)
+{
+        file_t *fp;
+
+	BUG_ON(!spin_is_locked(&file_lock));
+
+        list_for_each_entry(fp, &file_list,  f_list) {
+		if (fd == fp->f_fd) {
+			BUG_ON(atomic_read(&fp->f_ref) == 0);
+                        return fp;
+		}
+	}
+
+        return NULL;
+} /* file_find() */
+
+file_t *
+getf(int fd)
+{
+	file_t *fp;
+
+	/* Already open just take an extra reference */
+	spin_lock(&file_lock);
+
+	fp = file_find(fd);
+	if (fp) {
+		atomic_inc(&fp->f_ref);
+		spin_unlock(&file_lock);
+		return fp;
+	}
+
+	spin_unlock(&file_lock);
+
+	/* File was not yet opened via the SPL layer create needed bits */
+	fp = kmem_cache_alloc(file_cache, 0);
+	if (fp == NULL)
+		goto out;
+
+	mutex_enter(&fp->f_lock);
+
+	fp->f_vnode = vn_alloc(KM_SLEEP);
+	if (fp->f_vnode == NULL)
+		goto out_mutex;
+
+	/* XXX: Setup needed vnode stop, open file etc */
+
+	fp->f_file = fget(fd);
+	if (fp->f_file == NULL)
+		goto out_vnode;
+
+	fp->f_fd = fd;
+	atomic_inc(&fp->f_ref);
+
+	spin_lock(&file_lock);
+	list_add(&fp->f_list, &file_list);
+	spin_unlock(&file_lock);
+
+	mutex_exit(&fp->f_lock);
+	return fp;
+
+out_vnode:
+	vn_free(fp->f_vnode);
+out_mutex:
+	mutex_exit(&fp->f_lock);
+	kmem_cache_free(file_cache, fp);
+out:
+        return NULL;
+} /* getf() */
+EXPORT_SYMBOL(getf);
+
+static void releasef_locked(file_t *fp)
+{
+	BUG_ON(fp->f_file == NULL);
+	BUG_ON(fp->f_vnode == NULL);
+
+	/* Unlinked from list, no refs, safe to free outside mutex */
+	fput(fp->f_file);
+	vn_free(fp->f_vnode);
+
+	kmem_cache_free(file_cache, fp);
+}
+
+void
+releasef(int fd)
+{
+	file_t *fp;
+
+	spin_lock(&file_lock);
+
+	fp = file_find(fd);
+	if (fp) {
+		atomic_dec(&fp->f_ref);
+
+		if (atomic_read(&fp->f_ref) > 0) {
+			spin_unlock(&file_lock);
+			return;
+		}
+
+	        list_del(&fp->f_list);
+		spin_unlock(&file_lock);
+		releasef_locked(fp);
+	}
+
+	return;
+} /* releasef() */
+EXPORT_SYMBOL(releasef);
+
+static int
+file_cache_constructor(void *buf, void *cdrarg, int kmflags)
+{
+	file_t *fp = buf;
+
+	atomic_set(&fp->f_ref, 0);
+        mutex_init(&fp->f_lock, NULL, MUTEX_DEFAULT, NULL);
+
+        return (0);
+} /* file_cache_constructor() */
+
+static void
+file_cache_destructor(void *buf, void *cdrarg)
+{
+	file_t *fp = buf;
+
+	mutex_destroy(&fp->f_lock);
+} /* file_cache_destructor() */
+
+int
+file_init(void)
+{
+	file_cache = kmem_cache_create("spl_file_cache", sizeof(file_t), 64,
+				       file_cache_constructor,
+				       file_cache_destructor,
+				       NULL, NULL, NULL, 0);
+	return 0;
+} /* file_init() */
+
+void file_fini(void)
+{
+        file_t *fp, *next_fp;
+	int leaked = 0;
+
+	spin_lock(&file_lock);
+
+        list_for_each_entry_safe(fp, next_fp, &file_list,  f_list) {
+	        list_del(&fp->f_list);
+		releasef_locked(fp);
+		leaked++;
+	}
+
+	kmem_cache_destroy(file_cache);
+	file_cache = NULL;
+	spin_unlock(&file_lock);
+
+	if (leaked > 0)
+		printk("Warning: %d files leaked\n", leaked);
+
+} /* file_fini() */

modules/spl/spl-generic.c

@@ -1,6 +1,7 @@
 #include <sys/sysmacros.h>
 #include <sys/vmsystm.h>
 #include <sys/vnode.h>
+#include <sys/file.h>
 #include <sys/kmem.h>
 #include "config.h"
 
@@ -60,35 +61,27 @@ static int __init spl_init(void)
 {
 	int rc;
 
-	rc = vn_init();
-	if (rc)
+	if ((rc = vn_init()))
+		return rc;
+
+	if ((rc = file_init()))
+		return rc;
+
+	if ((rc = kmem_init()))
 		return rc;
 
 	strcpy(hw_serial, "007f0100"); /* loopback */
         printk(KERN_INFO "spl: Loaded Solaris Porting Layer v%s\n", VERSION);
 
-#ifdef DEBUG_KMEM
-	atomic64_set(&kmem_alloc_used, 0);
-	atomic64_set(&vmem_alloc_used, 0);
-#endif
-
 	return 0;
 }
 
 static void spl_fini(void)
 {
+	kmem_fini();
+	file_fini();
 	vn_fini();
 
-#ifdef DEBUG_KMEM
-	if (atomic64_read(&kmem_alloc_used) != 0)
-		printk("Warning: kmem leaked %ld/%ld bytes\n",
-                       atomic_read(&kmem_alloc_used), kmem_alloc_max);
-
-	if (atomic64_read(&vmem_alloc_used) != 0)
-		printk("Warning: vmem leaked %ld/%ld bytes\n",
-                       atomic_read(&vmem_alloc_used), vmem_alloc_max);
-#endif
-
 	return;
 }
 

modules/spl/spl-kmem.c

@@ -272,3 +272,27 @@ __kmem_reap(void) {
 	kmem_cache_generic_shrinker(KMC_REAP_CHUNK, GFP_KERNEL);
 }
 EXPORT_SYMBOL(__kmem_reap);
+
+int
+kmem_init(void)
+{
+#ifdef DEBUG_KMEM
+	atomic64_set(&kmem_alloc_used, 0);
+	atomic64_set(&vmem_alloc_used, 0);
+#endif
+	return 0;
+}
+
+void
+kmem_fini(void)
+{
+#ifdef DEBUG_KMEM
+        if (atomic64_read(&kmem_alloc_used) != 0)
+                printk("Warning: kmem leaked %ld/%ld bytes\n",
+                       atomic_read(&kmem_alloc_used), kmem_alloc_max);
+
+        if (atomic64_read(&vmem_alloc_used) != 0)
+                printk("Warning: vmem leaked %ld/%ld bytes\n",
+                       atomic_read(&vmem_alloc_used), vmem_alloc_max);
+#endif
+}

modules/spl/spl-vnode.c

@@ -43,7 +43,6 @@ vn_alloc(int flag)
 	vnode_t *vp;
 
 	vp = kmem_cache_alloc(vn_cache, flag);
-
 	if (vp != NULL) {
 		vp->v_fp = NULL;
 		vp->v_type = 0;
@@ -411,8 +410,9 @@ vn_cache_destructor(void *buf, void *cdrarg)
 int
 vn_init(void)
 {
-	vn_cache = kmem_cache_create("vn_cache", sizeof(struct vnode), 64,
-	                             vn_cache_constructor, vn_cache_destructor,
+	vn_cache = kmem_cache_create("spl_vn_cache", sizeof(struct vnode), 64,
+	                             vn_cache_constructor,
+				     vn_cache_destructor,
 				     NULL, NULL, NULL, 0);
 	return 0;
 } /* vn_init() */