Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    re6da6d5 rc69646f8  
    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. */
    … …  
    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, service_id_t service_id,
    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               
    … …  
    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                       
    … …  
    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;
     175                        return;
    182176                }
    183177        }
    … …  
    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;
     223                return;
    230224        }
    231225       
    … …  
    263257        async_answer_0(rid, rc);
    264258        fibril_rwlock_write_unlock(&namespace_rwlock);
    265         return rc;
    266259}
    267260
    … …  
    283276       
    284277        /*
    285          * Instance number is passed as ARG3.
    286          */
    287         unsigned int instance = IPC_GET_ARG3(*request);
    288 
     278         * For now, don't make use of ARG3, but it can be used to
     279         * carry mount options in the future.
     280         */
     281       
    289282        /* We want the client to send us the mount point. */
    290283        char *mp;
    … …  
    342335        fs_handle_t fs_handle;
    343336recheck:
    344         fs_handle = fs_name_to_handle(instance, fs_name, false);
     337        fs_handle = fs_name_to_handle(fs_name, false);
    345338        if (!fs_handle) {
    346339                if (flags & IPC_FLAG_BLOCKING) {
    … …  
    358351        }
    359352        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 
     353       
     354        /* Acknowledge that we know fs_name. */
     355        async_answer_0(callid, EOK);
     356       
    372357        /* 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 
     358        vfs_mount_internal(rid, service_id, fs_handle, mp, opts);
    399359        free(mp);
    400360        free(fs_name);
    401361        free(opts);
    402 
    403         /* Acknowledge that we know fs_name. */
    404         async_answer_0(callid, EOK);
    405362}
    406363
    … …  
    475432                 */
    476433               
     434                free(mp);
     435               
    477436                exch = vfs_exchange_grab(mr_node->fs_handle);
    478437                rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
    … …  
    482441                if (rc != EOK) {
    483442                        fibril_rwlock_write_unlock(&namespace_rwlock);
    484                         free(mp);
    485443                        vfs_node_put(mr_node);
    486444                        async_answer_0(rid, rc);
    … …  
    500458               
    501459                rc = vfs_lookup_internal(mp, L_MP, &mp_res, NULL);
     460                free(mp);
    502461                if (rc != EOK) {
    503462                        fibril_rwlock_write_unlock(&namespace_rwlock);
    504                         free(mp);
    505463                        vfs_node_put(mr_node);
    506464                        async_answer_0(rid, rc);
    … …  
    511469                if (!mp_node) {
    512470                        fibril_rwlock_write_unlock(&namespace_rwlock);
    513                         free(mp);
    514471                        vfs_node_put(mr_node);
    515472                        async_answer_0(rid, ENOMEM);
    … …  
    524481                if (rc != EOK) {
    525482                        fibril_rwlock_write_unlock(&namespace_rwlock);
    526                         free(mp);
    527483                        vfs_node_put(mp_node);
    528484                        vfs_node_put(mr_node);
    … …  
    542498         */
    543499        vfs_node_forget(mr_node);
     500       
    544501        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 
    567502        async_answer_0(rid, EOK);
    568503}
    … …  
    13531288}
    13541289
    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 
    14201290/**
    14211291 * @}
Note: See TracChangeset for help on using the changeset viewer.