Changes in uspace/srv/vfs/vfs_file.c [553492be:4fe94c66] in mainline

File:

• uspace/srv/vfs/vfs_file.c (modified) (5 diffs)

uspace/srv/vfs/vfs_file.c

@@ -38 +38 @@
 #include <errno.h>
 #include <stdlib.h>
-#include <string.h>
+#include <str.h>
 #include <assert.h>
 #include <bool.h>
 #include <fibril.h>
-#include <fibril_sync.h>
+#include <fibril_synch.h>
 #include "vfs.h"
 
-/**
- * This is a per-connection table of open files.
- * Our assumption is that each client opens only one connection and therefore
- * there is one table of open files per task. However, this may not be the case
- * and the client can open more connections to VFS. In that case, there will be
- * several tables and several file handle name spaces per task. Besides of this,
- * the functionality will stay unchanged. So unless the client knows what it is
- * doing, it should open one connection to VFS only.
- *
- * Allocation of the open files table is deferred until the client makes the
- * first VFS_OPEN operation.
- *
- * This resource being per-connection and, in the first place, per-fibril, we
- * don't need to protect it by a mutex.
- */
-fibril_local vfs_file_t **files = NULL;
+#define VFS_DATA        ((vfs_client_data_t *) async_client_data_get())
+#define FILES           (VFS_DATA->files)
+
+typedef struct {
+        fibril_mutex_t lock;
+        vfs_file_t **files;
+} vfs_client_data_t;
 
 /** Initialize the table of open files. */
-bool vfs_files_init(void)
-{
-        if (!files) {
-                files = malloc(MAX_OPEN_FILES * sizeof(vfs_file_t *));
-                if (!files)
+static bool vfs_files_init(void)
+{
+        fibril_mutex_lock(&VFS_DATA->lock);
+        if (!FILES) {
+                FILES = malloc(MAX_OPEN_FILES * sizeof(vfs_file_t *));
+                if (!FILES) {
+                        fibril_mutex_unlock(&VFS_DATA->lock);
                         return false;
-                memset(files, 0, MAX_OPEN_FILES * sizeof(vfs_file_t *));
-        }
+                }
+                memset(FILES, 0, MAX_OPEN_FILES * sizeof(vfs_file_t *));
+        }
+        fibril_mutex_unlock(&VFS_DATA->lock);
         return true;
 }
 
-/** Allocate a file descriptor.
- *
- * @return              First available file descriptor or a negative error
- *                      code.
- */
-int vfs_fd_alloc(void)
-{
-        if (!vfs_files_init())
-                return ENOMEM;
-        
-        unsigned int i;
+/** Cleanup the table of open files. */
+static void vfs_files_done(void)
+{
+        int i;
+
+        if (!FILES)
+                return;
+
         for (i = 0; i < MAX_OPEN_FILES; i++) {
-                if (!files[i]) {
-                        files[i] = (vfs_file_t *) malloc(sizeof(vfs_file_t));
-                        if (!files[i])
-                                return ENOMEM;
-                        
-                        memset(files[i], 0, sizeof(vfs_file_t));
-                        fibril_mutex_initialize(&files[i]->lock);
-                        vfs_file_addref(files[i]);
-                        return (int) i;
-                }
-        }
-        
-        return EMFILE;
-}
-
-/** Release file descriptor.
- *
- * @param fd            File descriptor being released.
- *
- * @return              EOK on success or EBADF if fd is an invalid file
- *                      descriptor.
- */
-int vfs_fd_free(int fd)
-{
-        if (!vfs_files_init())
-                return ENOMEM;
-        
-        if ((fd < 0) || (fd >= MAX_OPEN_FILES) || (files[fd] == NULL))
-                return EBADF;
-        
-        vfs_file_delref(files[fd]);
-        files[fd] = NULL;
-        
-        return EOK;
+                if (FILES[i]) {
+                        (void) vfs_close_internal(FILES[i]);
+                        (void) vfs_fd_free(i);
+                }
+        }
+        
+        free(FILES);
+}
+
+void *vfs_client_data_create(void)
+{
+        vfs_client_data_t *vfs_data;
+
+        vfs_data = malloc(sizeof(vfs_client_data_t));
+        if (vfs_data) {
+                fibril_mutex_initialize(&vfs_data->lock);
+                vfs_data->files = NULL;
+        }
+        
+        return vfs_data;
+}
+
+void vfs_client_data_destroy(void *data)
+{
+        vfs_client_data_t *vfs_data = (vfs_client_data_t *) data;
+
+        vfs_files_done();
+        free(vfs_data);
 }
 
@@ -127 +113 @@
  *                      incremented.
  */
-void vfs_file_addref(vfs_file_t *file)
-{
-        /*
-         * File structures are per-connection, so no-one, except the current
-         * fibril, should have a reference to them. This is the reason we don't
-         * do any synchronization here.
-         */
+static void vfs_file_addref(vfs_file_t *file)
+{
+        assert(fibril_mutex_is_locked(&VFS_DATA->lock));
+
         file->refcnt++;
 }
@@ -142 +125 @@
  *                      decremented.
  */
-void vfs_file_delref(vfs_file_t *file)
-{
+static void vfs_file_delref(vfs_file_t *file)
+{
+        assert(fibril_mutex_is_locked(&VFS_DATA->lock));
+
         if (file->refcnt-- == 1) {
                 /*
@@ -154 +139 @@
 }
 
+
+/** Allocate a file descriptor.
+ *
+ * @param desc If true, look for an available file descriptor
+ *             in a descending order.
+ *
+ * @return First available file descriptor or a negative error
+ *         code.
+ */
+int vfs_fd_alloc(bool desc)
+{
+        if (!vfs_files_init())
+                return ENOMEM;
+        
+        unsigned int i;
+        if (desc)
+                i = MAX_OPEN_FILES - 1;
+        else
+                i = 0;
+        
+        fibril_mutex_lock(&VFS_DATA->lock);
+        while (true) {
+                if (!FILES[i]) {
+                        FILES[i] = (vfs_file_t *) malloc(sizeof(vfs_file_t));
+                        if (!FILES[i]) {
+                                fibril_mutex_unlock(&VFS_DATA->lock);
+                                return ENOMEM;
+                        }
+                        
+                        memset(FILES[i], 0, sizeof(vfs_file_t));
+                        fibril_mutex_initialize(&FILES[i]->lock);
+                        vfs_file_addref(FILES[i]);
+                        fibril_mutex_unlock(&VFS_DATA->lock);
+                        return (int) i;
+                }
+                
+                if (desc) {
+                        if (i == 0)
+                                break;
+                        
+                        i--;
+                } else {
+                        if (i == MAX_OPEN_FILES - 1)
+                                break;
+                        
+                        i++;
+                }
+        }
+        fibril_mutex_unlock(&VFS_DATA->lock);
+        
+        return EMFILE;
+}
+
+/** Release file descriptor.
+ *
+ * @param fd            File descriptor being released.
+ *
+ * @return              EOK on success or EBADF if fd is an invalid file
+ *                      descriptor.
+ */
+int vfs_fd_free(int fd)
+{
+        if (!vfs_files_init())
+                return ENOMEM;
+
+        fibril_mutex_lock(&VFS_DATA->lock);     
+        if ((fd < 0) || (fd >= MAX_OPEN_FILES) || (FILES[fd] == NULL)) {
+                fibril_mutex_unlock(&VFS_DATA->lock);
+                return EBADF;
+        }
+        
+        vfs_file_delref(FILES[fd]);
+        FILES[fd] = NULL;
+        fibril_mutex_unlock(&VFS_DATA->lock);
+        
+        return EOK;
+}
+
+/** Assign a file to a file descriptor.
+ *
+ * @param file File to assign.
+ * @param fd   File descriptor to assign to.
+ *
+ * @return EOK on success or EINVAL if fd is an invalid or already
+ *         used file descriptor.
+ *
+ */
+int vfs_fd_assign(vfs_file_t *file, int fd)
+{
+        if (!vfs_files_init())
+                return ENOMEM;
+
+        fibril_mutex_lock(&VFS_DATA->lock);     
+        if ((fd < 0) || (fd >= MAX_OPEN_FILES) || (FILES[fd] != NULL)) {
+                fibril_mutex_unlock(&VFS_DATA->lock);
+                return EINVAL;
+        }
+        
+        FILES[fd] = file;
+        vfs_file_addref(FILES[fd]);
+        fibril_mutex_unlock(&VFS_DATA->lock);
+        
+        return EOK;
+}
+
 /** Find VFS file structure for a given file descriptor.
  *
@@ -165 +255 @@
                 return NULL;
         
-        if ((fd >= 0) && (fd < MAX_OPEN_FILES))
-                return files[fd];
+        fibril_mutex_lock(&VFS_DATA->lock);
+        if ((fd >= 0) && (fd < MAX_OPEN_FILES)) {
+                vfs_file_t *file = FILES[fd];
+                vfs_file_addref(file);
+                fibril_mutex_unlock(&VFS_DATA->lock);
+                return file;
+        }
+        fibril_mutex_unlock(&VFS_DATA->lock);
         
         return NULL;
+}
+
+/** Stop using a file structure.
+ *
+ * @param file          VFS file structure.
+ */
+void vfs_file_put(vfs_file_t *file)
+{
+        fibril_mutex_lock(&VFS_DATA->lock);
+        vfs_file_delref(file);
+        fibril_mutex_unlock(&VFS_DATA->lock);
 }