Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    re6da6d5 r27b76ca  
    5252#include <assert.h>
    5353#include <vfs/canonify.h>
    54 #include <vfs/vfs_mtab.h>
    55 
    56 FIBRIL_MUTEX_INITIALIZE(mtab_list_lock);
    57 LIST_INITIALIZE(mtab_list);
    58 static size_t mtab_size = 0;
    5954
    6055/* Forward declarations of static functions. */
    61 static int vfs_truncate_internal(fs_handle_t, service_id_t, fs_index_t,
     56static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t,
    6257    aoff64_t);
    6358
    … …  
    7065vfs_pair_t rootfs = {
    7166        .fs_handle = 0,
    72         .service_id = 0
     67        .devmap_handle = 0
    7368};
    7469
    75 static int vfs_mount_internal(ipc_callid_t rid, service_id_t service_id,
     70static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle,
    7671    fs_handle_t fs_handle, char *mp, char *opts)
    7772{
    … …  
    9691                        fibril_rwlock_write_unlock(&namespace_rwlock);
    9792                        async_answer_0(rid, EBUSY);
    98                         return EBUSY;
     93                        return;
    9994                }
    10095               
    … …  
    10499                        fibril_rwlock_write_unlock(&namespace_rwlock);
    105100                        async_answer_0(rid, rc);
    106                         return rc;
     101                        return;
    107102                }
    108103               
    … …  
    111106                        fibril_rwlock_write_unlock(&namespace_rwlock);
    112107                        async_answer_0(rid, ENOMEM);
    113                         return ENOMEM;
     108                        return;
    114109                }
    115110               
    … …  
    130125                        exch = vfs_exchange_grab(fs_handle);
    131126                        msg = async_send_1(exch, VFS_OUT_MOUNTED,
    132                             (sysarg_t) service_id, &answer);
     127                            (sysarg_t) devmap_handle, &answer);
    133128                        /* Send the mount options */
    134129                        rc = async_data_write_start(exch, (void *)opts,
    … …  
    140135                                fibril_rwlock_write_unlock(&namespace_rwlock);
    141136                                async_answer_0(rid, rc);
    142                                 return rc;
     137                                return;
    143138                        }
    144139                        async_wait_for(msg, &rc);
    … …  
    147142                                fibril_rwlock_write_unlock(&namespace_rwlock);
    148143                                async_answer_0(rid, rc);
    149                                 return rc;
     144                                return;
    150145                        }
    151146
    152147                        rindex = (fs_index_t) IPC_GET_ARG1(answer);
    153                         rsize = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(answer),
    154                             IPC_GET_ARG3(answer));
     148                        rsize = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    155149                        rlnkcnt = (unsigned) IPC_GET_ARG4(answer);
    156150                       
    157151                        mr_res.triplet.fs_handle = fs_handle;
    158                         mr_res.triplet.service_id = service_id;
     152                        mr_res.triplet.devmap_handle = devmap_handle;
    159153                        mr_res.triplet.index = rindex;
    160154                        mr_res.size = rsize;
    … …  
    163157                       
    164158                        rootfs.fs_handle = fs_handle;
    165                         rootfs.service_id = service_id;
     159                        rootfs.devmap_handle = devmap_handle;
    166160                       
    167161                        /* Add reference to the mounted root. */
    … …  
    171165                        fibril_rwlock_write_unlock(&namespace_rwlock);
    172166                        async_answer_0(rid, rc);
    173                         return rc;
     167                        return;
    174168                } else {
    175169                        /*
    … …  
    179173                        fibril_rwlock_write_unlock(&namespace_rwlock);
    180174                        async_answer_0(rid, ENOENT);
    181                         return ENOENT;
    182                 }
    183         }
    184        
    185         /*
    186          * At this point, we have all necessary pieces: file system handle
    187          * and service ID, and we know the mount point VFS node.
     175                        return;
     176                }
     177        }
     178       
     179        /*
     180         * At this point, we have all necessary pieces: file system and device
     181         * handles, and we know the mount point VFS node.
    188182         */
    189183       
    … …  
    193187        exch = vfs_exchange_grab(mp_res.triplet.fs_handle);
    194188        msg = async_send_4(exch, VFS_OUT_MOUNT,
    195             (sysarg_t) mp_res.triplet.service_id,
     189            (sysarg_t) mp_res.triplet.devmap_handle,
    196190            (sysarg_t) mp_res.triplet.index,
    197191            (sysarg_t) fs_handle,
    198             (sysarg_t) service_id, &answer);
     192            (sysarg_t) devmap_handle, &answer);
    199193       
    200194        /* Send connection */
    … …  
    212206                async_answer_0(rid, rc);
    213207                fibril_rwlock_write_unlock(&namespace_rwlock);
    214                 return rc;
     208                return;
    215209        }
    216210       
    … …  
    227221                fibril_rwlock_write_unlock(&namespace_rwlock);
    228222                async_answer_0(rid, rc);
    229                 return rc;
    230         }
    231        
    232         /*
    233          * Wait for the answer before releasing the exchange to avoid deadlock
    234          * in case the answer depends on further calls to the same file system.
    235          * Think of a case when mounting a FS on a file_bd backed by a file on
    236          * the same FS.
    237          */
     223                return;
     224        }
     225       
     226        vfs_exchange_release(exch);
    238227        async_wait_for(msg, &rc);
    239         vfs_exchange_release(exch);
    240228       
    241229        if (rc == EOK) {
    … …  
    246234               
    247235                mr_res.triplet.fs_handle = fs_handle;
    248                 mr_res.triplet.service_id = service_id;
     236                mr_res.triplet.devmap_handle = devmap_handle;
    249237                mr_res.triplet.index = rindex;
    250238                mr_res.size = rsize;
    … …  
    263251        async_answer_0(rid, rc);
    264252        fibril_rwlock_write_unlock(&namespace_rwlock);
    265         return rc;
    266253}
    267254
    268255void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
    269256{
    270         service_id_t service_id;
     257        devmap_handle_t devmap_handle;
    271258
    272259        /*
    … …  
    275262         * in the request.
    276263         */
    277         service_id = (service_id_t) IPC_GET_ARG1(*request);
     264        devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    278265       
    279266        /*
    … …  
    283270       
    284271        /*
    285          * Instance number is passed as ARG3.
    286          */
    287         unsigned int instance = IPC_GET_ARG3(*request);
    288 
     272         * For now, don't make use of ARG3, but it can be used to
     273         * carry mount options in the future.
     274         */
     275       
    289276        /* We want the client to send us the mount point. */
    290277        char *mp;
    … …  
    342329        fs_handle_t fs_handle;
    343330recheck:
    344         fs_handle = fs_name_to_handle(instance, fs_name, false);
     331        fs_handle = fs_name_to_handle(fs_name, false);
    345332        if (!fs_handle) {
    346333                if (flags & IPC_FLAG_BLOCKING) {
    … …  
    358345        }
    359346        fibril_mutex_unlock(&fs_list_lock);
    360 
    361         /* Add the filesystem info to the list of mounted filesystems */
    362         mtab_ent_t *mtab_ent = malloc(sizeof(mtab_ent_t));
    363         if (!mtab_ent) {
    364                 async_answer_0(callid, ENOMEM);
    365                 async_answer_0(rid, ENOMEM);
    366                 free(mp);
    367                 free(fs_name);
    368                 free(opts);
    369                 return;
    370         }
    371 
     347       
     348        /* Acknowledge that we know fs_name. */
     349        async_answer_0(callid, EOK);
     350       
    372351        /* Do the mount */
    373         rc = vfs_mount_internal(rid, service_id, fs_handle, mp, opts);
    374         if (rc != EOK) {
    375                 async_answer_0(callid, ENOTSUP);
    376                 async_answer_0(rid, ENOTSUP);
    377                 free(mtab_ent);
    378                 free(mp);
    379                 free(opts);
    380                 free(fs_name);
    381                 return;
    382         }
    383 
    384         /* Add the filesystem info to the list of mounted filesystems */
    385 
    386         str_cpy(mtab_ent->mp, MAX_PATH_LEN, mp);
    387         str_cpy(mtab_ent->fs_name, FS_NAME_MAXLEN, fs_name);
    388         str_cpy(mtab_ent->opts, MAX_MNTOPTS_LEN, opts);
    389         mtab_ent->instance = instance;
    390         mtab_ent->service_id = service_id;
    391 
    392         link_initialize(&mtab_ent->link);
    393 
    394         fibril_mutex_lock(&mtab_list_lock);
    395         list_append(&mtab_ent->link, &mtab_list);
    396         mtab_size++;
    397         fibril_mutex_unlock(&mtab_list_lock);
    398 
     352        vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
    399353        free(mp);
    400354        free(fs_name);
    401355        free(opts);
    402 
    403         /* Acknowledge that we know fs_name. */
    404         async_answer_0(callid, EOK);
    405356}
    406357
    … …  
    458409         */
    459410        if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
    460             mr_node->service_id) != 2) {
     411            mr_node->devmap_handle) != 2) {
    461412                fibril_rwlock_write_unlock(&namespace_rwlock);
    462413                vfs_node_put(mr_node);
    … …  
    475426                 */
    476427               
     428                free(mp);
     429               
    477430                exch = vfs_exchange_grab(mr_node->fs_handle);
    478431                rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
    479                     mr_node->service_id);
     432                    mr_node->devmap_handle);
    480433                vfs_exchange_release(exch);
    481434               
    482435                if (rc != EOK) {
    483436                        fibril_rwlock_write_unlock(&namespace_rwlock);
    484                         free(mp);
    485437                        vfs_node_put(mr_node);
    486438                        async_answer_0(rid, rc);
    … …  
    489441               
    490442                rootfs.fs_handle = 0;
    491                 rootfs.service_id = 0;
     443                rootfs.devmap_handle = 0;
    492444        } else {
    493445               
    … …  
    500452               
    501453                rc = vfs_lookup_internal(mp, L_MP, &mp_res, NULL);
     454                free(mp);
    502455                if (rc != EOK) {
    503456                        fibril_rwlock_write_unlock(&namespace_rwlock);
    504                         free(mp);
    505457                        vfs_node_put(mr_node);
    506458                        async_answer_0(rid, rc);
    … …  
    511463                if (!mp_node) {
    512464                        fibril_rwlock_write_unlock(&namespace_rwlock);
    513                         free(mp);
    514465                        vfs_node_put(mr_node);
    515466                        async_answer_0(rid, ENOMEM);
    … …  
    519470                exch = vfs_exchange_grab(mp_node->fs_handle);
    520471                rc = async_req_2_0(exch, VFS_OUT_UNMOUNT,
    521                     mp_node->service_id, mp_node->index);
     472                    mp_node->devmap_handle, mp_node->index);
    522473                vfs_exchange_release(exch);
    523474               
    524475                if (rc != EOK) {
    525476                        fibril_rwlock_write_unlock(&namespace_rwlock);
    526                         free(mp);
    527477                        vfs_node_put(mp_node);
    528478                        vfs_node_put(mr_node);
    … …  
    542492         */
    543493        vfs_node_forget(mr_node);
     494       
    544495        fibril_rwlock_write_unlock(&namespace_rwlock);
    545 
    546         fibril_mutex_lock(&mtab_list_lock);
    547 
    548         int found = 0;
    549 
    550         list_foreach(mtab_list, cur) {
    551                 mtab_ent_t *mtab_ent = list_get_instance(cur, mtab_ent_t,
    552                     link);
    553 
    554                 if (str_cmp(mtab_ent->mp, mp) == 0) {
    555                         list_remove(&mtab_ent->link);
    556                         mtab_size--;
    557                         free(mtab_ent);
    558                         found = 1;
    559                         break;
    560                 }
    561         }
    562         assert(found);
    563         fibril_mutex_unlock(&mtab_list_lock);
    564 
    565         free(mp);
    566 
    567496        async_answer_0(rid, EOK);
    568497}
    … …  
    646575                if (node->size) {
    647576                        rc = vfs_truncate_internal(node->fs_handle,
    648                             node->service_id, node->index, 0);
     577                            node->devmap_handle, node->index, 0);
    649578                        if (rc) {
    650579                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    … …  
    710639        aid_t msg;
    711640        ipc_call_t answer;
    712         msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id,
     641        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->devmap_handle,
    713642            file->node->index, &answer);
    714643       
    … …  
    795724        if (read) {
    796725                rc = async_data_read_forward_4_1(fs_exch, VFS_OUT_READ,
    797                     file->node->service_id, file->node->index,
     726                    file->node->devmap_handle, file->node->index,
    798727                    LOWER32(file->pos), UPPER32(file->pos), &answer);
    799728        } else {
    … …  
    802731               
    803732                rc = async_data_write_forward_4_1(fs_exch, VFS_OUT_WRITE,
    804                     file->node->service_id, file->node->index,
     733                    file->node->devmap_handle, file->node->index,
    805734                    LOWER32(file->pos), UPPER32(file->pos), &answer);
    806735        }
    … …  
    933862}
    934863
    935 int vfs_truncate_internal(fs_handle_t fs_handle, service_id_t service_id,
     864int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
    936865    fs_index_t index, aoff64_t size)
    937866{
    938867        async_exch_t *exch = vfs_exchange_grab(fs_handle);
    939868        sysarg_t rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
    940             (sysarg_t) service_id, (sysarg_t) index, LOWER32(size),
     869            (sysarg_t) devmap_handle, (sysarg_t) index, LOWER32(size),
    941870            UPPER32(size));
    942871        vfs_exchange_release(exch);
    … …  
    961890        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    962891        rc = vfs_truncate_internal(file->node->fs_handle,
    963             file->node->service_id, file->node->index, size);
     892            file->node->devmap_handle, file->node->index, size);
    964893        if (rc == EOK)
    965894                file->node->size = size;
    … …  
    995924       
    996925        aid_t msg;
    997         msg = async_send_3(exch, VFS_OUT_STAT, file->node->service_id,
     926        msg = async_send_3(exch, VFS_OUT_STAT, file->node->devmap_handle,
    998927            file->node->index, true, NULL);
    999928        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    … …  
    1048977       
    1049978        aid_t msg;
    1050         msg = async_send_3(exch, VFS_OUT_STAT, node->service_id,
     979        msg = async_send_3(exch, VFS_OUT_STAT, node->devmap_handle,
    1051980            node->index, false, NULL);
    1052981        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    … …  
    12251154        /* Check whether linking to the same file system instance. */
    12261155        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
    1227             (old_node->service_id != new_par_lr.triplet.service_id)) {
     1156            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    12281157                fibril_rwlock_write_unlock(&namespace_rwlock);
    12291158                vfs_node_put(old_node);
    … …  
    13531282}
    13541283
    1355 void vfs_get_mtab(ipc_callid_t rid, ipc_call_t *request)
    1356 {
    1357         ipc_callid_t callid;
    1358         ipc_call_t data;
    1359         sysarg_t rc = EOK;
    1360         size_t len;
    1361 
    1362         fibril_mutex_lock(&mtab_list_lock);
    1363 
    1364         /* Send to the caller the number of mounted filesystems */
    1365         callid = async_get_call(&data);
    1366         if (IPC_GET_IMETHOD(data) != VFS_IN_PING) {
    1367                 rc = ENOTSUP;
    1368                 async_answer_0(callid, rc);
    1369                 goto exit;
    1370         }
    1371         async_answer_1(callid, EOK, mtab_size);
    1372 
    1373         list_foreach(mtab_list, cur) {
    1374                 mtab_ent_t *mtab_ent = list_get_instance(cur, mtab_ent_t,
    1375                     link);
    1376 
    1377                 rc = ENOTSUP;
    1378 
    1379                 if (!async_data_read_receive(&callid, &len)) {
    1380                         async_answer_0(callid, rc);
    1381                         goto exit;
    1382                 }
    1383 
    1384                 (void) async_data_read_finalize(callid, mtab_ent->mp,
    1385                     str_size(mtab_ent->mp));
    1386 
    1387                 if (!async_data_read_receive(&callid, &len)) {
    1388                         async_answer_0(callid, rc);
    1389                         goto exit;
    1390                 }
    1391 
    1392                 (void) async_data_read_finalize(callid, mtab_ent->opts,
    1393                     str_size(mtab_ent->opts));
    1394 
    1395                 if (!async_data_read_receive(&callid, &len)) {
    1396                         async_answer_0(callid, rc);
    1397                         goto exit;
    1398                 }
    1399 
    1400                 (void) async_data_read_finalize(callid, mtab_ent->fs_name,
    1401                     str_size(mtab_ent->fs_name));
    1402 
    1403                 callid = async_get_call(&data);
    1404 
    1405                 if (IPC_GET_IMETHOD(data) != VFS_IN_PING) {
    1406                         async_answer_0(callid, rc);
    1407                         goto exit;
    1408                 }
    1409 
    1410                 rc = EOK;
    1411                 async_answer_2(callid, rc, mtab_ent->instance,
    1412                     mtab_ent->service_id);
    1413         }
    1414 
    1415 exit:
    1416         fibril_mutex_unlock(&mtab_list_lock);
    1417         async_answer_0(rid, rc);
    1418 }
    1419 
    14201284/**
    14211285 * @}
Note: See TracChangeset for help on using the changeset viewer.