Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4979403 rffa2c8ef  
    22 * Copyright (c) 2006 Martin Decky
    33 * Copyright (c) 2008 Jakub Jermar
    4  * Copyright (c) 2011 Oleg Romanenko
    54 * All rights reserved.
    65 *
    … …  
    4039#include "fat.h"
    4140#include <ipc/services.h>
    42 #include <ns.h>
     41#include <ipc/ns.h>
    4342#include <async.h>
    4443#include <errno.h>
    … …  
    5453        .name = NAME,
    5554        .concurrent_read_write = false,
    56         .write_retains_size = false,
    57         .instance = 0,
     55        .write_retains_size = false,   
    5856};
     57
     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}
    59143
    60144int main(int argc, char **argv)
    61145{
     146        int vfs_phone;
     147        int rc;
     148
    62149        printf(NAME ": HelenOS FAT file system server\n");
    63        
    64         if (argc == 3) {
    65                 if (!str_cmp(argv[1], "--instance"))
    66                         fat_vfs_info.instance = strtol(argv[2], NULL, 10);
    67                 else {
    68                         printf(NAME " Unrecognized parameters");
    69                         return -1;
    70                 }
    71         }
    72150
    73         int rc = fat_idx_init();
     151        rc = fat_idx_init();
    74152        if (rc != EOK)
    75153                goto err;
    76        
    77         async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
    78             SERVICE_VFS, 0, 0);
    79         if (!vfs_sess) {
     154
     155        vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
     156        if (vfs_phone < EOK) {
    80157                printf(NAME ": failed to connect to VFS\n");
    81158                return -1;
    82159        }
    83160       
    84         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);
    85162        if (rc != EOK) {
    86163                fat_idx_fini();
    … …  
    91168        task_retval(0);
    92169        async_manager();
    93        
    94         /* Not reached */
     170        /* not reached */
    95171        return 0;
    96        
     172
    97173err:
    98174        printf(NAME ": Failed to register file system (%d)\n", rc);
    … …  
    102178/**
    103179 * @}
    104  */
     180 */ 
Note: See TracChangeset for help on using the changeset viewer.