Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7ea7db31 r991f645  
    6060typedef struct {
    6161        devmap_handle_t handle;
    62         int phone;              /**< When < 0, the structure is incomplete. */
     62        int phone;
    6363        size_t refcount;
    6464        link_t link;
    65         fibril_condvar_t cv;    /**< Broadcast when completed. */
    6665} device_t;
    6766
    … …  
    228227                        [DEVICES_KEY_HANDLE] = (unsigned long) node->handle
    229228                };
    230                 link_t *lnk;
    231 
     229               
    232230                fibril_mutex_lock(&devices_mutex);
    233 restart:
    234                 lnk = hash_table_find(&devices, key);
     231                link_t *lnk = hash_table_find(&devices, key);
    235232                if (lnk == NULL) {
    236233                        device_t *dev = (device_t *) malloc(sizeof(device_t));
    … …  
    240237                        }
    241238                       
    242                         dev->handle = node->handle;
    243                         dev->phone = -1;        /* mark as incomplete */
    244                         dev->refcount = 1;
    245                         fibril_condvar_initialize(&dev->cv);
    246 
    247                         /*
    248                          * Insert the incomplete device structure so that other
    249                          * fibrils will not race with us when we drop the mutex
    250                          * below.
    251                          */
    252                         hash_table_insert(&devices, key, &dev->link);
    253 
    254                         /*
    255                          * Drop the mutex to allow recursive devfs requests.
    256                          */
    257                         fibril_mutex_unlock(&devices_mutex);
    258 
    259239                        int phone = devmap_device_connect(node->handle, 0);
    260 
    261                         fibril_mutex_lock(&devices_mutex);
    262 
    263                         /*
    264                          * Notify possible waiters about this device structure
    265                          * being completed (or destroyed).
    266                          */
    267                         fibril_condvar_broadcast(&dev->cv);
    268 
    269240                        if (phone < 0) {
    270                                 /*
    271                                  * Connecting failed, need to remove the
    272                                  * entry and free the device structure.
    273                                  */
    274                                 hash_table_remove(&devices, key, DEVICES_KEYS);
    275241                                fibril_mutex_unlock(&devices_mutex);
    276 
    277242                                free(dev);
    278243                                return ENOENT;
    279244                        }
    280245                       
    281                         /* Set the correct phone. */
     246                        dev->handle = node->handle;
    282247                        dev->phone = phone;
     248                        dev->refcount = 1;
     249                       
     250                        hash_table_insert(&devices, key, &dev->link);
    283251                } else {
    284252                        device_t *dev = hash_table_get_instance(lnk, device_t, link);
    285 
    286                         if (dev->phone < 0) {
    287                                 /*
    288                                  * Wait until the device structure is completed
    289                                  * and start from the beginning as the device
    290                                  * structure might have entirely disappeared
    291                                  * while we were not holding the mutex in
    292                                  * fibril_condvar_wait().
    293                                  */
    294                                 fibril_condvar_wait(&dev->cv, &devices_mutex);
    295                                 goto restart;
    296                         }
    297 
    298253                        dev->refcount++;
    299254                }
    … …  
    454409                return false;
    455410       
     411        if (devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING) < 0)
     412                return false;
     413       
    456414        return true;
    457415}
    … …  
    462420       
    463421        /* Accept the mount options */
    464         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,
    465423            0, NULL);
    466424        if (retval != EOK) {
    … …  
    606564               
    607565                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    608                 assert(dev->phone >= 0);
    609566               
    610567                ipc_callid_t callid;
    … …  
    618575                /* Make a request at the driver */
    619576                ipc_call_t answer;
    620                 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),
    621578                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
    622579                    IPC_GET_ARG3(*request), &answer);
    … …  
    627584               
    628585                /* Wait for reply from the driver. */
    629                 sysarg_t rc;
     586                ipcarg_t rc;
    630587                async_wait_for(msg, &rc);
    631588                size_t bytes = IPC_GET_ARG1(answer);
    … …  
    670627               
    671628                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    672                 assert(dev->phone >= 0);
    673629               
    674630                ipc_callid_t callid;
    … …  
    682638                /* Make a request at the driver */
    683639                ipc_call_t answer;
    684                 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),
    685641                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
    686642                    IPC_GET_ARG3(*request), &answer);
    … …  
    692648               
    693649                /* Wait for reply from the driver. */
    694                 sysarg_t rc;
     650                ipcarg_t rc;
    695651                async_wait_for(msg, &rc);
    696652                size_t bytes = IPC_GET_ARG1(answer);
    … …  
    740696               
    741697                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    742                 assert(dev->phone >= 0);
    743698                dev->refcount--;
    744699               
    … …  
    788743               
    789744                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    790                 assert(dev->phone >= 0);
    791745               
    792746                /* Make a request at the driver */
    793747                ipc_call_t answer;
    794                 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),
    795749                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), &answer);
    796750               
    … …  
    798752               
    799753                /* Wait for reply from the driver */
    800                 sysarg_t rc;
     754                ipcarg_t rc;
    801755                async_wait_for(msg, &rc);
    802756               
Note: See TracChangeset for help on using the changeset viewer.