Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/fat/fat.c

    refcebe1 rc4bbca8  
    22 * Copyright (c) 2006 Martin Decky
    33 * Copyright (c) 2008 Jakub Jermar
     4 * Copyright (c) 2011 Oleg Romanenko
    45 * All rights reserved.
    56 *
    … …  
    3940#include "fat.h"
    4041#include <ipc/services.h>
    41 #include <ns.h>
     42#include <ipc/ns.h>
    4243#include <async.h>
    4344#include <errno.h>
    … …  
    5657};
    5758
     59fs_reg_t fat_reg;
     60
     61/**
     62 * This connection fibril processes VFS requests from VFS.
     63 *
     64 * In order to support simultaneous VFS requests, our design is as follows.
     65 * The connection fibril accepts VFS requests from VFS. If there is only one
     66 * instance of the fibril, VFS will need to serialize all VFS requests it sends
     67 * to FAT. To overcome this bottleneck, VFS can send FAT the IPC_M_CONNECT_ME_TO
     68 * call. In that case, a new connection fibril will be created, which in turn
     69 * will accept the call. Thus, a new phone will be opened for VFS.
     70 *
     71 * There are few issues with this arrangement. First, VFS can run out of
     72 * available phones. In that case, VFS can close some other phones or use one
     73 * phone for more serialized requests. Similarily, FAT can refuse to duplicate
     74 * the connection. VFS should then just make use of already existing phones and
     75 * route its requests through them. To avoid paying the fibril creation price
     76 * upon each request, FAT might want to keep the connections open after the
     77 * request has been completed.
     78 */
     79static void fat_connection(ipc_callid_t iid, ipc_call_t *icall)
     80{
     81        if (iid) {
     82                /*
     83                 * This only happens for connections opened by
     84                 * IPC_M_CONNECT_ME_TO calls as opposed to callback connections
     85                 * created by IPC_M_CONNECT_TO_ME.
     86                 */
     87                async_answer_0(iid, EOK);
     88        }
     89       
     90        dprintf(NAME ": connection opened\n");
     91        while (1) {
     92                ipc_callid_t callid;
     93                ipc_call_t call;
     94       
     95                callid = async_get_call(&call);
     96                switch  (IPC_GET_IMETHOD(call)) {
     97                case IPC_M_PHONE_HUNGUP:
     98                        return;
     99                case VFS_OUT_MOUNTED:
     100                        fat_mounted(callid, &call);
     101                        break;
     102                case VFS_OUT_MOUNT:
     103                        fat_mount(callid, &call);
     104                        break;
     105                case VFS_OUT_UNMOUNTED:
     106                        fat_unmounted(callid, &call);
     107                        break;
     108                case VFS_OUT_UNMOUNT:
     109                        fat_unmount(callid, &call);
     110                        break;
     111                case VFS_OUT_LOOKUP:
     112                        fat_lookup(callid, &call);
     113                        break;
     114                case VFS_OUT_READ:
     115                        fat_read(callid, &call);
     116                        break;
     117                case VFS_OUT_WRITE:
     118                        fat_write(callid, &call);
     119                        break;
     120                case VFS_OUT_TRUNCATE:
     121                        fat_truncate(callid, &call);
     122                        break;
     123                case VFS_OUT_STAT:
     124                        fat_stat(callid, &call);
     125                        break;
     126                case VFS_OUT_CLOSE:
     127                        fat_close(callid, &call);
     128                        break;
     129                case VFS_OUT_DESTROY:
     130                        fat_destroy(callid, &call);
     131                        break;
     132                case VFS_OUT_OPEN_NODE:
     133                        fat_open_node(callid, &call);
     134                        break;
     135                case VFS_OUT_SYNC:
     136                        fat_sync(callid, &call);
     137                        break;
     138                default:
     139                        async_answer_0(callid, ENOTSUP);
     140                        break;
     141                }
     142        }
     143}
     144
    58145int main(int argc, char **argv)
    59146{
     147        int vfs_phone;
     148        int rc;
     149
    60150        printf(NAME ": HelenOS FAT file system server\n");
    61        
    62         int rc = fat_idx_init();
     151
     152        rc = fat_idx_init();
    63153        if (rc != EOK)
    64154                goto err;
    65        
    66         async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
    67             SERVICE_VFS, 0, 0);
    68         if (!vfs_sess) {
     155
     156        vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
     157        if (vfs_phone < EOK) {
    69158                printf(NAME ": failed to connect to VFS\n");
    70159                return -1;
    71160        }
    72161       
    73         rc = fs_register(vfs_sess, &fat_vfs_info, &fat_ops, &fat_libfs_ops);
     162        rc = fs_register(vfs_phone, &fat_reg, &fat_vfs_info, fat_connection);
    74163        if (rc != EOK) {
    75164                fat_idx_fini();
    … …  
    80169        task_retval(0);
    81170        async_manager();
    82        
    83         /* Not reached */
     171        /* not reached */
    84172        return 0;
    85        
     173
    86174err:
    87175        printf(NAME ": Failed to register file system (%d)\n", rc);
    … …  
    91179/**
    92180 * @}
    93  */
     181 */ 
Note: See TracChangeset for help on using the changeset viewer.