Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    refcebe1 rffa2c8ef  
    3939#include "fat.h"
    4040#include <ipc/services.h>
    41 #include <ns.h>
     41#include <ipc/ns.h>
    4242#include <async.h>
    4343#include <errno.h>
    … …  
    5656};
    5757
     58fs_reg_t fat_reg;
     59
     60/**
     61 * This connection fibril processes VFS requests from VFS.
     62 *
     63 * In order to support simultaneous VFS requests, our design is as follows.
     64 * The connection fibril accepts VFS requests from VFS. If there is only one
     65 * instance of the fibril, VFS will need to serialize all VFS requests it sends
     66 * to FAT. To overcome this bottleneck, VFS can send FAT the IPC_M_CONNECT_ME_TO
     67 * call. In that case, a new connection fibril will be created, which in turn
     68 * will accept the call. Thus, a new phone will be opened for VFS.
     69 *
     70 * There are few issues with this arrangement. First, VFS can run out of
     71 * available phones. In that case, VFS can close some other phones or use one
     72 * phone for more serialized requests. Similarily, FAT can refuse to duplicate
     73 * the connection. VFS should then just make use of already existing phones and
     74 * route its requests through them. To avoid paying the fibril creation price
     75 * upon each request, FAT might want to keep the connections open after the
     76 * request has been completed.
     77 */
     78static void fat_connection(ipc_callid_t iid, ipc_call_t *icall)
     79{
     80        if (iid) {
     81                /*
     82                 * This only happens for connections opened by
     83                 * IPC_M_CONNECT_ME_TO calls as opposed to callback connections
     84                 * created by IPC_M_CONNECT_TO_ME.
     85                 */
     86                async_answer_0(iid, EOK);
     87        }
     88       
     89        dprintf(NAME ": connection opened\n");
     90        while (1) {
     91                ipc_callid_t callid;
     92                ipc_call_t call;
     93       
     94                callid = async_get_call(&call);
     95                switch  (IPC_GET_IMETHOD(call)) {
     96                case IPC_M_PHONE_HUNGUP:
     97                        return;
     98                case VFS_OUT_MOUNTED:
     99                        fat_mounted(callid, &call);
     100                        break;
     101                case VFS_OUT_MOUNT:
     102                        fat_mount(callid, &call);
     103                        break;
     104                case VFS_OUT_UNMOUNTED:
     105                        fat_unmounted(callid, &call);
     106                        break;
     107                case VFS_OUT_UNMOUNT:
     108                        fat_unmount(callid, &call);
     109                        break;
     110                case VFS_OUT_LOOKUP:
     111                        fat_lookup(callid, &call);
     112                        break;
     113                case VFS_OUT_READ:
     114                        fat_read(callid, &call);
     115                        break;
     116                case VFS_OUT_WRITE:
     117                        fat_write(callid, &call);
     118                        break;
     119                case VFS_OUT_TRUNCATE:
     120                        fat_truncate(callid, &call);
     121                        break;
     122                case VFS_OUT_STAT:
     123                        fat_stat(callid, &call);
     124                        break;
     125                case VFS_OUT_CLOSE:
     126                        fat_close(callid, &call);
     127                        break;
     128                case VFS_OUT_DESTROY:
     129                        fat_destroy(callid, &call);
     130                        break;
     131                case VFS_OUT_OPEN_NODE:
     132                        fat_open_node(callid, &call);
     133                        break;
     134                case VFS_OUT_SYNC:
     135                        fat_sync(callid, &call);
     136                        break;
     137                default:
     138                        async_answer_0(callid, ENOTSUP);
     139                        break;
     140                }
     141        }
     142}
     143
    58144int main(int argc, char **argv)
    59145{
     146        int vfs_phone;
     147        int rc;
     148
    60149        printf(NAME ": HelenOS FAT file system server\n");
    61        
    62         int rc = fat_idx_init();
     150
     151        rc = fat_idx_init();
    63152        if (rc != EOK)
    64153                goto err;
    65        
    66         async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
    67             SERVICE_VFS, 0, 0);
    68         if (!vfs_sess) {
     154
     155        vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
     156        if (vfs_phone < EOK) {
    69157                printf(NAME ": failed to connect to VFS\n");
    70158                return -1;
    71159        }
    72160       
    73         rc = fs_register(vfs_sess, &fat_vfs_info, &fat_ops, &fat_libfs_ops);
     161        rc = fs_register(vfs_phone, &fat_reg, &fat_vfs_info, fat_connection);
    74162        if (rc != EOK) {
    75163                fat_idx_fini();
    … …  
    80168        task_retval(0);
    81169        async_manager();
    82        
    83         /* Not reached */
     170        /* not reached */
    84171        return 0;
    85        
     172
    86173err:
    87174        printf(NAME ": Failed to register file system (%d)\n", rc);
    … …  
    91178/**
    92179 * @}
    93  */
     180 */ 
Note: See TracChangeset for help on using the changeset viewer.