Changeset a33f0a6 in mainline for uspace/srv/fs/fat


Ignore:
Timestamp:
2011-08-03T17:34:57Z (14 years ago)
Author:
Oleg Romanenko <romanenko.oleg@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1940326
Parents:
52a79081 (diff), 3fab770 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from mainline

Location:
uspace/srv/fs/fat
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/fat/Makefile

    r52a79081 ra33f0a6  
    3232EXTRA_CFLAGS += -I$(LIBBLOCK_PREFIX) -I$(LIBFS_PREFIX)
    3333BINARY = fat
     34STATIC_NEEDED = y
    3435
    3536SOURCES = \

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

    r52a79081 ra33f0a6  
    4040#include "fat.h"
    4141#include <ipc/services.h>
    42 #include <ipc/ns.h>
     42#include <ns.h>
    4343#include <async.h>
    4444#include <errno.h>
    … …  
    5757};
    5858
    59 fs_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  */
    79 static 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 
    14559int main(int argc, char **argv)
    14660{
    147         int vfs_phone;
    148         int rc;
    149 
    15061        printf(NAME ": HelenOS FAT file system server\n");
    151 
    152         rc = fat_idx_init();
     62       
     63        int rc = fat_idx_init();
    15364        if (rc != EOK)
    15465                goto err;
    155 
    156         vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
    157         if (vfs_phone < EOK) {
     66       
     67        async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
     68            SERVICE_VFS, 0, 0);
     69        if (!vfs_sess) {
    15870                printf(NAME ": failed to connect to VFS\n");
    15971                return -1;
    16072        }
    16173       
    162         rc = fs_register(vfs_phone, &fat_reg, &fat_vfs_info, fat_connection);
     74        rc = fs_register(vfs_sess, &fat_vfs_info, &fat_ops, &fat_libfs_ops);
    16375        if (rc != EOK) {
    16476                fat_idx_fini();
    … …  
    16981        task_retval(0);
    17082        async_manager();
    171         /* not reached */
     83       
     84        /* Not reached */
    17285        return 0;
    173 
     86       
    17487err:
    17588        printf(NAME ": Failed to register file system (%d)\n", rc);
    … …  
    17992/**
    18093 * @}
    181  */ 
     94 */

  • uspace/srv/fs/fat/fat.h

    r52a79081 ra33f0a6  
    227227} fat_node_t;
    228228
    229 extern fs_reg_t fat_reg;
    230 
    231 extern void fat_mounted(ipc_callid_t, ipc_call_t *);
    232 extern void fat_mount(ipc_callid_t, ipc_call_t *);
    233 extern void fat_unmounted(ipc_callid_t, ipc_call_t *);
    234 extern void fat_unmount(ipc_callid_t, ipc_call_t *);
    235 extern void fat_lookup(ipc_callid_t, ipc_call_t *);
    236 extern void fat_read(ipc_callid_t, ipc_call_t *);
    237 extern void fat_write(ipc_callid_t, ipc_call_t *);
    238 extern void fat_truncate(ipc_callid_t, ipc_call_t *);
    239 extern void fat_stat(ipc_callid_t, ipc_call_t *);
    240 extern void fat_close(ipc_callid_t, ipc_call_t *);
    241 extern void fat_destroy(ipc_callid_t, ipc_call_t *);
    242 extern void fat_open_node(ipc_callid_t, ipc_call_t *);
    243 extern void fat_stat(ipc_callid_t, ipc_call_t *);
    244 extern void fat_sync(ipc_callid_t, ipc_call_t *);
     229extern vfs_out_ops_t fat_ops;
     230extern libfs_ops_t fat_libfs_ops;
    245231
    246232extern int fat_idx_get_new(fat_idx_t **, devmap_handle_t);

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

    r52a79081 ra33f0a6  
    5959typedef struct {
    6060        link_t          link;
    61         devmap_handle_t devmap_handle;
     61        devmap_handle_t devmap_handle;
    6262
    6363        /** Next unassigned index. */
    64         fs_index_t      next;
     64        fs_index_t next;
    6565        /** Number of remaining unassigned indices. */
    66         uint64_t        remaining;
     66        uint64_t remaining;
    6767
    6868        /** Sorted list of intervals of freed indices. */
    69         link_t          freed_head;
     69        list_t freed_list;
    7070} unused_t;
    7171
    … …  
    7474
    7575/** List of unused structures. */
    76 static LIST_INITIALIZE(unused_head);
     76static LIST_INITIALIZE(unused_list);
    7777
    7878static void unused_initialize(unused_t *u, devmap_handle_t devmap_handle)
    … …  
    8282        u->next = 0;
    8383        u->remaining = ((uint64_t)((fs_index_t)-1)) + 1;
    84         list_initialize(&u->freed_head);
     84        list_initialize(&u->freed_list);
    8585}
    8686
    … …  
    8888{
    8989        unused_t *u;
    90         link_t *l;
    9190
    9291        if (lock)
    9392                fibril_mutex_lock(&unused_lock);
    94         for (l = unused_head.next; l != &unused_head; l = l->next) {
     93
     94        list_foreach(unused_list, l) {
    9595                u = list_get_instance(l, unused_t, link);
    9696                if (u->devmap_handle == devmap_handle)
    9797                        return u;
    9898        }
     99       
    99100        if (lock)
    100101                fibril_mutex_unlock(&unused_lock);
    … …  
    249250                return false;   
    250251
    251         if (list_empty(&u->freed_head)) {
     252        if (list_empty(&u->freed_list)) {
    252253                if (u->remaining) {
    253254                        /*
    … …  
    262263        } else {
    263264                /* There are some freed indices which we can reuse. */
    264                 freed_t *f = list_get_instance(u->freed_head.next, freed_t,
    265                     link);
     265                freed_t *f = list_get_instance(list_first(&u->freed_list),
     266                    freed_t, link);
    266267                *index = f->first;
    267268                if (f->first++ == f->last) {
    … …  
    320321                link_t *lnk;
    321322                freed_t *n;
    322                 for (lnk = u->freed_head.next; lnk != &u->freed_head;
     323                for (lnk = u->freed_list.head.next; lnk != &u->freed_list.head;
    323324                    lnk = lnk->next) {
    324325                        freed_t *f = list_get_instance(lnk, freed_t, link);
    325326                        if (f->first == index + 1) {
    326327                                f->first--;
    327                                 if (lnk->prev != &u->freed_head)
     328                                if (lnk->prev != &u->freed_list.head)
    328329                                        try_coalesce_intervals(lnk->prev, lnk,
    329330                                            lnk);
    … …  
    333334                        if (f->last == index - 1) {
    334335                                f->last++;
    335                                 if (lnk->next != &u->freed_head)
     336                                if (lnk->next != &u->freed_list.head)
    336337                                        try_coalesce_intervals(lnk, lnk->next,
    337338                                            lnk);
    … …  
    359360                n->first = index;
    360361                n->last = index;
    361                 list_append(&n->link, &u->freed_head);
     362                list_append(&n->link, &u->freed_list);
    362363        }
    363364        fibril_mutex_unlock(&unused_lock);
    … …  
    558559        fibril_mutex_lock(&unused_lock);
    559560        if (!unused_find(devmap_handle, false)) {
    560                 list_append(&u->link, &unused_head);
     561                list_append(&u->link, &unused_list);
    561562        } else {
    562563                free(u);
    … …  
    594595        fibril_mutex_unlock(&unused_lock);
    595596
    596         while (!list_empty(&u->freed_head)) {
     597        while (!list_empty(&u->freed_list)) {
    597598                freed_t *f;
    598                 f = list_get_instance(u->freed_head.next, freed_t, link);
     599                f = list_get_instance(list_first(&u->freed_list), freed_t, link);
    599600                list_remove(&f->link);
    600601                free(f);

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

    r52a79081 ra33f0a6  
    7070
    7171/** List of cached free FAT nodes. */
    72 static LIST_INITIALIZE(ffn_head);
     72static LIST_INITIALIZE(ffn_list);
    7373
    7474/*
    … …  
    8888static aoff64_t fat_size_get(fs_node_t *);
    8989static unsigned fat_lnkcnt_get(fs_node_t *);
    90 static char fat_plb_get_char(unsigned);
    9190static bool fat_is_directory(fs_node_t *);
    9291static bool fat_is_file(fs_node_t *node);
    … …  
    150149static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
    151150{
    152         link_t *lnk;
    153151        fat_node_t *nodep;
    154152        int rc;
    … …  
    162160restart:
    163161        fibril_mutex_lock(&ffn_mutex);
    164         for (lnk = ffn_head.next; lnk != &ffn_head; lnk = lnk->next) {
     162        list_foreach(ffn_list, lnk) {
    165163                nodep = list_get_instance(lnk, fat_node_t, ffn_link);
    166164                if (!fibril_mutex_trylock(&nodep->lock)) {
    … …  
    199197                free(nodep);
    200198
    201                 /* Need to restart because we changed the ffn_head list. */
     199                /* Need to restart because we changed ffn_list. */
    202200                goto restart;
    203201        }
    … …  
    214212
    215213        fibril_mutex_lock(&ffn_mutex);
    216         if (!list_empty(&ffn_head)) {
     214        if (!list_empty(&ffn_list)) {
    217215                /* Try to use a cached free node structure. */
    218216                fat_idx_t *idxp_tmp;
    219                 nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
     217                nodep = list_get_instance(list_first(&ffn_list), fat_node_t,
     218                    ffn_link);
    220219                if (!fibril_mutex_trylock(&nodep->lock))
    221220                        goto skip_cache;
    … …  
    464463                if (nodep->idx) {
    465464                        fibril_mutex_lock(&ffn_mutex);
    466                         list_append(&nodep->ffn_link, &ffn_head);
     465                        list_append(&nodep->ffn_link, &ffn_list);
    467466                        fibril_mutex_unlock(&ffn_mutex);
    468467                } else {
    … …  
    823822}
    824823
    825 char fat_plb_get_char(unsigned pos)
    826 {
    827         return fat_reg.plb_ro[pos % PLB_SIZE];
    828 }
    829 
    830824bool fat_is_directory(fs_node_t *fn)
    831825{
    … …  
    858852        .size_get = fat_size_get,
    859853        .lnkcnt_get = fat_lnkcnt_get,
    860         .plb_get_char = fat_plb_get_char,
    861854        .is_directory = fat_is_directory,
    862855        .is_file = fat_is_file,
    … …  
    865858
    866859/*
    867  * VFS operations.
     860 * FAT VFS_OUT operations.
    868861 */
    869862
    870 void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
    871 {
    872         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     863static int
     864fat_mounted(devmap_handle_t devmap_handle, const char *opts, fs_index_t *index,
     865    aoff64_t *size, unsigned *linkcnt)
     866{
    873867        enum cache_mode cmode;
    874868        fat_bs_t *bs;
    875 
    876         /* Accept the mount options */
    877         char *opts;
    878         int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    879 
    880         if (rc != EOK) {
    881                 async_answer_0(rid, rc);
    882                 return;
    883         }
     869        int rc;
    884870
    885871        /* Check for option enabling write through. */
    … …  
    889875                cmode = CACHE_MODE_WB;
    890876
    891         free(opts);
    892 
    893877        /* initialize libblock */
    894         rc = block_init(devmap_handle, BS_SIZE);
    895         if (rc != EOK) {
    896                 async_answer_0(rid, rc);
    897                 return;
    898         }
     878        rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
     879        if (rc != EOK)
     880                return rc;
    899881
    900882        /* prepare the boot block */
    … …  
    902884        if (rc != EOK) {
    903885                block_fini(devmap_handle);
    904                 async_answer_0(rid, rc);
    905                 return;
     886                return rc;
    906887        }
    907888
    … …  
    911892        if (BPS(bs) != BS_SIZE) {
    912893                block_fini(devmap_handle);
    913                 async_answer_0(rid, ENOTSUP);
    914                 return;
     894                return ENOTSUP;
    915895        }
    916896
    … …  
    919899        if (rc != EOK) {
    920900                block_fini(devmap_handle);
    921                 async_answer_0(rid, rc);
    922                 return;
     901                return rc;
    923902        }
    924903
    … …  
    928907                (void) block_cache_fini(devmap_handle);
    929908                block_fini(devmap_handle);
    930                 async_answer_0(rid, rc);
    931                 return;
     909                return rc;
    932910        }
    933911
    … …  
    936914                (void) block_cache_fini(devmap_handle);
    937915                block_fini(devmap_handle);
    938                 async_answer_0(rid, rc);
    939                 return;
     916                return rc;
    940917        }
    941918
    … …  
    946923                block_fini(devmap_handle);
    947924                fat_idx_fini_by_devmap_handle(devmap_handle);
    948                 async_answer_0(rid, ENOMEM);
    949                 return;
     925                return ENOMEM;
    950926        }
    951927
    … …  
    957933                block_fini(devmap_handle);
    958934                fat_idx_fini_by_devmap_handle(devmap_handle);
    959                 async_answer_0(rid, ENOMEM);
    960                 return;
     935                return ENOMEM;
    961936        }
    962937        fat_node_initialize(rootp);
    … …  
    969944                block_fini(devmap_handle);
    970945                fat_idx_fini_by_devmap_handle(devmap_handle);
    971                 async_answer_0(rid, ENOMEM);
    972                 return;
     946                return ENOMEM;
    973947        }
    974948        assert(ridxp->index == 0);
    … …  
    1004978        fibril_mutex_unlock(&ridxp->lock);
    1005979
    1006         async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
    1007 }
    1008 
    1009 void fat_mount(ipc_callid_t rid, ipc_call_t *request)
    1010 {
    1011         libfs_mount(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1012 }
    1013 
    1014 void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    1015 {
    1016         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     980        *index = ridxp->index;
     981        *size = rootp->size;
     982        *linkcnt = rootp->lnkcnt;
     983
     984        return EOK;
     985}
     986
     987static int fat_unmounted(devmap_handle_t devmap_handle)
     988{
    1017989        fs_node_t *fn;
    1018990        fat_node_t *nodep;
    … …  
    1020992
    1021993        rc = fat_root_get(&fn, devmap_handle);
    1022         if (rc != EOK) {
    1023                 async_answer_0(rid, rc);
    1024                 return;
    1025         }
     994        if (rc != EOK)
     995                return rc;
    1026996        nodep = FAT_NODE(fn);
    1027997
    … …  
    10321002        if (nodep->refcnt != 2) {
    10331003                (void) fat_node_put(fn);
    1034                 async_answer_0(rid, EBUSY);
    1035                 return;
     1004                return EBUSY;
    10361005        }
    10371006
    … …  
    10521021        block_fini(devmap_handle);
    10531022
    1054         async_answer_0(rid, EOK);
    1055 }
    1056 
    1057 void fat_unmount(ipc_callid_t rid, ipc_call_t *request)
    1058 {
    1059         libfs_unmount(&fat_libfs_ops, rid, request);
    1060 }
    1061 
    1062 void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
    1063 {
    1064         libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1065 }
    1066 
    1067 void fat_read(ipc_callid_t rid, ipc_call_t *request)
    1068 {
    1069         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1070         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1071         aoff64_t pos =
    1072             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1023        return EOK;
     1024}
     1025
     1026static int
     1027fat_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1028    size_t *rbytes)
     1029{
    10731030        fs_node_t *fn;
    10741031        fat_node_t *nodep;
    … …  
    10791036
    10801037        rc = fat_node_get(&fn, devmap_handle, index);
    1081         if (rc != EOK) {
    1082                 async_answer_0(rid, rc);
    1083                 return;
    1084         }
    1085         if (!fn) {
    1086                 async_answer_0(rid, ENOENT);
    1087                 return;
    1088         }
     1038        if (rc != EOK)
     1039                return rc;
     1040        if (!fn)
     1041                return ENOENT;
    10891042        nodep = FAT_NODE(fn);
    10901043
    … …  
    10941047                fat_node_put(fn);
    10951048                async_answer_0(callid, EINVAL);
    1096                 async_answer_0(rid, EINVAL);
    1097                 return;
     1049                return EINVAL;
    10981050        }
    10991051
    … …  
    11181070                                fat_node_put(fn);
    11191071                                async_answer_0(callid, rc);
    1120                                 async_answer_0(rid, rc);
    1121                                 return;
     1072                                return rc;
    11221073                        }
    11231074                        (void) async_data_read_finalize(callid,
    … …  
    11261077                        if (rc != EOK) {
    11271078                                fat_node_put(fn);
    1128                                 async_answer_0(rid, rc);
    1129                                 return;
     1079                                return rc;
    11301080                        }
    11311081                }
    … …  
    11551105                (void) fat_node_put(fn);
    11561106                async_answer_0(callid, rc);
    1157                 async_answer_0(rid, rc);
    1158                 return;
     1107                return rc;
    11591108
    11601109miss:
    … …  
    11641113                rc = fat_node_put(fn);
    11651114                async_answer_0(callid, rc != EOK ? rc : ENOENT);
    1166                 async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    1167                 return;
     1115                *rbytes = 0;
     1116                return rc != EOK ? rc : ENOENT;
    11681117
    11691118hit:
    … …  
    11771126
    11781127        rc = fat_node_put(fn);
    1179         async_answer_1(rid, rc, (sysarg_t)bytes);
    1180 }
    1181 
    1182 void fat_write(ipc_callid_t rid, ipc_call_t *request)
    1183 {
    1184         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1185         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1186         aoff64_t pos =
    1187             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1128        *rbytes = bytes;
     1129        return rc;
     1130}
     1131
     1132static int
     1133fat_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1134    size_t *wbytes, aoff64_t *nsize)
     1135{
    11881136        fs_node_t *fn;
    11891137        fat_node_t *nodep;
    11901138        fat_bs_t *bs;
    1191         size_t bytes, size;
     1139        size_t bytes;
    11921140        block_t *b;
    11931141        aoff64_t boundary;
    … …  
    11961144
    11971145        rc = fat_node_get(&fn, devmap_handle, index);
    1198         if (rc != EOK) {
    1199                 async_answer_0(rid, rc);
    1200                 return;
    1201         }
    1202         if (!fn) {
    1203                 async_answer_0(rid, ENOENT);
    1204                 return;
    1205         }
     1146        if (rc != EOK)
     1147                return rc;
     1148        if (!fn)
     1149                return ENOENT;
    12061150        nodep = FAT_NODE(fn);
    12071151
    … …  
    12111155                (void) fat_node_put(fn);
    12121156                async_answer_0(callid, EINVAL);
    1213                 async_answer_0(rid, EINVAL);
    1214                 return;
     1157                return EINVAL;
    12151158        }
    12161159
    … …  
    12401183                        (void) fat_node_put(fn);
    12411184                        async_answer_0(callid, rc);
    1242                         async_answer_0(rid, rc);
    1243                         return;
     1185                        return rc;
    12441186                }
    12451187                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
    … …  
    12471189                        (void) fat_node_put(fn);
    12481190                        async_answer_0(callid, rc);
    1249                         async_answer_0(rid, rc);
    1250                         return;
     1191                        return rc;
    12511192                }
    12521193                (void) async_data_write_finalize(callid,
    … …  
    12561197                if (rc != EOK) {
    12571198                        (void) fat_node_put(fn);
    1258                         async_answer_0(rid, rc);
    1259                         return;
     1199                        return rc;
    12601200                }
    12611201                if (pos + bytes > nodep->size) {
    … …  
    12631203                        nodep->dirty = true;    /* need to sync node */
    12641204                }
    1265                 size = nodep->size;
     1205                *wbytes = bytes;
     1206                *nsize = nodep->size;
    12661207                rc = fat_node_put(fn);
    1267                 async_answer_2(rid, rc, bytes, nodep->size);
    1268                 return;
     1208                return rc;
    12691209        } else {
    12701210                /*
    … …  
    12821222                        (void) fat_node_put(fn);
    12831223                        async_answer_0(callid, rc);
    1284                         async_answer_0(rid, rc);
    1285                         return;
     1224                        return rc;
    12861225                }
    12871226                /* zero fill any gaps */
    … …  
    12911230                        (void) fat_node_put(fn);
    12921231                        async_answer_0(callid, rc);
    1293                         async_answer_0(rid, rc);
    1294                         return;
     1232                        return rc;
    12951233                }
    12961234                rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
    … …  
    13001238                        (void) fat_node_put(fn);
    13011239                        async_answer_0(callid, rc);
    1302                         async_answer_0(rid, rc);
    1303                         return;
     1240                        return rc;
    13041241                }
    13051242                (void) async_data_write_finalize(callid,
    … …  
    13101247                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13111248                        (void) fat_node_put(fn);
    1312                         async_answer_0(rid, rc);
    1313                         return;
     1249                        return rc;
    13141250                }
    13151251                /*
    … …  
    13211257                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13221258                        (void) fat_node_put(fn);
    1323                         async_answer_0(rid, rc);
    1324                         return;
    1325                 }
    1326                 nodep->size = size = pos + bytes;
     1259                        return rc;
     1260                }
     1261                *nsize = nodep->size = pos + bytes;
     1262                rc = fat_node_put(fn);
    13271263                nodep->dirty = true;            /* need to sync node */
    1328                 rc = fat_node_put(fn);
    1329                 async_answer_2(rid, rc, bytes, size);
    1330                 return;
    1331         }
    1332 }
    1333 
    1334 void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
    1335 {
    1336         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1337         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1338         aoff64_t size =
    1339             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1264                *wbytes = bytes;
     1265                return rc;
     1266        }
     1267}
     1268
     1269static int
     1270fat_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
     1271{
    13401272        fs_node_t *fn;
    13411273        fat_node_t *nodep;
    … …  
    13441276
    13451277        rc = fat_node_get(&fn, devmap_handle, index);
    1346         if (rc != EOK) {
    1347                 async_answer_0(rid, rc);
    1348                 return;
    1349         }
    1350         if (!fn) {
    1351                 async_answer_0(rid, ENOENT);
    1352                 return;
    1353         }
     1278        if (rc != EOK)
     1279                return rc;
     1280        if (!fn)
     1281                return ENOENT;
    13541282        nodep = FAT_NODE(fn);
    13551283
    … …  
    13951323out:
    13961324        fat_node_put(fn);
    1397         async_answer_0(rid, rc);
    1398         return;
    1399 }
    1400 
    1401 void fat_close(ipc_callid_t rid, ipc_call_t *request)
    1402 {
    1403         async_answer_0(rid, EOK);
    1404 }
    1405 
    1406 void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
    1407 {
    1408         devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
    1409         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     1325        return rc;
     1326}
     1327
     1328static int fat_close(devmap_handle_t devmap_handle, fs_index_t index)
     1329{
     1330        return EOK;
     1331}
     1332
     1333static int fat_destroy(devmap_handle_t devmap_handle, fs_index_t index)
     1334{
    14101335        fs_node_t *fn;
    14111336        fat_node_t *nodep;
    … …  
    14131338
    14141339        rc = fat_node_get(&fn, devmap_handle, index);
    1415         if (rc != EOK) {
    1416                 async_answer_0(rid, rc);
    1417                 return;
    1418         }
    1419         if (!fn) {
    1420                 async_answer_0(rid, ENOENT);
    1421                 return;
    1422         }
     1340        if (rc != EOK)
     1341                return rc;
     1342        if (!fn)
     1343                return ENOENT;
    14231344
    14241345        nodep = FAT_NODE(fn);
    … …  
    14301351
    14311352        rc = fat_destroy_node(fn);
    1432         async_answer_0(rid, rc);
    1433 }
    1434 
    1435 void fat_open_node(ipc_callid_t rid, ipc_call_t *request)
    1436 {
    1437         libfs_open_node(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1438 }
    1439 
    1440 void fat_stat(ipc_callid_t rid, ipc_call_t *request)
    1441 {
    1442         libfs_stat(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1443 }
    1444 
    1445 void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    1446 {
    1447         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1448         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1449 
     1353        return rc;
     1354}
     1355
     1356static int fat_sync(devmap_handle_t devmap_handle, fs_index_t index)
     1357{
    14501358        fs_node_t *fn;
    14511359        int rc = fat_node_get(&fn, devmap_handle, index);
    1452         if (rc != EOK) {
    1453                 async_answer_0(rid, rc);
    1454                 return;
    1455         }
    1456         if (!fn) {
    1457                 async_answer_0(rid, ENOENT);
    1458                 return;
    1459         }
     1360        if (rc != EOK)
     1361                return rc;
     1362        if (!fn)
     1363                return ENOENT;
    14601364
    14611365        fat_node_t *nodep = FAT_NODE(fn);
    … …  
    14651369
    14661370        fat_node_put(fn);
    1467         async_answer_0(rid, rc);
    1468 }
     1371        return rc;
     1372}
     1373
     1374vfs_out_ops_t fat_ops = {
     1375        .mounted = fat_mounted,
     1376        .unmounted = fat_unmounted,
     1377        .read = fat_read,
     1378        .write = fat_write,
     1379        .truncate = fat_truncate,
     1380        .close = fat_close,
     1381        .destroy = fat_destroy,
     1382        .sync = fat_sync,
     1383};
    14691384
    14701385/**
Note: See TracChangeset for help on using the changeset viewer.