Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/devfs/devfs_ops.c

    r79ae36dd rcfd630af  
    5959typedef struct {
    6060        devmap_handle_t handle;
    61         async_sess_t *sess;       /**< If NULL, the structure is incomplete. */
     61        int phone;              /**< When < 0, the structure is incomplete. */
    6262        size_t refcount;
    6363        link_t link;
    64         fibril_condvar_t cv;      /**< Broadcast when completed. */
     64        fibril_condvar_t cv;    /**< Broadcast when completed. */
    6565} device_t;
    6666
     
    232232                };
    233233                link_t *lnk;
    234                
     234
    235235                fibril_mutex_lock(&devices_mutex);
    236236restart:
     
    244244                       
    245245                        dev->handle = node->handle;
    246                        
    247                         /* Mark as incomplete */
    248                         dev->sess = NULL;
     246                        dev->phone = -1;        /* mark as incomplete */
    249247                        dev->refcount = 1;
    250248                        fibril_condvar_initialize(&dev->cv);
    251                        
     249
    252250                        /*
    253251                         * Insert the incomplete device structure so that other
     
    256254                         */
    257255                        hash_table_insert(&devices, key, &dev->link);
    258                        
     256
    259257                        /*
    260258                         * Drop the mutex to allow recursive devfs requests.
    261259                         */
    262260                        fibril_mutex_unlock(&devices_mutex);
    263                        
    264                         async_sess_t *sess = devmap_device_connect(EXCHANGE_SERIALIZE,
    265                             node->handle, 0);
    266                        
     261
     262                        int phone = devmap_device_connect(node->handle, 0);
     263
    267264                        fibril_mutex_lock(&devices_mutex);
    268                        
     265
    269266                        /*
    270267                         * Notify possible waiters about this device structure
     
    272269                         */
    273270                        fibril_condvar_broadcast(&dev->cv);
    274                        
    275                         if (!sess) {
     271
     272                        if (phone < 0) {
    276273                                /*
    277274                                 * Connecting failed, need to remove the
     
    280277                                hash_table_remove(&devices, key, DEVICES_KEYS);
    281278                                fibril_mutex_unlock(&devices_mutex);
    282                                
     279
    283280                                return ENOENT;
    284281                        }
    285282                       
    286                         /* Set the correct session. */
    287                         dev->sess = sess;
     283                        /* Set the correct phone. */
     284                        dev->phone = phone;
    288285                } else {
    289286                        device_t *dev = hash_table_get_instance(lnk, device_t, link);
    290                        
    291                         if (!dev->sess) {
     287
     288                        if (dev->phone < 0) {
    292289                                /*
    293290                                 * Wait until the device structure is completed
     
    611608               
    612609                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    613                 assert(dev->sess);
     610                assert(dev->phone >= 0);
    614611               
    615612                ipc_callid_t callid;
     
    622619               
    623620                /* Make a request at the driver */
    624                 async_exch_t *exch = async_exchange_begin(dev->sess);
    625                
    626621                ipc_call_t answer;
    627                 aid_t msg = async_send_3(exch, IPC_GET_IMETHOD(*request),
     622                aid_t msg = async_send_3(dev->phone, IPC_GET_IMETHOD(*request),
    628623                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
    629624                    IPC_GET_ARG3(*request), &answer);
    630625               
    631626                /* Forward the IPC_M_DATA_READ request to the driver */
    632                 async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    633                
    634                 async_exchange_end(exch);
    635                
     627                async_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    636628                fibril_mutex_unlock(&devices_mutex);
    637629               
     
    680672               
    681673                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    682                 assert(dev->sess);
     674                assert(dev->phone >= 0);
    683675               
    684676                ipc_callid_t callid;
     
    691683               
    692684                /* Make a request at the driver */
    693                 async_exch_t *exch = async_exchange_begin(dev->sess);
    694                
    695685                ipc_call_t answer;
    696                 aid_t msg = async_send_3(exch, IPC_GET_IMETHOD(*request),
     686                aid_t msg = async_send_3(dev->phone, IPC_GET_IMETHOD(*request),
    697687                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
    698688                    IPC_GET_ARG3(*request), &answer);
    699689               
    700690                /* Forward the IPC_M_DATA_WRITE request to the driver */
    701                 async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    702                
    703                 async_exchange_end(exch);
     691                async_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    704692               
    705693                fibril_mutex_unlock(&devices_mutex);
     
    754742               
    755743                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    756                 assert(dev->sess);
     744                assert(dev->phone >= 0);
    757745                dev->refcount--;
    758746               
    759747                if (dev->refcount == 0) {
    760                         async_hangup(dev->sess);
     748                        async_hangup(dev->phone);
    761749                        hash_table_remove(&devices, key, DEVICES_KEYS);
    762750                }
     
    802790               
    803791                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    804                 assert(dev->sess);
     792                assert(dev->phone >= 0);
    805793               
    806794                /* Make a request at the driver */
    807                 async_exch_t *exch = async_exchange_begin(dev->sess);
    808                
    809795                ipc_call_t answer;
    810                 aid_t msg = async_send_2(exch, IPC_GET_IMETHOD(*request),
     796                aid_t msg = async_send_2(dev->phone, IPC_GET_IMETHOD(*request),
    811797                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), &answer);
    812                
    813                 async_exchange_end(exch);
    814798               
    815799                fibril_mutex_unlock(&devices_mutex);
Note: See TracChangeset for help on using the changeset viewer.