Changeset 03bc76a in mainline for uspace/srv/fs/minixfs/mfs_ops.c


Ignore:
Timestamp:
2011-09-04T12:33:10Z (14 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c699b0c
Parents:
8ff0bd2
Message:

Get rid of VFS_OUT method switch and IPC unmarshalling

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/minixfs/mfs_ops.c

    r8ff0bd2 r03bc76a  
    3838
    3939#define OPEN_NODES_KEYS 2
    40 #define OPEN_NODES_DEV_HANDLE_KEY 0
     40#define OPEN_NODES_SERVICE_KEY 0
    4141#define OPEN_NODES_INODE_KEY 1
    4242#define OPEN_NODES_BUCKETS 256
    … …  
    5151static fs_index_t mfs_index_get(fs_node_t *fsnode);
    5252static unsigned mfs_lnkcnt_get(fs_node_t *fsnode);
    53 static char mfs_plb_get_char(unsigned pos);
    5453static bool mfs_is_directory(fs_node_t *fsnode);
    5554static bool mfs_is_file(fs_node_t *fsnode);
    5655static int mfs_has_children(bool *has_children, fs_node_t *fsnode);
    57 static int mfs_root_get(fs_node_t **rfn, devmap_handle_t handle);
    58 static devmap_handle_t mfs_device_get(fs_node_t *fsnode);
     56static int mfs_root_get(fs_node_t **rfn, service_id_t service_id);
     57static service_id_t mfs_device_get(fs_node_t *fsnode);
    5958static aoff64_t mfs_size_get(fs_node_t *node);
    6059static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component);
    61 static int mfs_create_node(fs_node_t **rfn, devmap_handle_t handle, int flags);
     60static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags);
    6261static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name);
    6362static int mfs_unlink(fs_node_t *, fs_node_t *, const char *name);
    … …  
    6867static void open_nodes_remove_cb(link_t *link);
    6968
    70 static int mfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle,
     69static int mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    7170                        fs_index_t index);
     71static int
     72mfs_instance_get(service_id_t service_id, struct mfs_instance **instance);
    7273
    7374
    … …  
    9293        .unlink = mfs_unlink,
    9394        .destroy = mfs_destroy_node,
    94         .plb_get_char = mfs_plb_get_char,
    9595        .has_children = mfs_has_children,
    9696        .lnkcnt_get = mfs_lnkcnt_get
    … …  
    109109        struct mfs_node *mnode = hash_table_get_instance(item, struct mfs_node, link);
    110110        assert(keys > 0);
    111         if (mnode->instance->handle !=
    112             ((devmap_handle_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
     111        if (mnode->instance->service_id !=
     112            ((service_id_t) key[OPEN_NODES_SERVICE_KEY])) {
    113113                return false;
    114114        }
    … …  
    140140}
    141141
    142 void mfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    143 {
    144         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     142static int
     143mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
     144                aoff64_t *size, unsigned *linkcnt)
     145{
    145146        enum cache_mode cmode;
    146147        struct mfs_superblock *sb;
    … …  
    151152        mfs_version_t version;
    152153        uint16_t magic;
    153 
    154         /* Accept the mount options */
    155         char *opts;
    156         int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    157 
    158         if (rc != EOK) {
    159                 mfsdebug("Can't accept async data write\n");
    160                 async_answer_0(rid, rc);
    161                 return;
    162         }
     154        int rc;
    163155
    164156        /* Check for option enabling write through. */
    … …  
    168160                cmode = CACHE_MODE_WB;
    169161
    170         free(opts);
    171 
    172162        /* initialize libblock */
    173         rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, 1024);
    174         if (rc != EOK) {
    175                 mfsdebug("libblock initialization failed\n");
    176                 async_answer_0(rid, rc);
    177                 return;
    178         }
     163        rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
     164        if (rc != EOK)
     165                return rc;
    179166
    180167        /*Allocate space for generic MFS superblock*/
    181168        sbi = malloc(sizeof(*sbi));
    182 
    183169        if (!sbi) {
    184                 async_answer_0(rid, ENOMEM);
    185                 return;
     170                block_fini(service_id);
     171                return ENOMEM;
    186172        }
    187173
    188174        /*Allocate space for filesystem instance*/
    189175        instance = malloc(sizeof(*instance));
    190 
    191176        if (!instance) {
    192                 async_answer_0(rid, ENOMEM);
    193                 return;
     177                block_fini(service_id);
     178                return ENOMEM;
    194179        }
    195180
    … …  
    197182
    198183        sb = malloc(MFS_SUPERBLOCK_SIZE);
    199 
    200184        if (!sb) {
    201                 async_answer_0(rid, ENOMEM);
    202                 return;
     185                block_fini(service_id);
     186                return ENOMEM;
    203187        }
    204188
    205189        /* Read the superblock */
    206         rc = block_read_direct(devmap_handle, MFS_SUPERBLOCK << 1, 1, sb);
     190        rc = block_read_direct(service_id, MFS_SUPERBLOCK << 1, 1, sb);
    207191        if (rc != EOK) {
    208                 block_fini(devmap_handle);
    209                 async_answer_0(rid, rc);
    210                 return;
     192                block_fini(service_id);
     193                return rc;
    211194        }
    212195
    … …  
    221204        if (!check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
    222205                mfsdebug("magic number not recognized\n");
    223                 block_fini(devmap_handle);
    224                 async_answer_0(rid, ENOTSUP);
    225                 return;
     206                block_fini(service_id);
     207                return ENOTSUP;
    226208        }
    227209
    … …  
    278260        free(sb);
    279261
    280         rc = block_cache_init(devmap_handle, sbi->block_size, 0, cmode);
    281 
     262        rc = block_cache_init(service_id, sbi->block_size, 0, cmode);
    282263        if (rc != EOK) {
    283                 block_fini(devmap_handle);
    284                 async_answer_0(rid, EINVAL);
     264                free(sbi);
     265                free(instance);
     266                block_cache_fini(service_id);
     267                block_fini(service_id);
    285268                mfsdebug("block cache initialization failed\n");
    286                 return;
     269                return EINVAL;
    287270        }
    288271
    289272        /*Initialize the instance structure and add it to the list*/
    290273        link_initialize(&instance->link);
    291         instance->handle = devmap_handle;
     274        instance->service_id = service_id;
    292275        instance->sbi = sbi;
    293276
    … …  
    299282
    300283        fs_node_t *fn;
    301         mfs_node_get(&fn, devmap_handle, MFS_ROOT_INO);
    302 
    303         struct mfs_node *nroot = fn->data;
    304 
    305         async_answer_3(rid, EOK,
    306                         MFS_ROOT_INO,
    307                         0,
    308                         nroot->ino_i->i_nlinks);
    309 
    310         mfs_node_put(fn);
    311 }
    312 
    313 void mfs_mount(ipc_callid_t rid, ipc_call_t *request)
    314 {
    315         libfs_mount(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
    316 }
    317 
    318 void mfs_unmount(ipc_callid_t rid, ipc_call_t *request)
    319 {
    320         libfs_unmount(&mfs_libfs_ops, rid, request);
    321 }
    322 
    323 void mfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    324 {
    325         devmap_handle_t devmap = (devmap_handle_t) IPC_GET_ARG1(*request);
     284        mfs_node_get(&fn, service_id, MFS_ROOT_INO);
     285
     286        struct mfs_node *mroot = fn->data;
     287
     288        *index = mroot->ino_i->index;
     289        *size = mroot->ino_i->i_size;
     290        *linkcnt = mroot->ino_i->i_nlinks;
     291
     292        return mfs_node_put(fn);
     293}
     294
     295static int
     296mfs_unmounted(service_id_t service_id)
     297{
    326298        struct mfs_instance *inst;
    327299
    328         int r = mfs_instance_get(devmap, &inst);
    329         if (r != EOK) {
    330                 async_answer_0(rid, r);
    331                 return;
    332         }
    333 
    334         if (inst->open_nodes_cnt != 0) {
    335                 async_answer_0(rid, EBUSY);
    336                 return;
    337         }
    338 
    339         (void) block_cache_fini(devmap);
    340         block_fini(devmap);
     300        int r = mfs_instance_get(service_id, &inst);
     301        if (r != EOK)
     302                return r;
     303
     304        if (inst->open_nodes_cnt != 0)
     305                return EBUSY;
     306
     307        (void) block_cache_fini(service_id);
     308        block_fini(service_id);
    341309
    342310        /* Remove the instance from the list */
    … …  
    347315        free(inst->sbi);
    348316        free(inst);
    349 
    350         async_answer_0(rid, EOK);
    351 }
    352 
    353 devmap_handle_t mfs_device_get(fs_node_t *fsnode)
     317        return EOK;
     318}
     319
     320service_id_t mfs_device_get(fs_node_t *fsnode)
    354321{
    355322        struct mfs_node *node = fsnode->data;
    356         return node->instance->handle;
    357 }
    358 
    359 static int mfs_create_node(fs_node_t **rfn, devmap_handle_t handle, int flags)
     323        return node->instance->service_id;
     324}
     325
     326static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    360327{
    361328        int r;
    … …  
    367334        mfsdebug("%s()\n", __FUNCTION__);
    368335
    369         r = mfs_instance_get(handle, &inst);
     336        r = mfs_instance_get(service_id, &inst);
    370337        on_error(r, return r);
    371338
    … …  
    421388
    422389        unsigned long key[] = {
    423                 [OPEN_NODES_DEV_HANDLE_KEY] = inst->handle,
     390                [OPEN_NODES_SERVICE_KEY] = inst->service_id,
    424391                [OPEN_NODES_INODE_KEY] = inum,
    425392        };
    … …  
    498465}
    499466
    500 void mfs_stat(ipc_callid_t rid, ipc_call_t *request)
    501 {
    502         libfs_stat(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
    503 }
    504 
    505 static int mfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle,
     467static int
     468mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    506469                        fs_index_t index)
    507470{
    … …  
    511474        mfsdebug("%s()\n", __FUNCTION__);
    512475
    513         rc = mfs_instance_get(devmap_handle, &instance);
     476        rc = mfs_instance_get(service_id, &instance);
    514477        on_error(rc, return rc);
    515478
    … …  
    517480}
    518481
    519 static int mfs_node_put(fs_node_t *fsnode)
     482static int
     483mfs_node_put(fs_node_t *fsnode)
    520484{
    521485        int rc = EOK;
    … …  
    530494        if (mnode->refcnt == 0) {
    531495                unsigned long key[] = {
    532                         [OPEN_NODES_DEV_HANDLE_KEY] = mnode->instance->handle,
     496                        [OPEN_NODES_SERVICE_KEY] = mnode->instance->service_id,
    533497                        [OPEN_NODES_INODE_KEY] = mnode->ino_i->index
    534498                };
    … …  
    588552        /* Check if the node is not already open */
    589553        unsigned long key[] = {
    590                 [OPEN_NODES_DEV_HANDLE_KEY] = inst->handle,
     554                [OPEN_NODES_SERVICE_KEY] = inst->service_id,
    591555                [OPEN_NODES_INODE_KEY] = index,
    592556        };
    … …  
    659623}
    660624
    661 static int mfs_root_get(fs_node_t **rfn, devmap_handle_t handle)
    662 {
    663         int rc = mfs_node_get(rfn, handle, MFS_ROOT_INO);
     625static int mfs_root_get(fs_node_t **rfn, service_id_t service_id)
     626{
     627        int rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
    664628        return rc;
    665 }
    666 
    667 void mfs_lookup(ipc_callid_t rid, ipc_call_t *request)
    668 {
    669         libfs_lookup(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
    670 }
    671 
    672 static char mfs_plb_get_char(unsigned pos)
    673 {
    674         return mfs_reg.plb_ro[pos % PLB_SIZE];
    675629}
    676630
    … …  
    772726}
    773727
    774 void
    775 mfs_read(ipc_callid_t rid, ipc_call_t *request)
     728static int
     729mfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     730                size_t *rbytes)
    776731{
    777732        int rc;
    778         devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    779         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    780         aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
    781                                                IPC_GET_ARG4(*request));
    782733        fs_node_t *fn;
    783734
    784         rc = mfs_node_get(&fn, handle, index);
    785         if (rc != EOK) {
    786                 async_answer_0(rid, rc);
    787                 return;
    788         }
    789         if (!fn) {
    790                 async_answer_0(rid, ENOENT);
    791                 return;
    792         }
     735        rc = mfs_node_get(&fn, service_id, index);
     736        if (rc != EOK)
     737                return rc;
     738        if (!fn)
     739                return ENOENT;
    793740
    794741        struct mfs_node *mnode;
    … …  
    827774                rc = mfs_node_put(fn);
    828775                async_answer_0(callid, rc != EOK ? rc : ENOENT);
    829                 async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    830                 return;
     776                return rc;
    831777found:
    832778                async_data_read_finalize(callid, d_info.d_name,
    … …  
    866812                }
    867813
    868                 rc = block_get(&b, handle, zone, BLOCK_FLAGS_NONE);
     814                rc = block_get(&b, service_id, zone, BLOCK_FLAGS_NONE);
    869815                on_error(rc, goto out_error);
    870816
    … …  
    875821                if (rc != EOK) {
    876822                        mfs_node_put(fn);
    877                         async_answer_0(rid, rc);
    878                         return;
     823                        return rc;
    879824                }
    880825        }
    881826out_success:
    882827        rc = mfs_node_put(fn);
    883         async_answer_1(rid, rc, (sysarg_t)bytes);
    884         return;
     828        *rbytes = bytes;
     829        return rc;
    885830out_error:
    886831        ;
    887832        int tmp = mfs_node_put(fn);
    888833        async_answer_0(callid, tmp != EOK ? tmp : rc);
    889         async_answer_0(rid, tmp != EOK ? tmp : rc);
    890 }
    891 
    892 void
    893 mfs_write(ipc_callid_t rid, ipc_call_t *request)
    894 {
    895         devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    896         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    897         aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
    898                                                IPC_GET_ARG4(*request));
    899 
     834        return tmp != EOK ? tmp : rc;
     835}
     836
     837static int
     838mfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     839                size_t *wbytes, aoff64_t *nsize)
     840{
    900841        fs_node_t *fn;
    901842        int r;
    902843        int flags = BLOCK_FLAGS_NONE;
    903844
    904         r = mfs_node_get(&fn, handle, index);
    905         if (r != EOK) {
    906                 async_answer_0(rid, r);
    907                 return;
    908         }
    909 
    910         if (!fn) {
    911                 async_answer_0(rid, ENOENT);
    912                 return;
    913         }
     845        r = mfs_node_get(&fn, service_id, index);
     846        if (r != EOK)
     847                return r;
     848        if (!fn)
     849                return ENOENT;
    914850
    915851        ipc_callid_t callid;
    … …  
    953889
    954890        block_t *b;
    955         r = block_get(&b, handle, block, flags);
     891        r = block_get(&b, service_id, block, flags);
    956892        on_error(r, goto out_err);
    957893
    … …  
    962898        if (r != EOK) {
    963899                mfs_node_put(fn);
    964                 async_answer_0(rid, r);
    965                 return;
     900                return r;
    966901        }
    967902
    … …  
    969904        ino_i->dirty = true;
    970905        r = mfs_node_put(fn);
    971         async_answer_2(rid, r, bytes, pos + bytes);
    972         return;
     906        *nsize = pos + bytes;
     907        *wbytes = bytes;
     908        return r;
    973909
    974910out_err:
    975911        mfs_node_put(fn);
    976912        async_answer_0(callid, r);
    977         async_answer_0(rid, r);
    978 }
    979 
    980 void
    981 mfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    982 {
    983         devmap_handle_t handle = (devmap_handle_t)IPC_GET_ARG1(*request);
    984         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     913        return r;
     914}
     915
     916static int
     917mfs_destroy(service_id_t service_id, fs_index_t index)
     918{
    985919        fs_node_t *fn;
    986920        int r;
    987921
    988         r = mfs_node_get(&fn, handle, index);
    989         if (r != EOK) {
    990                 async_answer_0(rid, r);
    991                 return;
    992         }
    993         if (!fn) {
    994                 async_answer_0(rid, ENOENT);
    995                 return;
    996         }
     922        r = mfs_node_get(&fn, service_id, index);
     923        if (r != EOK)
     924                return r;
     925        if (!fn)
     926                return ENOENT;
    997927
    998928        /*Destroy the inode*/
    999929        r = mfs_destroy_node(fn);
    1000         async_answer_0(rid, r);
     930        return r;
    1001931}
    1002932
    … …  
    1031961}
    1032962
    1033 void
    1034 mfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    1035 {
    1036         devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1037         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1038         aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
    1039                                                 IPC_GET_ARG4(*request));
     963static int
     964mfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
     965{
    1040966        fs_node_t *fn;
    1041967        int r;
    1042968
    1043         r = mfs_node_get(&fn, handle, index);
    1044         if (r != EOK) {
    1045                 async_answer_0(rid, r);
    1046                 return;
    1047         }
    1048 
    1049         if (!fn) {
    1050                 async_answer_0(rid, r);
    1051                 return;
    1052         }
     969        r = mfs_node_get(&fn, service_id, index);
     970        if (r != EOK)
     971                return r;
     972        if (!fn)
     973                return r;
    1053974
    1054975        struct mfs_node *mnode = fn->data;
    … …  
    1060981                r = inode_shrink(mnode, ino_i->i_size - size);
    1061982
    1062         async_answer_0(rid, r);
    1063983        mfs_node_put(fn);
    1064 }
    1065 
    1066 int mfs_instance_get(devmap_handle_t handle, struct mfs_instance **instance)
    1067 {
    1068         link_t *link;
     984        return r;
     985}
     986
     987static int
     988mfs_instance_get(service_id_t service_id, struct mfs_instance **instance)
     989{
    1069990        struct mfs_instance *instance_ptr;
    1070991
    1071992        fibril_mutex_lock(&inst_list_mutex);
    1072993
    1073         for (link = inst_list.next; link != &inst_list; link = link->next) {
     994        if (list_empty(&inst_list)) {
     995                fibril_mutex_unlock(&inst_list_mutex);
     996                return EINVAL;
     997        }
     998
     999        list_foreach(inst_list, link) {
    10741000                instance_ptr = list_get_instance(link, struct mfs_instance,
    10751001                                                 link);
    10761002
    1077                 if (instance_ptr->handle == handle) {
     1003                if (instance_ptr->service_id == service_id) {
    10781004                        *instance = instance_ptr;
    10791005                        fibril_mutex_unlock(&inst_list_mutex);
    … …  
    11171043}
    11181044
    1119 void
    1120 mfs_close(ipc_callid_t rid, ipc_call_t *request)
    1121 {
    1122         async_answer_0(rid, EOK);
    1123 }
    1124 
    1125 void
    1126 mfs_open_node(ipc_callid_t rid, ipc_call_t *request)
    1127 {
    1128         libfs_open_node(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
    1129 }
    1130 
    1131 void
    1132 mfs_sync(ipc_callid_t rid, ipc_call_t *request)
    1133 {
    1134         devmap_handle_t devmap = (devmap_handle_t) IPC_GET_ARG1(*request);
    1135         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1136 
     1045static int
     1046mfs_close(service_id_t service_id, fs_index_t index)
     1047{
     1048        return 0;
     1049}
     1050
     1051static int
     1052mfs_sync(service_id_t service_id, fs_index_t index)
     1053{
    11371054        fs_node_t *fn;
    1138         int rc = mfs_node_get(&fn, devmap, index);
    1139         if (rc != EOK) {
    1140                 async_answer_0(rid, rc);
    1141                 return;
    1142         }
    1143         if (!fn) {
    1144                 async_answer_0(rid, ENOENT);
    1145                 return;
    1146         }
     1055        int rc = mfs_node_get(&fn, service_id, index);
     1056        if (rc != EOK)
     1057                return rc;
     1058        if (!fn)
     1059                return ENOENT;
    11471060
    11481061        struct mfs_node *mnode = fn->data;
    11491062        mnode->ino_i->dirty = true;
    11501063
    1151         rc = mfs_node_put(fn);
    1152         async_answer_0(rid, rc);
    1153 }
     1064        return mfs_node_put(fn);
     1065}
     1066
     1067vfs_out_ops_t mfs_ops = {
     1068        .mounted = mfs_mounted,
     1069        .unmounted = mfs_unmounted,
     1070        .read = mfs_read,
     1071        .write = mfs_write,
     1072        .truncate = mfs_truncate,
     1073        .close = mfs_close,
     1074        .destroy = mfs_destroy,
     1075        .sync = mfs_sync,
     1076};
    11541077
    11551078/**
Note: See TracChangeset for help on using the changeset viewer.