Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/tmpfs/tmpfs.c

    refcebe1 rffa2c8ef  
    3030/** @addtogroup fs
    3131 * @{
    32  */
     32 */ 
    3333
    3434/**
    … …  
    4343#include "tmpfs.h"
    4444#include <ipc/services.h>
    45 #include <ns.h>
     45#include <ipc/ns.h>
    4646#include <async.h>
    4747#include <errno.h>
    … …  
    6161};
    6262
     63fs_reg_t tmpfs_reg;
     64
     65/**
     66 * This connection fibril processes VFS requests from VFS.
     67 *
     68 * In order to support simultaneous VFS requests, our design is as follows.
     69 * The connection fibril accepts VFS requests from VFS. If there is only one
     70 * instance of the fibril, VFS will need to serialize all VFS requests it sends
     71 * to FAT. To overcome this bottleneck, VFS can send TMPFS the
     72 * IPC_M_CONNECT_ME_TO call. In that case, a new connection fibril will be
     73 * created, which in turn will accept the call. Thus, a new phone will be
     74 * opened for VFS.
     75 *
     76 * There are few issues with this arrangement. First, VFS can run out of
     77 * available phones. In that case, VFS can close some other phones or use one
     78 * phone for more serialized requests. Similarily, TMPFS can refuse to duplicate
     79 * the connection. VFS should then just make use of already existing phones and
     80 * route its requests through them. To avoid paying the fibril creation price
     81 * upon each request, TMPFS might want to keep the connections open after the
     82 * request has been completed.
     83 */
     84static void tmpfs_connection(ipc_callid_t iid, ipc_call_t *icall)
     85{
     86        if (iid) {
     87                /*
     88                 * This only happens for connections opened by
     89                 * IPC_M_CONNECT_ME_TO calls as opposed to callback connections
     90                 * created by IPC_M_CONNECT_TO_ME.
     91                 */
     92                async_answer_0(iid, EOK);
     93        }
     94       
     95        dprintf(NAME ": connection opened\n");
     96        while (1) {
     97                ipc_callid_t callid;
     98                ipc_call_t call;
     99       
     100                callid = async_get_call(&call);
     101                switch  (IPC_GET_IMETHOD(call)) {
     102                case IPC_M_PHONE_HUNGUP:
     103                        return;
     104                case VFS_OUT_MOUNTED:
     105                        tmpfs_mounted(callid, &call);
     106                        break;
     107                case VFS_OUT_MOUNT:
     108                        tmpfs_mount(callid, &call);
     109                        break;
     110                case VFS_OUT_UNMOUNTED:
     111                        tmpfs_unmounted(callid, &call);
     112                        break;
     113                case VFS_OUT_UNMOUNT:
     114                        tmpfs_unmount(callid, &call);
     115                        break;
     116                case VFS_OUT_LOOKUP:
     117                        tmpfs_lookup(callid, &call);
     118                        break;
     119                case VFS_OUT_READ:
     120                        tmpfs_read(callid, &call);
     121                        break;
     122                case VFS_OUT_WRITE:
     123                        tmpfs_write(callid, &call);
     124                        break;
     125                case VFS_OUT_TRUNCATE:
     126                        tmpfs_truncate(callid, &call);
     127                        break;
     128                case VFS_OUT_CLOSE:
     129                        tmpfs_close(callid, &call);
     130                        break;
     131                case VFS_OUT_DESTROY:
     132                        tmpfs_destroy(callid, &call);
     133                        break;
     134                case VFS_OUT_OPEN_NODE:
     135                        tmpfs_open_node(callid, &call);
     136                        break;
     137                case VFS_OUT_STAT:
     138                        tmpfs_stat(callid, &call);
     139                        break;
     140                case VFS_OUT_SYNC:
     141                        tmpfs_sync(callid, &call);
     142                        break;
     143                default:
     144                        async_answer_0(callid, ENOTSUP);
     145                        break;
     146                }
     147        }
     148}
     149
    63150int main(int argc, char **argv)
    64151{
    65152        printf(NAME ": HelenOS TMPFS file system server\n");
    66        
     153
    67154        if (!tmpfs_init()) {
    68155                printf(NAME ": failed to initialize TMPFS\n");
    69156                return -1;
    70157        }
    71        
    72         async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
    73             SERVICE_VFS, 0, 0);
    74         if (!vfs_sess) {
     158
     159        int vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
     160        if (vfs_phone < EOK) {
    75161                printf(NAME ": Unable to connect to VFS\n");
    76162                return -1;
    77163        }
    78        
    79         int rc = fs_register(vfs_sess, &tmpfs_vfs_info, &tmpfs_ops,
    80             &tmpfs_libfs_ops);
     164
     165        int rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info,
     166            tmpfs_connection);
    81167        if (rc != EOK) {
    82168                printf(NAME ": Failed to register file system (%d)\n", rc);
    83169                return rc;
    84170        }
    85        
     171
    86172        printf(NAME ": Accepting connections\n");
    87173        task_retval(0);
    88174        async_manager();
    89        
    90         /* Not reached */
     175        /* not reached */
    91176        return 0;
    92177}
    … …  
    94179/**
    95180 * @}
    96  */
     181 */ 
Note: See TracChangeset for help on using the changeset viewer.