Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset fc02cc41 in mainline


Ignore:
Timestamp:
2009-06-10T19:15:00Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
ba2a055
Parents:
95ba2b8
Message:

get back fine-grained locking (which was removed in commit 4458), but this time with proper fibril synchronization

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/devmap/devmap.c

    r95ba2b8 rfc02cc41  
    4242#include <errno.h>
    4343#include <bool.h>
     44#include <fibril_sync.h>
    4445#include <stdlib.h>
    4546#include <string.h>
     
    6263        /** Device driver name */
    6364        char *name;
     65        /** Fibril mutex for list of devices owned by this driver */
     66        fibril_mutex_t devices_mutex;
    6467} devmap_driver_t;
    6568
     
    9295LIST_INITIALIZE(pending_req);
    9396
     97/* Locking order:
     98 *  drivers_list_mutex
     99 *  devices_list_mutex
     100 *  (devmap_driver_t *)->devices_mutex
     101 *  create_handle_mutex
     102 **/
     103
     104static FIBRIL_MUTEX_INITIALIZE(devices_list_mutex);
     105static FIBRIL_MUTEX_INITIALIZE(drivers_list_mutex);
     106static FIBRIL_MUTEX_INITIALIZE(create_handle_mutex);
     107
    94108static dev_handle_t last_handle = 0;
    95109
     
    100114         */
    101115       
     116        fibril_mutex_lock(&create_handle_mutex);
    102117        last_handle++;
     118        fibril_mutex_unlock(&create_handle_mutex);
    103119       
    104120        return last_handle;
     
    134150static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
    135151{
     152        fibril_mutex_lock(&devices_list_mutex);
     153       
    136154        link_t *item = (&devices_list)->next;
    137155        devmap_device_t *device = NULL;
     
    144162        }
    145163       
    146         if (item == &devices_list)
     164        if (item == &devices_list) {
     165                fibril_mutex_unlock(&devices_list_mutex);
    147166                return NULL;
     167        }
    148168       
    149169        device = list_get_instance(item, devmap_device_t, devices);
     170       
     171        fibril_mutex_unlock(&devices_list_mutex);
    150172       
    151173        return device;
     
    236258        driver->name[name_size] = 0;
    237259       
     260        /* Initialize mutex for list of devices owned by this driver */
     261        fibril_mutex_initialize(&driver->devices_mutex);
     262       
    238263        /*
    239264         * Initialize list of asociated devices
    240265         */
    241         list_initialize(&(driver->devices));
     266        list_initialize(&driver->devices);
    242267       
    243268        /*
     
    262287        list_initialize(&(driver->drivers));
    263288       
     289        fibril_mutex_lock(&drivers_list_mutex);
     290       
    264291        /* TODO:
    265292         * check that no driver with name equal to driver->name is registered
     
    270297         */
    271298        list_append(&(driver->drivers), &drivers_list);
     299        fibril_mutex_unlock(&drivers_list_mutex);
    272300       
    273301        ipc_answer_0(iid, EOK);
     
    286314                return EEXISTS;
    287315       
     316        fibril_mutex_lock(&drivers_list_mutex);
     317       
    288318        if (driver->phone != 0)
    289319                ipc_hangup(driver->phone);
     
    291321        /* Remove it from list of drivers */
    292322        list_remove(&(driver->drivers));
     323       
     324        /* Unregister all its devices */
     325        fibril_mutex_lock(&devices_list_mutex);
     326        fibril_mutex_lock(&driver->devices_mutex);
    293327       
    294328        while (!list_empty(&(driver->devices))) {
     
    298332        }
    299333       
     334        fibril_mutex_unlock(&driver->devices_mutex);
     335        fibril_mutex_unlock(&devices_list_mutex);
     336        fibril_mutex_unlock(&drivers_list_mutex);
     337       
    300338        /* free name and driver */
    301339        if (driver->name != NULL)
     
    311349static void process_pending_lookup(void)
    312350{
    313         async_serialize_start();
    314        
    315351        link_t *cur;
    316352       
     
    331367                goto loop;
    332368        }
    333        
    334         async_serialize_end();
    335369}
    336370
     
    386420        list_initialize(&(device->driver_devices));
    387421       
     422        fibril_mutex_lock(&devices_list_mutex);
     423       
    388424        /* Check that device with such name is not already registered */
    389425        if (NULL != devmap_device_find_name(device->name)) {
    390426                printf(NAME ": Device '%s' already registered\n", device->name);
     427                fibril_mutex_unlock(&devices_list_mutex);
    391428                free(device->name);
    392429                free(device);
     
    403440        list_append(&device->devices, &devices_list);
    404441       
     442        /* Insert device into list of devices that belog to one driver */
     443        fibril_mutex_lock(&device->driver->devices_mutex);
     444       
    405445        list_append(&device->driver_devices, &device->driver->devices);
     446       
     447        fibril_mutex_unlock(&device->driver->devices_mutex);
     448        fibril_mutex_unlock(&devices_list_mutex);
    406449       
    407450        ipc_answer_1(iid, EOK, device->handle);
     
    556599static void devmap_get_count(ipc_callid_t iid, ipc_call_t *icall)
    557600{
     601        fibril_mutex_lock(&devices_list_mutex);
    558602        ipc_answer_1(iid, EOK, list_count(&devices_list));
     603        fibril_mutex_unlock(&devices_list_mutex);
    559604}
    560605
    561606static void devmap_get_devices(ipc_callid_t iid, ipc_call_t *icall)
    562607{
     608        fibril_mutex_lock(&devices_list_mutex);
     609       
    563610        ipc_callid_t callid;
    564611        size_t size;
     
    604651        free(desc);
    605652       
     653        fibril_mutex_unlock(&devices_list_mutex);
     654       
    606655        ipc_answer_1(iid, EOK, pos);
    607656}
     
    627676        list_initialize(&(device->driver_devices));
    628677       
     678        fibril_mutex_lock(&devices_list_mutex);
     679       
    629680        /* Get unique device handle */
    630681        device->handle = devmap_create_handle();
     
    633684        /* Insert device into list of all devices  */
    634685        list_append(&device->devices, &devices_list);
     686       
     687        fibril_mutex_unlock(&devices_list_mutex);
    635688       
    636689        return true;
     
    656709                ipc_callid_t callid = async_get_call(&call);
    657710               
    658                 async_serialize_start();
    659                
    660711                switch (IPC_GET_METHOD(call)) {
    661712                case IPC_M_PHONE_HUNGUP:
    662713                        cont = false;
    663                         async_serialize_end();
    664714                        continue;
    665715                case DEVMAP_DRIVER_UNREGISTER:
     
    687737                                ipc_answer_0(callid, ENOENT);
    688738                }
    689                
    690                 async_serialize_end();
    691739        }
    692740       
     
    695743                 * Unregister the device driver and all its devices.
    696744                 */
    697                
    698                 async_serialize_start();
    699                
    700745                devmap_driver_unregister(driver);
    701746                driver = NULL;
    702                
    703                 async_serialize_end();
    704747        }
    705748}
     
    718761                ipc_callid_t callid = async_get_call(&call);
    719762               
    720                 async_serialize_start();
    721                
    722763                switch (IPC_GET_METHOD(call)) {
    723764                case IPC_M_PHONE_HUNGUP:
    724765                        cont = false;
    725                         async_serialize_end();
    726766                        continue;
    727767                case DEVMAP_DEVICE_GET_HANDLE:
     
    741781                                ipc_answer_0(callid, ENOENT);
    742782                }
    743                
    744                 async_serialize_end();
    745783        }
    746784}
Note: See TracChangeset for help on using the changeset viewer.