Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/devfs/devfs_ops.c

    rcfd630af r19f857a  
    3636 */
    3737
     38#include <ipc/ipc.h>
    3839#include <macros.h>
    3940#include <bool.h>
    … …  
    5354typedef struct {
    5455        devmap_handle_type_t type;
    55         devmap_handle_t handle;
     56        dev_handle_t handle;
    5657} devfs_node_t;
    5758
    5859/** Opened devices structure */
    5960typedef struct {
    60         devmap_handle_t handle;
    61         int phone;              /**< When < 0, the structure is incomplete. */
     61        dev_handle_t handle;
     62        int phone;
    6263        size_t refcount;
    6364        link_t link;
    64         fibril_condvar_t cv;    /**< Broadcast when completed. */
    6565} device_t;
    6666
    … …  
    8484{
    8585        device_t *dev = hash_table_get_instance(item, device_t, link);
    86         return (dev->handle == (devmap_handle_t) key[DEVICES_KEY_HANDLE]);
     86        return (dev->handle == (dev_handle_t) key[DEVICES_KEY_HANDLE]);
    8787}
    8888
    … …  
    9999
    100100static int devfs_node_get_internal(fs_node_t **rfn, devmap_handle_type_t type,
    101     devmap_handle_t handle)
     101    dev_handle_t handle)
    102102{
    103103        devfs_node_t *node = (devfs_node_t *) malloc(sizeof(devfs_node_t));
    … …  
    122122}
    123123
    124 static int devfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
     124static int devfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
    125125{
    126126        return devfs_node_get_internal(rfn, DEV_HANDLE_NONE, 0);
    … …  
    130130{
    131131        devfs_node_t *node = (devfs_node_t *) pfn->data;
    132         int ret;
    133132       
    134133        if (node->handle == 0) {
    … …  
    146145                               
    147146                                if (str_cmp(devs[pos].name, component) == 0) {
    148                                         ret = devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
    149147                                        free(devs);
    150                                         return ret;
     148                                        return devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
    151149                                }
    152150                        }
    … …  
    156154               
    157155                /* Search root namespace */
    158                 devmap_handle_t namespace;
     156                dev_handle_t namespace;
    159157                if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
    160158                        count = devmap_get_devices(namespace, &devs);
    … …  
    164162                                for (pos = 0; pos < count; pos++) {
    165163                                        if (str_cmp(devs[pos].name, component) == 0) {
    166                                                 ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    167164                                                free(devs);
    168                                                 return ret;
     165                                                return devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    169166                                        }
    170167                                }
    … …  
    187184                        for (pos = 0; pos < count; pos++) {
    188185                                if (str_cmp(devs[pos].name, component) == 0) {
    189                                         ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    190186                                        free(devs);
    191                                         return ret;
     187                                        return devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    192188                                }
    193189                        }
    … …  
    204200}
    205201
    206 static int devfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
     202static int devfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
    207203{
    208204        return devfs_node_get_internal(rfn, devmap_handle_probe(index), index);
    … …  
    231227                        [DEVICES_KEY_HANDLE] = (unsigned long) node->handle
    232228                };
    233                 link_t *lnk;
    234 
     229               
    235230                fibril_mutex_lock(&devices_mutex);
    236 restart:
    237                 lnk = hash_table_find(&devices, key);
     231                link_t *lnk = hash_table_find(&devices, key);
    238232                if (lnk == NULL) {
    239233                        device_t *dev = (device_t *) malloc(sizeof(device_t));
    … …  
    243237                        }
    244238                       
    245                         dev->handle = node->handle;
    246                         dev->phone = -1;        /* mark as incomplete */
    247                         dev->refcount = 1;
    248                         fibril_condvar_initialize(&dev->cv);
    249 
    250                         /*
    251                          * Insert the incomplete device structure so that other
    252                          * fibrils will not race with us when we drop the mutex
    253                          * below.
    254                          */
    255                         hash_table_insert(&devices, key, &dev->link);
    256 
    257                         /*
    258                          * Drop the mutex to allow recursive devfs requests.
    259                          */
    260                         fibril_mutex_unlock(&devices_mutex);
    261 
    262239                        int phone = devmap_device_connect(node->handle, 0);
    263 
    264                         fibril_mutex_lock(&devices_mutex);
    265 
    266                         /*
    267                          * Notify possible waiters about this device structure
    268                          * being completed (or destroyed).
    269                          */
    270                         fibril_condvar_broadcast(&dev->cv);
    271 
    272240                        if (phone < 0) {
    273                                 /*
    274                                  * Connecting failed, need to remove the
    275                                  * entry and free the device structure.
    276                                  */
    277                                 hash_table_remove(&devices, key, DEVICES_KEYS);
    278241                                fibril_mutex_unlock(&devices_mutex);
    279 
     242                                free(dev);
    280243                                return ENOENT;
    281244                        }
    282245                       
    283                         /* Set the correct phone. */
     246                        dev->handle = node->handle;
    284247                        dev->phone = phone;
     248                        dev->refcount = 1;
     249                       
     250                        hash_table_insert(&devices, key, &dev->link);
    285251                } else {
    286252                        device_t *dev = hash_table_get_instance(lnk, device_t, link);
    287 
    288                         if (dev->phone < 0) {
    289                                 /*
    290                                  * Wait until the device structure is completed
    291                                  * and start from the beginning as the device
    292                                  * structure might have entirely disappeared
    293                                  * while we were not holding the mutex in
    294                                  * fibril_condvar_wait().
    295                                  */
    296                                 fibril_condvar_wait(&dev->cv, &devices_mutex);
    297                                 goto restart;
    298                         }
    299 
    300253                        dev->refcount++;
    301254                }
    … …  
    316269}
    317270
    318 static int devfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
     271static int devfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
    319272{
    320273        assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
    … …  
    351304               
    352305                /* Root namespace */
    353                 devmap_handle_t namespace;
     306                dev_handle_t namespace;
    354307                if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
    355308                        count = devmap_count_devices(namespace);
    … …  
    419372}
    420373
    421 static devmap_handle_t devfs_device_get(fs_node_t *fn)
     374static dev_handle_t devfs_device_get(fs_node_t *fn)
    422375{
    423376        devfs_node_t *node = (devfs_node_t *) fn->data;
    … …  
    456409                return false;
    457410       
     411        if (devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING) < 0)
     412                return false;
     413       
    458414        return true;
    459415}
    … …  
    464420       
    465421        /* Accept the mount options */
    466         sysarg_t retval = async_data_write_accept((void **) &opts, true, 0, 0,
     422        ipcarg_t retval = async_data_write_accept((void **) &opts, true, 0, 0,
    467423            0, NULL);
    468424        if (retval != EOK) {
    469                 async_answer_0(rid, retval);
     425                ipc_answer_0(rid, retval);
    470426                return;
    471427        }
    472428       
    473429        free(opts);
    474         async_answer_3(rid, EOK, 0, 0, 0);
     430        ipc_answer_3(rid, EOK, 0, 0, 0);
    475431}
    476432
    … …  
    482438void devfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    483439{
    484         async_answer_0(rid, ENOTSUP);
     440        ipc_answer_0(rid, ENOTSUP);
    485441}
    486442
    … …  
    515471                size_t size;
    516472                if (!async_data_read_receive(&callid, &size)) {
    517                         async_answer_0(callid, EINVAL);
    518                         async_answer_0(rid, EINVAL);
     473                        ipc_answer_0(callid, EINVAL);
     474                        ipc_answer_0(rid, EINVAL);
    519475                        return;
    520476                }
    … …  
    537493                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    538494                        free(desc);
    539                         async_answer_1(rid, EOK, 1);
     495                        ipc_answer_1(rid, EOK, 1);
    540496                        return;
    541497                }
    … …  
    545501               
    546502                /* Search root namespace */
    547                 devmap_handle_t namespace;
     503                dev_handle_t namespace;
    548504                if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
    549505                        count = devmap_get_devices(namespace, &desc);
    … …  
    552508                                async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    553509                                free(desc);
    554                                 async_answer_1(rid, EOK, 1);
     510                                ipc_answer_1(rid, EOK, 1);
    555511                                return;
    556512                        }
    … …  
    559515                }
    560516               
    561                 async_answer_0(callid, ENOENT);
    562                 async_answer_1(rid, ENOENT, 0);
     517                ipc_answer_0(callid, ENOENT);
     518                ipc_answer_1(rid, ENOENT, 0);
    563519                return;
    564520        }
    … …  
    571527                size_t size;
    572528                if (!async_data_read_receive(&callid, &size)) {
    573                         async_answer_0(callid, EINVAL);
    574                         async_answer_0(rid, EINVAL);
     529                        ipc_answer_0(callid, EINVAL);
     530                        ipc_answer_0(rid, EINVAL);
    575531                        return;
    576532                }
    … …  
    582538                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    583539                        free(desc);
    584                         async_answer_1(rid, EOK, 1);
     540                        ipc_answer_1(rid, EOK, 1);
    585541                        return;
    586542                }
    587543               
    588544                free(desc);
    589                 async_answer_0(callid, ENOENT);
    590                 async_answer_1(rid, ENOENT, 0);
     545                ipc_answer_0(callid, ENOENT);
     546                ipc_answer_1(rid, ENOENT, 0);
    591547                return;
    592548        }
    … …  
    603559                if (lnk == NULL) {
    604560                        fibril_mutex_unlock(&devices_mutex);
    605                         async_answer_0(rid, ENOENT);
     561                        ipc_answer_0(rid, ENOENT);
    606562                        return;
    607563                }
    608564               
    609565                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    610                 assert(dev->phone >= 0);
    611566               
    612567                ipc_callid_t callid;
    613568                if (!async_data_read_receive(&callid, NULL)) {
    614569                        fibril_mutex_unlock(&devices_mutex);
    615                         async_answer_0(callid, EINVAL);
    616                         async_answer_0(rid, EINVAL);
     570                        ipc_answer_0(callid, EINVAL);
     571                        ipc_answer_0(rid, EINVAL);
    617572                        return;
    618573                }
    … …  
    620575                /* Make a request at the driver */
    621576                ipc_call_t answer;
    622                 aid_t msg = async_send_3(dev->phone, IPC_GET_IMETHOD(*request),
     577                aid_t msg = async_send_3(dev->phone, IPC_GET_METHOD(*request),
    623578                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
    624579                    IPC_GET_ARG3(*request), &answer);
    625580               
    626581                /* Forward the IPC_M_DATA_READ request to the driver */
    627                 async_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     582                ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    628583                fibril_mutex_unlock(&devices_mutex);
    629584               
    630585                /* Wait for reply from the driver. */
    631                 sysarg_t rc;
     586                ipcarg_t rc;
    632587                async_wait_for(msg, &rc);
    633588                size_t bytes = IPC_GET_ARG1(answer);
    634589               
    635590                /* Driver reply is the final result of the whole operation */
    636                 async_answer_1(rid, rc, bytes);
    637                 return;
    638         }
    639        
    640         async_answer_0(rid, ENOENT);
     591                ipc_answer_1(rid, rc, bytes);
     592                return;
     593        }
     594       
     595        ipc_answer_0(rid, ENOENT);
    641596}
    642597
    … …  
    645600        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    646601        if (index == 0) {
    647                 async_answer_0(rid, ENOTSUP);
     602                ipc_answer_0(rid, ENOTSUP);
    648603                return;
    649604        }
    … …  
    653608        if (type == DEV_HANDLE_NAMESPACE) {
    654609                /* Namespace directory */
    655                 async_answer_0(rid, ENOTSUP);
     610                ipc_answer_0(rid, ENOTSUP);
    656611                return;
    657612        }
    … …  
    667622                if (lnk == NULL) {
    668623                        fibril_mutex_unlock(&devices_mutex);
    669                         async_answer_0(rid, ENOENT);
     624                        ipc_answer_0(rid, ENOENT);
    670625                        return;
    671626                }
    672627               
    673628                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    674                 assert(dev->phone >= 0);
    675629               
    676630                ipc_callid_t callid;
    677631                if (!async_data_write_receive(&callid, NULL)) {
    678632                        fibril_mutex_unlock(&devices_mutex);
    679                         async_answer_0(callid, EINVAL);
    680                         async_answer_0(rid, EINVAL);
     633                        ipc_answer_0(callid, EINVAL);
     634                        ipc_answer_0(rid, EINVAL);
    681635                        return;
    682636                }
    … …  
    684638                /* Make a request at the driver */
    685639                ipc_call_t answer;
    686                 aid_t msg = async_send_3(dev->phone, IPC_GET_IMETHOD(*request),
     640                aid_t msg = async_send_3(dev->phone, IPC_GET_METHOD(*request),
    687641                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
    688642                    IPC_GET_ARG3(*request), &answer);
    689643               
    690644                /* Forward the IPC_M_DATA_WRITE request to the driver */
    691                 async_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     645                ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    692646               
    693647                fibril_mutex_unlock(&devices_mutex);
    694648               
    695649                /* Wait for reply from the driver. */
    696                 sysarg_t rc;
     650                ipcarg_t rc;
    697651                async_wait_for(msg, &rc);
    698652                size_t bytes = IPC_GET_ARG1(answer);
    699653               
    700654                /* Driver reply is the final result of the whole operation */
    701                 async_answer_1(rid, rc, bytes);
    702                 return;
    703         }
    704        
    705         async_answer_0(rid, ENOENT);
     655                ipc_answer_1(rid, rc, bytes);
     656                return;
     657        }
     658       
     659        ipc_answer_0(rid, ENOENT);
    706660}
    707661
    708662void devfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    709663{
    710         async_answer_0(rid, ENOTSUP);
     664        ipc_answer_0(rid, ENOTSUP);
    711665}
    712666
    … …  
    716670       
    717671        if (index == 0) {
    718                 async_answer_0(rid, EOK);
     672                ipc_answer_0(rid, EOK);
    719673                return;
    720674        }
    … …  
    724678        if (type == DEV_HANDLE_NAMESPACE) {
    725679                /* Namespace directory */
    726                 async_answer_0(rid, EOK);
     680                ipc_answer_0(rid, EOK);
    727681                return;
    728682        }
    … …  
    737691                if (lnk == NULL) {
    738692                        fibril_mutex_unlock(&devices_mutex);
    739                         async_answer_0(rid, ENOENT);
     693                        ipc_answer_0(rid, ENOENT);
    740694                        return;
    741695                }
    742696               
    743697                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    744                 assert(dev->phone >= 0);
    745698                dev->refcount--;
    746699               
    747700                if (dev->refcount == 0) {
    748                         async_hangup(dev->phone);
     701                        ipc_hangup(dev->phone);
    749702                        hash_table_remove(&devices, key, DEVICES_KEYS);
    750703                }
    … …  
    752705                fibril_mutex_unlock(&devices_mutex);
    753706               
    754                 async_answer_0(rid, EOK);
    755                 return;
    756         }
    757        
    758         async_answer_0(rid, ENOENT);
     707                ipc_answer_0(rid, EOK);
     708                return;
     709        }
     710       
     711        ipc_answer_0(rid, ENOENT);
    759712}
    760713
    … …  
    764717       
    765718        if (index == 0) {
    766                 async_answer_0(rid, EOK);
     719                ipc_answer_0(rid, EOK);
    767720                return;
    768721        }
    … …  
    772725        if (type == DEV_HANDLE_NAMESPACE) {
    773726                /* Namespace directory */
    774                 async_answer_0(rid, EOK);
     727                ipc_answer_0(rid, EOK);
    775728                return;
    776729        }
    … …  
    785738                if (lnk == NULL) {
    786739                        fibril_mutex_unlock(&devices_mutex);
    787                         async_answer_0(rid, ENOENT);
     740                        ipc_answer_0(rid, ENOENT);
    788741                        return;
    789742                }
    790743               
    791744                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    792                 assert(dev->phone >= 0);
    793745               
    794746                /* Make a request at the driver */
    795747                ipc_call_t answer;
    796                 aid_t msg = async_send_2(dev->phone, IPC_GET_IMETHOD(*request),
     748                aid_t msg = async_send_2(dev->phone, IPC_GET_METHOD(*request),
    797749                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), &answer);
    798750               
    … …  
    800752               
    801753                /* Wait for reply from the driver */
    802                 sysarg_t rc;
     754                ipcarg_t rc;
    803755                async_wait_for(msg, &rc);
    804756               
    805757                /* Driver reply is the final result of the whole operation */
    806                 async_answer_0(rid, rc);
    807                 return;
    808         }
    809        
    810         async_answer_0(rid, ENOENT);
     758                ipc_answer_0(rid, rc);
     759                return;
     760        }
     761       
     762        ipc_answer_0(rid, ENOENT);
    811763}
    812764
    813765void devfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    814766{
    815         async_answer_0(rid, ENOTSUP);
     767        ipc_answer_0(rid, ENOTSUP);
    816768}
    817769
Note: See TracChangeset for help on using the changeset viewer.