Changes in / [ab49a0d:8dd039a] in mainline


Ignore:
Files:
4 added
22 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/ddi/irq.h

    rab49a0d r8dd039a  
    189189extern hash_table_t irq_uspace_hash_table;
    190190
    191 extern inr_t last_inr;
    192 
    193191extern void irq_init(size_t, size_t);
    194192extern void irq_initialize(irq_t *);

  • kernel/generic/src/ddi/irq.c

    rab49a0d r8dd039a  
    136136static size_t buckets;
    137137
    138 /** Last valid INR. */
    139 inr_t last_inr = 0;
    140 
    141138/** Initialize IRQ subsystem.
    142139 *
    … …  
    148145{
    149146        buckets = chains;
    150         last_inr = inrs - 1;
    151 
    152147        /*
    153148         * Be smart about the choice of the hash table operations.

  • kernel/generic/src/ipc/irq.c

    rab49a0d r8dd039a  
    131131/** Register an answerbox as a receiving end for IRQ notifications.
    132132 *
    133  * @param box           Receiving answerbox.
    134  * @param inr           IRQ number.
    135  * @param devno         Device number.
    136  * @param imethod       Interface and method to be associated with the
    137  *                      notification.
    138  * @param ucode         Uspace pointer to top-half pseudocode.
    139  * @return              EOK on success or a negative error code.
     133 * @param box     Receiving answerbox.
     134 * @param inr     IRQ number.
     135 * @param devno   Device number.
     136 * @param imethod Interface and method to be associated
     137 *                with the notification.
     138 * @param ucode   Uspace pointer to top-half pseudocode.
     139 *
     140 * @return EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
    140141 *
    141142 */
    … …  
    147148                (sysarg_t) devno
    148149        };
    149 
    150         if ((inr < 0) || (inr > last_inr))
    151                 return ELIMIT;
    152150       
    153151        irq_code_t *code;
    … …  
    210208/** Unregister task from IRQ notification.
    211209 *
    212  * @param box           Answerbox associated with the notification.
    213  * @param inr           IRQ number.
    214  * @param devno         Device number.
    215  * @return              EOK on success or a negative error code.
     210 * @param box   Answerbox associated with the notification.
     211 * @param inr   IRQ number.
     212 * @param devno Device number.
     213 *
    216214 */
    217215int ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
    … …  
    221219                (sysarg_t) devno
    222220        };
    223 
    224         if ((inr < 0) || (inr > last_inr))
    225                 return ELIMIT;
    226221       
    227222        irq_spinlock_lock(&irq_uspace_hash_table_lock, true);

  • uspace/app/init/init.c

    rab49a0d r8dd039a  
    5757#define DEVFS_MOUNT_POINT  "/dev"
    5858
    59 #define TMPFS_FS_TYPE      "tmpfs"
    60 #define TMPFS_MOUNT_POINT  "/tmp"
     59#define SCRATCH_FS_TYPE      "tmpfs"
     60#define SCRATCH_MOUNT_POINT  "/scratch"
    6161
    6262#define DATA_FS_TYPE      "fat"
    … …  
    235235}
    236236
    237 static bool mount_tmpfs(void)
    238 {
    239         int rc = mount(TMPFS_FS_TYPE, TMPFS_MOUNT_POINT, "", "", 0);
    240         return mount_report("Temporary filesystem", TMPFS_MOUNT_POINT,
    241             TMPFS_FS_TYPE, NULL, rc);
     237static bool mount_scratch(void)
     238{
     239        int rc = mount(SCRATCH_FS_TYPE, SCRATCH_MOUNT_POINT, "", "", 0);
     240        return mount_report("Scratch filesystem", SCRATCH_MOUNT_POINT,
     241            SCRATCH_FS_TYPE, NULL, rc);
    242242}
    243243
    … …  
    271271        }
    272272       
    273         mount_tmpfs();
     273        mount_scratch();
    274274       
    275275        spawn("/srv/fhc");

  • uspace/app/tester/Makefile

    rab49a0d r8dd039a  
    5151        vfs/vfs1.c \
    5252        ipc/ping_pong.c \
     53        ipc/register.c \
     54        ipc/connect.c \
    5355        loop/loop1.c \
    5456        mm/malloc1.c \

  • uspace/app/tester/tester.c

    rab49a0d r8dd039a  
    6060#include "vfs/vfs1.def"
    6161#include "ipc/ping_pong.def"
     62#include "ipc/register.def"
     63#include "ipc/connect.def"
    6264#include "loop/loop1.def"
    6365#include "mm/malloc1.def"

  • uspace/app/tester/tester.h

    rab49a0d r8dd039a  
    7777extern const char *test_vfs1(void);
    7878extern const char *test_ping_pong(void);
     79extern const char *test_register(void);
     80extern const char *test_connect(void);
    7981extern const char *test_loop1(void);
    8082extern const char *test_malloc1(void);

  • uspace/app/tester/vfs/vfs1.c

    rab49a0d r8dd039a  
    4040#include "../tester.h"
    4141
    42 #define TEST_DIRECTORY  "/tmp/testdir"
     42#define FS_TYPE      "tmpfs"
     43#define MOUNT_POINT  "/tmp"
     44#define OPTIONS      ""
     45#define FLAGS        0
     46
     47#define TEST_DIRECTORY  MOUNT_POINT "/testdir"
    4348#define TEST_FILE       TEST_DIRECTORY "/testfile"
    4449#define TEST_FILE2      TEST_DIRECTORY "/nextfile"
    … …  
    7075const char *test_vfs1(void)
    7176{
    72         int rc;
    73         if ((rc = mkdir(TEST_DIRECTORY, 0)) != 0) {
    74                 TPRINTF("rc=%d\n", rc);
     77        if (mkdir(MOUNT_POINT, 0) != 0)
    7578                return "mkdir() failed";
     79        TPRINTF("Created directory %s\n", MOUNT_POINT);
     80       
     81        int rc = mount(FS_TYPE, MOUNT_POINT, "", OPTIONS, FLAGS);
     82        switch (rc) {
     83        case EOK:
     84                TPRINTF("Mounted %s on %s\n", FS_TYPE, MOUNT_POINT);
     85                break;
     86        case EBUSY:
     87                TPRINTF("(INFO) Filesystem already mounted on %s\n", MOUNT_POINT);
     88                break;
     89        default:
     90                TPRINTF("(ERR) IPC returned errno %d (is tmpfs loaded?)\n", rc);
     91                return "mount() failed";
    7692        }
     93       
     94        if (mkdir(TEST_DIRECTORY, 0) != 0)
     95                return "mkdir() failed";
    7796        TPRINTF("Created directory %s\n", TEST_DIRECTORY);
    7897       

  • uspace/drv/ns8250/ns8250.c

    rab49a0d r8dd039a  
    342342                printf(NAME ": failed to connect to the parent driver of the "
    343343                    "device %s.\n", dev->name);
    344                 ret = dev->parent_phone;
     344                ret = EPARTY;   /* FIXME: use another EC */
    345345                goto failed;
    346346        }
    347347       
    348348        /* Get hw resources. */
    349         ret = get_hw_resources(dev->parent_phone, &hw_resources);
    350         if (ret != EOK) {
     349        if (!get_hw_resources(dev->parent_phone, &hw_resources)) {
    351350                printf(NAME ": failed to get hw resources for the device "
    352351                    "%s.\n", dev->name);
     352                ret = EPARTY;   /* FIXME: use another EC */
    353353                goto failed;
    354354        }
    … …  
    374374                                printf(NAME ": i/o range assigned to the device "
    375375                                    "%s is too small.\n", dev->name);
    376                                 ret = ELIMIT;
     376                                ret = EPARTY;   /* FIXME: use another EC */
    377377                                goto failed;
    378378                        }
    … …  
    390390                printf(NAME ": missing hw resource(s) for the device %s.\n",
    391391                    dev->name);
    392                 ret = ENOENT;
     392                ret = EPARTY;   /* FIXME: use another EC */
    393393                goto failed;
    394394        }

  • uspace/drv/pciintel/pci.c

    rab49a0d r8dd039a  
    452452static int pci_add_device(device_t *dev)
    453453{
    454         int rc;
    455 
    456454        printf(NAME ": pci_add_device\n");
    457455       
    … …  
    468466                    "parent's driver.\n");
    469467                delete_pci_bus_data(bus_data);
    470                 return dev->parent_phone;
     468                return EPARTY;  /* FIXME: use another EC */
    471469        }
    472470       
    473471        hw_resource_list_t hw_resources;
    474472       
    475         rc = get_hw_resources(dev->parent_phone, &hw_resources);
    476         if (rc != EOK) {
     473        if (!get_hw_resources(dev->parent_phone, &hw_resources)) {
    477474                printf(NAME ": pci_add_device failed to get hw resources for "
    478475                    "the device.\n");
    479476                delete_pci_bus_data(bus_data);
    480477                ipc_hangup(dev->parent_phone);
    481                 return rc;
     478                return EPARTY;  /* FIXME: use another EC */
    482479        }       
    483480       

  • uspace/lib/c/generic/async_rel.c

    rab49a0d r8dd039a  
    239239                 */
    240240retry:
    241                 rel_phone = async_connect_me_to(key_phone, 0, 0, 0);
     241                rel_phone = ipc_connect_me_to(key_phone, 0, 0, 0);
    242242                if (rel_phone >= 0) {
    243243                        /* success, do nothing */

  • uspace/lib/c/generic/device/hw_res.c

    rab49a0d r8dd039a  
    3838#include <malloc.h>
    3939
    40 int get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources)
     40bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources)
    4141{
    4242        sysarg_t count = 0;
    4343        int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), GET_RESOURCE_LIST, &count);
    4444        hw_resources->count = count;
    45         if (rc != EOK)
    46                 return rc;
     45        if (EOK != rc) {
     46                return false;
     47        }
    4748       
    4849        size_t size = count * sizeof(hw_resource_t);
    4950        hw_resources->resources = (hw_resource_t *)malloc(size);
    50         if (!hw_resources->resources)
    51                 return ENOMEM;
     51        if (NULL == hw_resources->resources) {
     52                return false;
     53        }
    5254       
    5355        rc = async_data_read_start(dev_phone, hw_resources->resources, size);
    54         if (rc != EOK) {
     56        if (EOK != rc) {
    5557                free(hw_resources->resources);
    5658                hw_resources->resources = NULL;
    57                 return rc;
     59                return false;
    5860        }
    5961                 
    60         return EOK;
     62        return true;     
    6163}
    6264

  • uspace/lib/c/generic/devmap.c

    rab49a0d r8dd039a  
    279279       
    280280        if (flags & IPC_FLAG_BLOCKING) {
    281                 phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
     281                phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
    282282                    DEVMAP_CONNECT_TO_DEVICE, handle);
    283283        } else {
    284                 phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
     284                phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
    285285                    DEVMAP_CONNECT_TO_DEVICE, handle);
    286286        }

  • uspace/lib/c/generic/fibril_synch.c

    rab49a0d r8dd039a  
    139139static void _fibril_mutex_unlock_unsafe(fibril_mutex_t *fm)
    140140{
     141        assert(fm->counter <= 0);
    141142        if (fm->counter++ < 0) {
    142143                link_t *tmp;
    … …  
    164165void fibril_mutex_unlock(fibril_mutex_t *fm)
    165166{
    166         assert(fibril_mutex_is_locked(fm));
    167167        futex_down(&async_futex);
    168168        _fibril_mutex_unlock_unsafe(fm);
    169169        futex_up(&async_futex);
    170 }
    171 
    172 bool fibril_mutex_is_locked(fibril_mutex_t *fm)
    173 {
    174         bool locked = false;
    175        
    176         futex_down(&async_futex);
    177         if (fm->counter <= 0)
    178                 locked = true;
    179         futex_up(&async_futex);
    180        
    181         return locked;
    182170}
    183171
    … …  
    242230{
    243231        futex_down(&async_futex);
     232        assert(frw->readers || (frw->writers == 1));
    244233        if (frw->readers) {
    245234                if (--frw->readers) {
    … …  
    307296void fibril_rwlock_read_unlock(fibril_rwlock_t *frw)
    308297{
    309         assert(fibril_rwlock_is_read_locked(frw));
    310298        _fibril_rwlock_common_unlock(frw);
    311299}
    … …  
    313301void fibril_rwlock_write_unlock(fibril_rwlock_t *frw)
    314302{
    315         assert(fibril_rwlock_is_write_locked(frw));
    316303        _fibril_rwlock_common_unlock(frw);
    317 }
    318 
    319 bool fibril_rwlock_is_read_locked(fibril_rwlock_t *frw)
    320 {
    321         bool locked = false;
    322 
    323         futex_down(&async_futex);
    324         if (frw->readers)
    325                 locked = true;
    326         futex_up(&async_futex);
    327 
    328         return locked;
    329 }
    330 
    331 bool fibril_rwlock_is_write_locked(fibril_rwlock_t *frw)
    332 {
    333         bool locked = false;
    334 
    335         futex_down(&async_futex);
    336         if (frw->writers) {
    337                 assert(frw->writers == 1);
    338                 locked = true;
    339         }
    340         futex_up(&async_futex);
    341 
    342         return locked;
    343 }
    344 
    345 bool fibril_rwlock_is_locked(fibril_rwlock_t *frw)
    346 {
    347         return fibril_rwlock_is_read_locked(frw) ||
    348             fibril_rwlock_is_write_locked(frw);
    349304}
    350305
    … …  
    359314{
    360315        awaiter_t wdata;
    361 
    362         assert(fibril_mutex_is_locked(fm));
    363316
    364317        if (timeout < 0)

  • uspace/lib/c/include/device/hw_res.h

    rab49a0d r8dd039a  
    9595
    9696
    97 extern int get_hw_resources(int, hw_resource_list_t *);
    98 extern bool enable_interrupt(int);
     97bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources);
     98
     99bool enable_interrupt(int dev_phone);
    99100
    100101

  • uspace/lib/c/include/fibril_synch.h

    rab49a0d r8dd039a  
    105105extern bool fibril_mutex_trylock(fibril_mutex_t *);
    106106extern void fibril_mutex_unlock(fibril_mutex_t *);
    107 extern bool fibril_mutex_is_locked(fibril_mutex_t *);
    108107
    109108extern void fibril_rwlock_initialize(fibril_rwlock_t *);
    … …  
    112111extern void fibril_rwlock_read_unlock(fibril_rwlock_t *);
    113112extern void fibril_rwlock_write_unlock(fibril_rwlock_t *);
    114 extern bool fibril_rwlock_is_read_locked(fibril_rwlock_t *);
    115 extern bool fibril_rwlock_is_write_locked(fibril_rwlock_t *);
    116 extern bool fibril_rwlock_is_locked(fibril_rwlock_t *);
    117113
    118114extern void fibril_condvar_initialize(fibril_condvar_t *);

  • uspace/lib/packet/generic/packet_server.c

    rab49a0d r8dd039a  
    135135/** Creates a new packet of dimensions at least as given.
    136136 *
     137 * Should be used only when the global data are locked.
     138 *
    137139 * @param[in] length    The total length of the packet, including the header,
    138140 *                      the addresses and the data of the packet.
    … …  
    151153        packet_t *packet;
    152154        int rc;
    153 
    154         assert(fibril_mutex_is_locked(&ps_globals.lock));
    155155
    156156        // already locked
    … …  
    233233/** Release the packet and returns it to the appropriate free packet queue.
    234234 *
     235 * Should be used only when the global data are locked.
     236 *
    235237 * @param[in] packet    The packet to be released.
    236238 *
    … …  
    240242        int index;
    241243        int result;
    242 
    243         assert(fibril_mutex_is_locked(&ps_globals.lock));
    244244
    245245        for (index = 0; (index < FREE_QUEUES_COUNT - 1) &&

  • uspace/srv/devman/devman.c

    rab49a0d r8dd039a  
    392392        printf(NAME ": create_root_node\n");
    393393
    394         fibril_rwlock_write_lock(&tree->rwlock);
    395394        node = create_dev_node();
    396395        if (node != NULL) {
    … …  
    402401                tree->root_node = node;
    403402        }
    404         fibril_rwlock_write_unlock(&tree->rwlock);
    405403
    406404        return node != NULL;
    … …  
    465463/** Start a driver
    466464 *
     465 * The driver's mutex is assumed to be locked.
     466 *
    467467 * @param drv           The driver's structure.
    468468 * @return              True if the driver's task is successfully spawned, false
    … …  
    473473        int rc;
    474474
    475         assert(fibril_mutex_is_locked(&drv->driver_mutex));
    476        
    477475        printf(NAME ": start_driver '%s'\n", drv->name);
    478476       
    … …  
    869867/** Find the device node structure of the device witch has the specified handle.
    870868 *
     869 * Device tree's rwlock should be held at least for reading.
     870 *
    871871 * @param tree          The device tree where we look for the device node.
    872872 * @param handle        The handle of the device.
    … …  
    876876{
    877877        unsigned long key = handle;
    878         link_t *link;
    879        
    880         assert(fibril_rwlock_is_locked(&tree->rwlock));
    881        
    882         link = hash_table_find(&tree->devman_devices, &key);
     878        link_t *link = hash_table_find(&tree->devman_devices, &key);
    883879        return hash_table_get_instance(link, node_t, devman_link);
    884880}
    … …  
    936932/** Insert new device into device tree.
    937933 *
     934 * The device tree's rwlock should be already held exclusively when calling this
     935 * function.
     936 *
    938937 * @param tree          The device tree.
    939938 * @param node          The newly added device node.
    … …  
    950949        assert(tree != NULL);
    951950        assert(dev_name != NULL);
    952         assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    953951       
    954952        node->name = dev_name;

  • uspace/srv/devmap/devmap.c

    rab49a0d r8dd039a  
    4646#include <str.h>
    4747#include <ipc/devmap.h>
    48 #include <assert.h>
    4948
    5049#define NAME          "devmap"
    … …  
    209208}
    210209
    211 /** Find namespace with given name. */
     210/** Find namespace with given name.
     211 *
     212 * The devices_list_mutex should be already held when
     213 * calling this function.
     214 *
     215 */
    212216static devmap_namespace_t *devmap_namespace_find_name(const char *name)
    213217{
    214218        link_t *item;
    215        
    216         assert(fibril_mutex_is_locked(&devices_list_mutex));
    217        
    218219        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
    219220                devmap_namespace_t *namespace =
    … …  
    228229/** Find namespace with given handle.
    229230 *
     231 * The devices_list_mutex should be already held when
     232 * calling this function.
     233 *
    230234 * @todo: use hash table
    231235 *
    … …  
    234238{
    235239        link_t *item;
    236        
    237         assert(fibril_mutex_is_locked(&devices_list_mutex));
    238        
    239240        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
    240241                devmap_namespace_t *namespace =
    … …  
    247248}
    248249
    249 /** Find device with given name. */
     250/** Find device with given name.
     251 *
     252 * The devices_list_mutex should be already held when
     253 * calling this function.
     254 *
     255 */
    250256static devmap_device_t *devmap_device_find_name(const char *ns_name,
    251257    const char *name)
    252258{
    253259        link_t *item;
    254        
    255         assert(fibril_mutex_is_locked(&devices_list_mutex));
    256        
    257260        for (item = devices_list.next; item != &devices_list; item = item->next) {
    258261                devmap_device_t *device =
    … …  
    268271/** Find device with given handle.
    269272 *
     273 * The devices_list_mutex should be already held when
     274 * calling this function.
     275 *
    270276 * @todo: use hash table
    271277 *
    … …  
    274280{
    275281        link_t *item;
    276        
    277         assert(fibril_mutex_is_locked(&devices_list_mutex));
    278        
    279282        for (item = devices_list.next; item != &devices_list; item = item->next) {
    280283                devmap_device_t *device =
    … …  
    287290}
    288291
    289 /** Create a namespace (if not already present). */
     292/** Create a namespace (if not already present)
     293 *
     294 * The devices_list_mutex should be already held when
     295 * calling this function.
     296 *
     297 */
    290298static devmap_namespace_t *devmap_namespace_create(const char *ns_name)
    291299{
    292         devmap_namespace_t *namespace;
    293        
    294         assert(fibril_mutex_is_locked(&devices_list_mutex));
    295        
    296         namespace = devmap_namespace_find_name(ns_name);
     300        devmap_namespace_t *namespace = devmap_namespace_find_name(ns_name);
    297301        if (namespace != NULL)
    298302                return namespace;
    … …  
    319323}
    320324
    321 /** Destroy a namespace (if it is no longer needed). */
     325/** Destroy a namespace (if it is no longer needed)
     326 *
     327 * The devices_list_mutex should be already held when
     328 * calling this function.
     329 *
     330 */
    322331static void devmap_namespace_destroy(devmap_namespace_t *namespace)
    323332{
    324         assert(fibril_mutex_is_locked(&devices_list_mutex));
    325 
    326333        if (namespace->refcnt == 0) {
    327334                list_remove(&(namespace->namespaces));
    … …  
    332339}
    333340
    334 /** Increase namespace reference count by including device. */
     341/** Increase namespace reference count by including device
     342 *
     343 * The devices_list_mutex should be already held when
     344 * calling this function.
     345 *
     346 */
    335347static void devmap_namespace_addref(devmap_namespace_t *namespace,
    336348    devmap_device_t *device)
    337349{
    338         assert(fibril_mutex_is_locked(&devices_list_mutex));
    339 
    340350        device->namespace = namespace;
    341351        namespace->refcnt++;
    342352}
    343353
    344 /** Decrease namespace reference count. */
     354/** Decrease namespace reference count
     355 *
     356 * The devices_list_mutex should be already held when
     357 * calling this function.
     358 *
     359 */
    345360static void devmap_namespace_delref(devmap_namespace_t *namespace)
    346361{
    347         assert(fibril_mutex_is_locked(&devices_list_mutex));
    348 
    349362        namespace->refcnt--;
    350363        devmap_namespace_destroy(namespace);
    351364}
    352365
    353 /** Unregister device and free it. */
     366/** Unregister device and free it
     367 *
     368 * The devices_list_mutex should be already held when
     369 * calling this function.
     370 *
     371 */
    354372static void devmap_device_unregister_core(devmap_device_t *device)
    355373{
    356         assert(fibril_mutex_is_locked(&devices_list_mutex));
    357 
    358374        devmap_namespace_delref(device->namespace);
    359375        list_remove(&(device->devices));

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

    rab49a0d r8dd039a  
    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                }
    … …  
    609564               
    610565                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    611                 assert(dev->phone >= 0);
    612566               
    613567                ipc_callid_t callid;
    … …  
    673627               
    674628                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    675                 assert(dev->phone >= 0);
    676629               
    677630                ipc_callid_t callid;
    … …  
    743696               
    744697                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    745                 assert(dev->phone >= 0);
    746698                dev->refcount--;
    747699               
    … …  
    791743               
    792744                device_t *dev = hash_table_get_instance(lnk, device_t, link);
    793                 assert(dev->phone >= 0);
    794745               
    795746                /* Make a request at the driver */

  • uspace/srv/net/tl/tcp/tcp.c

    rab49a0d r8dd039a  
    20852085        if (!fibril) {
    20862086                free(operation_timeout);
    2087                 return ENOMEM;
    2088         }
    2089 
     2087                return EPARTY;  /* FIXME: use another EC */
     2088        }
    20902089//      fibril_mutex_lock(&socket_data->operation.mutex);
    20912090        /* Start the timeout fibril */

  • uspace/srv/vfs/vfs_lookup.c

    rab49a0d r8dd039a  
    179179        fibril_mutex_unlock(&plb_mutex);
    180180       
    181         if ((int) rc < EOK)
     181        if (((int) rc < EOK) || (!result))
    182182                return (int) rc;
    183 
    184         if (!result)
    185                 return EOK;
    186183       
    187184        result->triplet.fs_handle = (fs_handle_t) rc;
Note: See TracChangeset for help on using the changeset viewer.