Changes in uspace/srv/vfs/vfs_file.c [6639ae1:e2ab36f1] in mainline

File:

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

uspace/srv/vfs/vfs_file.c

@@ -43 +43 @@
 #include <fibril.h>
 #include <fibril_synch.h>
+#include <adt/list.h>
+#include <task.h>
 #include "vfs.h"
 
-#define VFS_DATA        ((vfs_client_data_t *) async_client_data_get())
+#define VFS_DATA        ((vfs_client_data_t *) async_get_client_data())
 #define FILES           (VFS_DATA->files)
 
 typedef struct {
         fibril_mutex_t lock;
+        fibril_condvar_t cv;
+        list_t passed_handles;
         vfs_file_t **files;
 } vfs_client_data_t;
 
+typedef struct {
+        link_t link;
+        int handle;
+} vfs_boxed_handle_t;
+
+static int _vfs_fd_free(vfs_client_data_t *, int);
+
 /** Initialize the table of open 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);
+static bool vfs_files_init(vfs_client_data_t *vfs_data)
+{
+        fibril_mutex_lock(&vfs_data->lock);
+        if (!vfs_data->files) {
+                vfs_data->files = malloc(MAX_OPEN_FILES * sizeof(vfs_file_t *));
+                if (!vfs_data->files) {
+                        fibril_mutex_unlock(&vfs_data->lock);
                         return false;
                 }
-                memset(FILES, 0, MAX_OPEN_FILES * sizeof(vfs_file_t *));
-        }
-        fibril_mutex_unlock(&VFS_DATA->lock);
+                memset(vfs_data->files, 0, MAX_OPEN_FILES * sizeof(vfs_file_t *));
+        }
+        fibril_mutex_unlock(&vfs_data->lock);
         return true;
 }
 
 /** Cleanup the table of open files. */
-static void vfs_files_done(void)
+static void vfs_files_done(vfs_client_data_t *vfs_data)
 {
         int i;
 
-        if (!FILES)
+        if (!vfs_data->files)
                 return;
 
         for (i = 0; i < MAX_OPEN_FILES; i++) {
-                if (FILES[i]) {
-                        (void) vfs_close_internal(FILES[i]);
-                        (void) vfs_fd_free(i);
-                }
-        }
-        
-        free(FILES);
+                if (vfs_data->files[i])
+                        (void) _vfs_fd_free(vfs_data, i);
+        }
+        
+        free(vfs_data->files);
+
+        while (!list_empty(&vfs_data->passed_handles)) {
+                link_t *lnk;
+                vfs_boxed_handle_t *bh;
+                
+                lnk = list_first(&vfs_data->passed_handles);
+                list_remove(lnk);
+
+                bh = list_get_instance(lnk, vfs_boxed_handle_t, link);
+                free(bh);
+        }
 }
 
@@ -94 +114 @@
         if (vfs_data) {
                 fibril_mutex_initialize(&vfs_data->lock);
+                fibril_condvar_initialize(&vfs_data->cv);
+                list_initialize(&vfs_data->passed_handles);
                 vfs_data->files = NULL;
         }
@@ -104 +126 @@
         vfs_client_data_t *vfs_data = (vfs_client_data_t *) data;
 
-        vfs_files_done();
+        vfs_files_done(vfs_data);
         free(vfs_data);
+}
+
+/** Close the file in the endpoint FS server. */
+static int vfs_file_close_remote(vfs_file_t *file)
+{
+        assert(!file->refcnt);
+        
+        async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle);
+        
+        ipc_call_t answer;
+        aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->service_id,
+            file->node->index, &answer);
+        
+        vfs_exchange_release(exch);
+        
+        sysarg_t rc;
+        async_wait_for(msg, &rc);
+        
+        return IPC_GET_ARG1(answer);
 }
 
@@ -113 +154 @@
  *                      incremented.
  */
-static void vfs_file_addref(vfs_file_t *file)
-{
-        assert(fibril_mutex_is_locked(&VFS_DATA->lock));
+static void vfs_file_addref(vfs_client_data_t *vfs_data, vfs_file_t *file)
+{
+        assert(fibril_mutex_is_locked(&vfs_data->lock));
 
         file->refcnt++;
@@ -125 +166 @@
  *                      decremented.
  */
-static void vfs_file_delref(vfs_file_t *file)
-{
-        assert(fibril_mutex_is_locked(&VFS_DATA->lock));
+static int vfs_file_delref(vfs_client_data_t *vfs_data, vfs_file_t *file)
+{
+        int rc = EOK;
+
+        assert(fibril_mutex_is_locked(&vfs_data->lock));
 
         if (file->refcnt-- == 1) {
                 /*
-                 * Lost the last reference to a file, need to drop our reference
-                 * to the underlying VFS node.
+                 * Lost the last reference to a file, need to close it in the
+                 * endpoint FS and drop our reference to the underlying VFS node.
                  */
+                rc = vfs_file_close_remote(file);
                 vfs_node_delref(file->node);
                 free(file);
         }
-}
-
-
-/** 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 rc;
+}
+
+static int _vfs_fd_alloc(vfs_client_data_t *vfs_data, bool desc)
+{
+        if (!vfs_files_init(vfs_data))
                 return ENOMEM;
         
@@ -159 +196 @@
                 i = 0;
         
-        fibril_mutex_lock(&VFS_DATA->lock);
+        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);
+                if (!vfs_data->files[i]) {
+                        vfs_data->files[i] = (vfs_file_t *) malloc(sizeof(vfs_file_t));
+                        if (!vfs_data->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);
+                        memset(vfs_data->files[i], 0, sizeof(vfs_file_t));
+                        fibril_mutex_initialize(&vfs_data->files[i]->lock);
+                        vfs_file_addref(vfs_data, vfs_data->files[i]);
+                        fibril_mutex_unlock(&vfs_data->lock);
                         return (int) i;
                 }
@@ -187 +224 @@
                 }
         }
-        fibril_mutex_unlock(&VFS_DATA->lock);
+        fibril_mutex_unlock(&vfs_data->lock);
         
         return EMFILE;
+}
+
+/** 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)
+{
+        return _vfs_fd_alloc(VFS_DATA, desc);
+}
+
+static int _vfs_fd_free(vfs_client_data_t *vfs_data, int fd)
+{
+        int rc;
+
+        if (!vfs_files_init(vfs_data))
+                return ENOMEM;
+
+        fibril_mutex_lock(&vfs_data->lock);     
+        if ((fd < 0) || (fd >= MAX_OPEN_FILES) || !vfs_data->files[fd]) {
+                fibril_mutex_unlock(&vfs_data->lock);
+                return EBADF;
+        }
+        
+        rc = vfs_file_delref(vfs_data, vfs_data->files[fd]);
+        vfs_data->files[fd] = NULL;
+        fibril_mutex_unlock(&vfs_data->lock);
+        
+        return rc;
 }
 
@@ -201 +271 @@
 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;
+        return _vfs_fd_free(VFS_DATA, fd);
 }
 
@@ -228 +285 @@
 int vfs_fd_assign(vfs_file_t *file, int fd)
 {
-        if (!vfs_files_init())
+        if (!vfs_files_init(VFS_DATA))
                 return ENOMEM;
 
@@ -238 +295 @@
         
         FILES[fd] = file;
-        vfs_file_addref(FILES[fd]);
+        vfs_file_addref(VFS_DATA, FILES[fd]);
         fibril_mutex_unlock(&VFS_DATA->lock);
         
@@ -244 +301 @@
 }
 
-/** Find VFS file structure for a given file descriptor.
- *
- * @param fd            File descriptor.
- *
- * @return              VFS file structure corresponding to fd.
- */
-vfs_file_t *vfs_file_get(int fd)
-{
-        if (!vfs_files_init())
+static vfs_file_t *_vfs_file_get(vfs_client_data_t *vfs_data, int fd)
+{
+        if (!vfs_files_init(vfs_data))
                 return NULL;
         
-        fibril_mutex_lock(&VFS_DATA->lock);
+        fibril_mutex_lock(&vfs_data->lock);
         if ((fd >= 0) && (fd < MAX_OPEN_FILES)) {
-                vfs_file_t *file = FILES[fd];
+                vfs_file_t *file = vfs_data->files[fd];
                 if (file != NULL) {
-                        vfs_file_addref(file);
-                        fibril_mutex_unlock(&VFS_DATA->lock);
+                        vfs_file_addref(vfs_data, file);
+                        fibril_mutex_unlock(&vfs_data->lock);
                         return file;
                 }
         }
-        fibril_mutex_unlock(&VFS_DATA->lock);
+        fibril_mutex_unlock(&vfs_data->lock);
         
         return NULL;
 }
 
+/** Find VFS file structure for a given file descriptor.
+ *
+ * @param fd            File descriptor.
+ *
+ * @return              VFS file structure corresponding to fd.
+ */
+vfs_file_t *vfs_file_get(int fd)
+{
+        return _vfs_file_get(VFS_DATA, fd);
+}
+
+static void _vfs_file_put(vfs_client_data_t *vfs_data, vfs_file_t *file)
+{
+        fibril_mutex_lock(&vfs_data->lock);
+        vfs_file_delref(vfs_data, file);
+        fibril_mutex_unlock(&vfs_data->lock);
+}
+
 /** Stop using a file structure.
  *
@@ -275 +344 @@
 void vfs_file_put(vfs_file_t *file)
 {
-        fibril_mutex_lock(&VFS_DATA->lock);
-        vfs_file_delref(file);
-        fibril_mutex_unlock(&VFS_DATA->lock);
+        _vfs_file_put(VFS_DATA, file);
+}
+
+void vfs_pass_handle(task_id_t donor_id, task_id_t acceptor_id, int donor_fd)
+{
+        vfs_client_data_t *donor_data = NULL;
+        vfs_client_data_t *acceptor_data = NULL;
+        vfs_file_t *donor_file = NULL;
+        vfs_file_t *acceptor_file = NULL;
+        vfs_boxed_handle_t *bh;
+        int acceptor_fd;
+
+        acceptor_data = async_get_client_data_by_id(acceptor_id);
+        if (!acceptor_data)
+                return;
+
+        bh = malloc(sizeof(vfs_boxed_handle_t));
+        assert(bh);
+
+        link_initialize(&bh->link);
+        bh->handle = -1;
+
+        donor_data = async_get_client_data_by_id(donor_id);
+        if (!donor_data)
+                goto out;
+
+        donor_file = _vfs_file_get(donor_data, donor_fd);
+        if (!donor_file)
+                goto out;
+
+        acceptor_fd = _vfs_fd_alloc(acceptor_data, false);
+        if (acceptor_fd < 0)
+                goto out;
+
+        bh->handle = acceptor_fd;
+
+        /*
+         * Add a new reference to the underlying VFS node.
+         */
+        vfs_node_addref(donor_file->node);
+        (void) vfs_open_node_remote(donor_file->node);
+
+        acceptor_file = _vfs_file_get(acceptor_data, acceptor_fd);
+        assert(acceptor_file);
+
+        /*
+         * Inherit attributes from the donor.
+         */
+        acceptor_file->node = donor_file->node;
+        acceptor_file->append = donor_file->append;
+        acceptor_file->pos = donor_file->pos;
+
+out:
+        fibril_mutex_lock(&acceptor_data->lock);
+        list_append(&bh->link, &acceptor_data->passed_handles);
+        fibril_condvar_broadcast(&acceptor_data->cv);
+        fibril_mutex_unlock(&acceptor_data->lock);
+
+        if (donor_data)
+                async_put_client_data_by_id(donor_id);
+        if (acceptor_data)
+                async_put_client_data_by_id(acceptor_id);
+        if (donor_file)
+                _vfs_file_put(donor_data, donor_file);
+        if (acceptor_file)
+                _vfs_file_put(acceptor_data, acceptor_file);
+
+}
+
+int vfs_wait_handle_internal(void)
+{
+        vfs_client_data_t *vfs_data = VFS_DATA; 
+        int fd;
+        
+        fibril_mutex_lock(&vfs_data->lock);
+        while (list_empty(&vfs_data->passed_handles))
+                fibril_condvar_wait(&vfs_data->cv, &vfs_data->lock);
+        link_t *lnk = list_first(&vfs_data->passed_handles);
+        list_remove(lnk);
+        fibril_mutex_unlock(&vfs_data->lock);
+
+        vfs_boxed_handle_t *bh = list_get_instance(lnk, vfs_boxed_handle_t, link);
+        fd = bh->handle;
+        free(bh);
+
+        return fd;
 }