Changeset 498ced1 in mainline for uspace/lib


Ignore:
Timestamp:
2018-08-11T02:43:32Z (7 years ago)
Author:
Jiří Zárevúcky <jiri.zarevucky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
05882233
Parents:
b13d80b
git-author:
Jiří Zárevúcky <jiri.zarevucky@…> (2018-08-11 02:29:02)
git-committer:
Jiří Zárevúcky <jiri.zarevucky@…> (2018-08-11 02:43:32)
Message:

Unify reference counting and remove some unnecessary instances of <atomic.h>

Location:
uspace/lib
Files:
1 added
12 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/assert.c

    rb13d80b r498ced1  
    3535#include <io/kio.h>
    3636#include <stdlib.h>
    37 #include <atomic.h>
    3837#include <stacktrace.h>
    3938#include <stdint.h>
    4039#include <task.h>
    4140
    42 static atomic_t failed_asserts = { 0 };
     41__thread int failed_asserts = 0;
    4342
    4443void __helenos_assert_quick_abort(const char *cond, const char *file, unsigned int line)
    … …  
    6968         * Check if this is a nested or parallel assert.
    7069         */
    71         if (atomic_postinc(&failed_asserts))
     70        failed_asserts++;
     71        if (failed_asserts > 0)
    7272                abort();
    7373

  • uspace/lib/c/generic/async/client.c

    rb13d80b r498ced1  
    185185        list_initialize(&session_ns.exch_list);
    186186        fibril_mutex_initialize(&session_ns.mutex);
    187         atomic_set(&session_ns.refcnt, 0);
     187        session_ns.exchanges = 0;
    188188}
    189189
    … …  
    605605        }
    606606
    607         async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
     607        async_sess_t *sess = calloc(1, sizeof(async_sess_t));
    608608        if (sess == NULL) {
    609609                errno = ENOMEM;
    … …  
    627627
    628628        fibril_mutex_initialize(&sess->remote_state_mtx);
    629         sess->remote_state_data = NULL;
    630 
    631629        list_initialize(&sess->exch_list);
    632630        fibril_mutex_initialize(&sess->mutex);
    633         atomic_set(&sess->refcnt, 0);
    634631
    635632        return sess;
    … …  
    676673        }
    677674
    678         async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
     675        async_sess_t *sess = calloc(1, sizeof(async_sess_t));
    679676        if (sess == NULL) {
    680677                errno = ENOMEM;
    … …  
    698695
    699696        fibril_mutex_initialize(&sess->remote_state_mtx);
    700         sess->remote_state_data = NULL;
    701 
    702697        list_initialize(&sess->exch_list);
    703698        fibril_mutex_initialize(&sess->mutex);
    704         atomic_set(&sess->refcnt, 0);
    705699
    706700        return sess;
    … …  
    712706async_sess_t *async_connect_kbox(task_id_t id)
    713707{
    714         async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
     708        async_sess_t *sess = calloc(1, sizeof(async_sess_t));
    715709        if (sess == NULL) {
    716710                errno = ENOMEM;
    … …  
    729723        sess->mgmt = EXCHANGE_ATOMIC;
    730724        sess->phone = phone;
    731         sess->arg1 = 0;
    732         sess->arg2 = 0;
    733         sess->arg3 = 0;
    734725
    735726        fibril_mutex_initialize(&sess->remote_state_mtx);
    736         sess->remote_state_data = NULL;
    737 
    738727        list_initialize(&sess->exch_list);
    739728        fibril_mutex_initialize(&sess->mutex);
    740         atomic_set(&sess->refcnt, 0);
    741729
    742730        return sess;
    … …  
    761749        assert(sess);
    762750
    763         if (atomic_get(&sess->refcnt) > 0)
    764                 return EBUSY;
    765 
    766751        fibril_mutex_lock(&async_sess_mutex);
     752
     753        assert(sess->exchanges == 0);
    767754
    768755        errno_t rc = async_hangup_internal(sess->phone);
    … …  
    874861        }
    875862
     863        if (exch != NULL)
     864                sess->exchanges++;
     865
    876866        fibril_mutex_unlock(&async_sess_mutex);
    877867
    878         if (exch != NULL) {
    879                 atomic_inc(&sess->refcnt);
    880 
    881                 if (mgmt == EXCHANGE_SERIALIZE)
    882                         fibril_mutex_lock(&sess->mutex);
    883         }
     868        if (exch != NULL && mgmt == EXCHANGE_SERIALIZE)
     869                fibril_mutex_lock(&sess->mutex);
    884870
    885871        return exch;
    … …  
    903889                mgmt = sess->iface & IFACE_EXCHANGE_MASK;
    904890
    905         atomic_dec(&sess->refcnt);
    906 
    907891        if (mgmt == EXCHANGE_SERIALIZE)
    908892                fibril_mutex_unlock(&sess->mutex);
    909893
    910894        fibril_mutex_lock(&async_sess_mutex);
     895
     896        sess->exchanges--;
    911897
    912898        list_append(&exch->sess_link, &sess->exch_list);

  • uspace/lib/c/generic/async/server.c

    rb13d80b r498ced1  
    129129
    130130        task_id_t in_task_id;
    131         atomic_t refcnt;
     131        int refcnt;
    132132        void *data;
    133133} client_t;
    … …  
    327327        if (link) {
    328328                client = hash_table_get_inst(link, client_t, link);
    329                 atomic_inc(&client->refcnt);
     329                client->refcnt++;
    330330        } else if (create) {
    331331                // TODO: move the malloc out of critical section
    … …  
    336336                        client->data = async_client_data_create();
    337337
    338                         atomic_set(&client->refcnt, 1);
     338                        client->refcnt = 1;
    339339                        hash_table_insert(&client_hash_table, &client->link);
    340340                }
    … …  
    351351        fibril_rmutex_lock(&client_mutex);
    352352
    353         if (atomic_predec(&client->refcnt) == 0) {
     353        if (--client->refcnt == 0) {
    354354                hash_table_remove(&client_hash_table, &client->in_task_id);
    355355                destroy = true;
    … …  
    15741574        }
    15751575
    1576         async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
     1576        async_sess_t *sess = calloc(1, sizeof(async_sess_t));
    15771577        if (sess == NULL) {
    15781578                async_answer_0(&call, ENOMEM);
    … …  
    15831583        sess->mgmt = mgmt;
    15841584        sess->phone = phandle;
    1585         sess->arg1 = 0;
    1586         sess->arg2 = 0;
    1587         sess->arg3 = 0;
    15881585
    15891586        fibril_mutex_initialize(&sess->remote_state_mtx);
    1590         sess->remote_state_data = NULL;
    1591 
    15921587        list_initialize(&sess->exch_list);
    15931588        fibril_mutex_initialize(&sess->mutex);
    1594         atomic_set(&sess->refcnt, 0);
    15951589
    15961590        /* Acknowledge the connected phone */
    … …  
    16221616                return NULL;
    16231617
    1624         async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
     1618        async_sess_t *sess = calloc(1, sizeof(async_sess_t));
    16251619        if (sess == NULL)
    16261620                return NULL;
    … …  
    16291623        sess->mgmt = mgmt;
    16301624        sess->phone = phandle;
    1631         sess->arg1 = 0;
    1632         sess->arg2 = 0;
    1633         sess->arg3 = 0;
    16341625
    16351626        fibril_mutex_initialize(&sess->remote_state_mtx);
    1636         sess->remote_state_data = NULL;
    1637 
    16381627        list_initialize(&sess->exch_list);
    16391628        fibril_mutex_initialize(&sess->mutex);
    1640         atomic_set(&sess->refcnt, 0);
    16411629
    16421630        return sess;

  • uspace/lib/c/generic/ddi.c

    rb13d80b r498ced1  
    3434
    3535#include <assert.h>
    36 #include <atomic.h>
    3736#include <stdio.h>
    3837#include <errno.h>

  • uspace/lib/c/generic/private/async.h

    rb13d80b r498ced1  
    7070
    7171        /** Number of opened exchanges */
    72         atomic_t refcnt;
     72        int exchanges;
    7373
    7474        /** Mutex for stateful connections */

  • uspace/lib/c/generic/private/fibril.h

    rb13d80b r498ced1  
    3434#include <tls.h>
    3535#include <abi/proc/uarg.h>
    36 #include <atomic.h>
    3736#include <fibril.h>
    3837

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

    rb13d80b r498ced1  
    4343#include <fibril.h>
    4444#include <sys/time.h>
    45 #include <atomic.h>
    4645#include <stdbool.h>
    4746#include <abi/proc/task.h>

  • uspace/lib/drv/generic/driver.c

    rb13d80b r498ced1  
    578578static void dev_add_ref(ddf_dev_t *dev)
    579579{
    580         atomic_inc(&dev->refcnt);
     580        refcount_up(&dev->refcnt);
    581581}
    582582
    … …  
    587587static void dev_del_ref(ddf_dev_t *dev)
    588588{
    589         if (atomic_predec(&dev->refcnt) == 0)
     589        if (refcount_down(&dev->refcnt))
    590590                delete_device(dev);
    591591}
    … …  
    600600{
    601601        dev_add_ref(fun->dev);
    602         atomic_inc(&fun->refcnt);
     602        refcount_up(&fun->refcnt);
    603603}
    604604
    … …  
    611611        ddf_dev_t *dev = fun->dev;
    612612
    613         if (atomic_predec(&fun->refcnt) == 0)
     613        if (refcount_down(&fun->refcnt))
    614614                delete_function(fun);
    615615

  • uspace/lib/drv/generic/private/driver.h

    rb13d80b r498ced1  
    3838
    3939#include <async.h>
     40#include <refcount.h>
    4041#include <ipc/devman.h>
    4142#include <ipc/dev_iface.h>
    … …  
    5152
    5253        /** Reference count */
    53         atomic_t refcnt;
     54        atomic_refcount_t refcnt;
    5455
    5556        /** Session with the parent device driver */
    … …  
    7576
    7677        /** Reference count */
    77         atomic_t refcnt;
     78        atomic_refcount_t refcnt;
    7879
    7980        /** Device which this function belogs to */

  • uspace/lib/usbhost/include/usb/host/endpoint.h

    rb13d80b r498ced1  
    4242
    4343#include <adt/list.h>
    44 #include <atomic.h>
    4544#include <fibril_synch.h>
     45#include <refcount.h>
    4646#include <stdbool.h>
    4747#include <sys/time.h>
    … …  
    7878        device_t *device;
    7979        /** Reference count. */
    80         atomic_t refcnt;
     80        atomic_refcount_t refcnt;
    8181
    8282        /** An inherited guard */

  • uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h

    rb13d80b r498ced1  
    3838#define LIBUSBHOST_HOST_USB_TRANSFER_BATCH_H
    3939
    40 #include <atomic.h>
    4140#include <errno.h>
     41#include <refcount.h>
    4242#include <stddef.h>
    4343#include <stdint.h>

  • uspace/lib/usbhost/src/endpoint.c

    rb13d80b r498ced1  
    3636
    3737#include <assert.h>
    38 #include <atomic.h>
    3938#include <mem.h>
    4039#include <stdlib.h>
    … …  
    6059        ep->device = dev;
    6160
    62         atomic_set(&ep->refcnt, 0);
     61        refcount_init(&ep->refcnt);
    6362        fibril_condvar_initialize(&ep->avail);
    6463
    … …  
    9190void endpoint_add_ref(endpoint_t *ep)
    9291{
    93         atomic_inc(&ep->refcnt);
     92        refcount_up(&ep->refcnt);
    9493}
    9594
    … …  
    115114void endpoint_del_ref(endpoint_t *ep)
    116115{
    117         if (atomic_predec(&ep->refcnt) == 0) {
     116        if (refcount_down(&ep->refcnt))
    118117                endpoint_destroy(ep);
    119         }
    120118}
    121119
Note: See TracChangeset for help on using the changeset viewer.