Changeset 498ced1 in mainline for uspace/srv


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/srv
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/audio/hound/audio_data.c

    rb13d80b r498ced1  
    5959                adata->size = size - overflow;
    6060                adata->format = format;
    61                 atomic_set(&adata->refcount, 1);
     61                refcount_init(&adata->refcount);
    6262        }
    6363        return adata;
    … …  
    7171{
    7272        assert(adata);
    73         assert(atomic_get(&adata->refcount) > 0);
    74         atomic_inc(&adata->refcount);
     73        refcount_up(&adata->refcount);
    7574}
    7675
    … …  
    8281{
    8382        assert(adata);
    84         assert(atomic_get(&adata->refcount) > 0);
    85         atomic_count_t refc = atomic_predec(&adata->refcount);
    86         if (refc == 0) {
     83        if (refcount_down(&adata->refcount)) {
    8784                free(adata->data);
    8885                free(adata);

  • uspace/srv/audio/hound/audio_data.h

    rb13d80b r498ced1  
    3838
    3939#include <adt/list.h>
    40 #include <atomic.h>
     40#include <refcount.h>
    4141#include <errno.h>
    4242#include <fibril_synch.h>
    … …  
    5252        pcm_format_t format;
    5353        /** Reference counter */
    54         atomic_t refcount;
     54        atomic_refcount_t refcount;
    5555} audio_data_t;
    5656

  • uspace/srv/bd/vbd/disk.c

    rb13d80b r498ced1  
    244244{
    245245        log_msg(LOG_DEFAULT, LVL_DEBUG2, "vbds_part_add_ref");
    246         atomic_inc(&part->refcnt);
     246        refcount_up(&part->refcnt);
    247247}
    248248
    … …  
    250250{
    251251        log_msg(LOG_DEFAULT, LVL_DEBUG2, "vbds_part_del_ref");
    252         if (atomic_predec(&part->refcnt) == 0) {
     252        if (refcount_down(&part->refcnt)) {
    253253                log_msg(LOG_DEFAULT, LVL_DEBUG2, " - free part");
    254254                free(part);
    … …  
    328328        part->block0 = lpinfo.block0;
    329329        part->nblocks = lpinfo.nblocks;
    330         atomic_set(&part->refcnt, 1);
     330        refcount_init(&part->refcnt);
    331331
    332332        bd_srvs_init(&part->bds);

  • uspace/srv/bd/vbd/types/vbd.h

    rb13d80b r498ced1  
    3939
    4040#include <adt/list.h>
    41 #include <atomic.h>
    4241#include <bd_srv.h>
    4342#include <label/label.h>
    4443#include <loc.h>
     44#include <refcount.h>
    4545#include <stdbool.h>
    4646#include <stddef.h>
    … …  
    8383        aoff64_t nblocks;
    8484        /** Reference count */
    85         atomic_t refcnt;
     85        atomic_refcount_t refcnt;
    8686} vbds_part_t;
    8787

  • uspace/srv/devman/dev.c

    rb13d80b r498ced1  
    4848                return NULL;
    4949
    50         atomic_set(&dev->refcnt, 0);
     50        refcount_init(&dev->refcnt);
    5151        list_initialize(&dev->functions);
    5252        link_initialize(&dev->driver_devices);
    … …  
    7474void dev_add_ref(dev_node_t *dev)
    7575{
    76         atomic_inc(&dev->refcnt);
     76        refcount_up(&dev->refcnt);
    7777}
    7878
    … …  
    8585void dev_del_ref(dev_node_t *dev)
    8686{
    87         if (atomic_predec(&dev->refcnt) == 0)
     87        if (refcount_down(&dev->refcnt))
    8888                delete_dev_node(dev);
    8989}

  • uspace/srv/devman/devman.h

    rb13d80b r498ced1  
    4141#include <ipc/loc.h>
    4242#include <fibril_synch.h>
    43 #include <atomic.h>
     43#include <refcount.h>
    4444#include <async.h>
    4545
    … …  
    115115struct dev_node {
    116116        /** Reference count */
    117         atomic_t refcnt;
     117        atomic_refcount_t refcnt;
    118118
    119119        /** The global unique identifier of the device. */
    … …  
    155155struct fun_node {
    156156        /** Reference count */
    157         atomic_t refcnt;
     157        atomic_refcount_t refcnt;
    158158        /** State */
    159159        fun_state_t state;

  • uspace/srv/devman/driver.c

    rb13d80b r498ced1  
    406406                }
    407407
    408                 log_msg(LOG_DEFAULT, LVL_DEBUG, "pass_devices_to_driver: dev->refcnt=%d\n",
    409                     (int)atomic_get(&dev->refcnt));
    410408                dev_add_ref(dev);
    411409

  • uspace/srv/devman/fun.c

    rb13d80b r498ced1  
    6060
    6161        fun->state = FUN_INIT;
    62         atomic_set(&fun->refcnt, 0);
     62        refcount_init(&fun->refcnt);
    6363        fibril_mutex_initialize(&fun->busy_lock);
    6464        link_initialize(&fun->dev_functions);
    … …  
    8989void fun_add_ref(fun_node_t *fun)
    9090{
    91         atomic_inc(&fun->refcnt);
     91        refcount_up(&fun->refcnt);
    9292}
    9393
    … …  
    100100void fun_del_ref(fun_node_t *fun)
    101101{
    102         if (atomic_predec(&fun->refcnt) == 0)
     102        if (refcount_down(&fun->refcnt))
    103103                delete_fun_node(fun);
    104104}

  • uspace/srv/fs/exfat/exfat.h

    rb13d80b r498ced1  
    3838#include <fibril_synch.h>
    3939#include <libfs.h>
    40 #include <atomic.h>
    4140#include <stdint.h>
    4241#include <stdbool.h>

  • uspace/srv/fs/fat/fat.h

    rb13d80b r498ced1  
    3838#include <fibril_synch.h>
    3939#include <libfs.h>
    40 #include <atomic.h>
    4140#include <stdint.h>
    4241#include <stdbool.h>

  • uspace/srv/fs/tmpfs/tmpfs.h

    rb13d80b r498ced1  
    3535
    3636#include <libfs.h>
    37 #include <atomic.h>
    3837#include <stddef.h>
    3938#include <stdbool.h>

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    rb13d80b r498ced1  
    4343#include <async.h>
    4444#include <errno.h>
    45 #include <atomic.h>
    4645#include <stdlib.h>
    4746#include <str.h>

  • uspace/srv/fs/udf/udf.h

    rb13d80b r498ced1  
    3737#include <fibril_synch.h>
    3838#include <libfs.h>
    39 #include <atomic.h>
    4039#include <stddef.h>
    4140#include <stdint.h>

  • uspace/srv/hid/compositor/compositor.c

    rb13d80b r498ced1  
    3333 */
    3434
     35#include <assert.h>
    3536#include <stddef.h>
    3637#include <stdint.h>
    … …  
    4647#include <stdlib.h>
    4748
    48 #include <atomic.h>
     49#include <refcount.h>
    4950#include <fibril_synch.h>
    5051#include <adt/prodcons.h>
    … …  
    9394typedef struct {
    9495        link_t link;
    95         atomic_t ref_cnt;
     96        atomic_refcount_t ref_cnt;
    9697        window_flags_t flags;
    9798        service_id_t in_dsid;
    … …  
    223224
    224225        link_initialize(&win->link);
    225         atomic_set(&win->ref_cnt, 0);
     226        refcount_init(&win->ref_cnt);
    226227        prodcons_initialize(&win->queue);
    227228        transform_identity(&win->transform);
    … …  
    240241static void window_destroy(window_t *win)
    241242{
    242         if ((win) && (atomic_get(&win->ref_cnt) == 0)) {
    243                 while (!list_empty(&win->queue.list)) {
    244                         window_event_t *event = (window_event_t *) list_first(&win->queue.list);
    245                         list_remove(&event->link);
    246                         free(event);
    247                 }
    248 
    249                 if (win->surface)
    250                         surface_destroy(win->surface);
    251 
    252                 free(win);
    253         }
     243        if (!win || !refcount_down(&win->ref_cnt))
     244                return;
     245
     246        while (!list_empty(&win->queue.list)) {
     247                window_event_t *event = (window_event_t *) list_first(&win->queue.list);
     248                list_remove(&event->link);
     249                free(event);
     250        }
     251
     252        if (win->surface)
     253                surface_destroy(win->surface);
     254
     255        free(win);
    254256}
    255257
    … …  
    988990                }
    989991        }
     992
     993        if (win)
     994                refcount_up(&win->ref_cnt);
     995
    990996        fibril_mutex_unlock(&window_list_mtx);
    991997
    992998        if (win) {
    993                 atomic_inc(&win->ref_cnt);
    994999                async_answer_0(icall, EOK);
    9951000        } else {
    … …  
    10051010                        if (!IPC_GET_IMETHOD(call)) {
    10061011                                async_answer_0(&call, EOK);
    1007                                 atomic_dec(&win->ref_cnt);
    10081012                                window_destroy(win);
    10091013                                return;
    … …  
    10241028                        if (!IPC_GET_IMETHOD(call)) {
    10251029                                comp_window_close(win, &call);
    1026                                 atomic_dec(&win->ref_cnt);
    10271030                                window_destroy(win);
    10281031                                return;

  • uspace/srv/hid/console/console.c

    rb13d80b r498ced1  
    3434
    3535#include <async.h>
     36#include <atomic.h>
    3637#include <stdio.h>
    3738#include <adt/prodcons.h>

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

    rb13d80b r498ced1  
    128128
    129129        /* One for the user, one for not being in closed state */
    130         atomic_set(&conn->refcnt, 2);
     130        refcount_init(&conn->refcnt);
     131        refcount_up(&conn->refcnt);
    131132
    132133        /* Allocate receive buffer */
    … …  
    238239void tcp_conn_addref(tcp_conn_t *conn)
    239240{
    240         log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_addref(%p) before=%zu",
    241             conn->name, conn, atomic_get(&conn->refcnt));
    242         atomic_inc(&conn->refcnt);
     241        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_addref(%p)",
     242            conn->name, conn);
     243
     244        refcount_up(&conn->refcnt);
    243245}
    244246
    … …  
    251253void tcp_conn_delref(tcp_conn_t *conn)
    252254{
    253         log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_delref(%p) before=%zu",
    254             conn->name, conn, atomic_get(&conn->refcnt));
    255 
    256         if (atomic_predec(&conn->refcnt) == 0)
     255        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_delref(%p)",
     256            conn->name, conn);
     257
     258        if (refcount_down(&conn->refcnt))
    257259                tcp_conn_free(conn);
    258260}

  • uspace/srv/net/tcp/tcp_type.h

    rb13d80b r498ced1  
    4141#include <fibril.h>
    4242#include <fibril_synch.h>
     43#include <refcount.h>
    4344#include <stddef.h>
    4445#include <stdint.h>
    … …  
    248249        fibril_mutex_t lock;
    249250        /** Reference count */
    250         atomic_t refcnt;
     251        atomic_refcount_t refcnt;
    251252
    252253        /** Connection state */

  • uspace/srv/net/udp/assoc.c

    rb13d80b r498ced1  
    9191
    9292        /* One for the user */
    93         atomic_set(&assoc->refcnt, 1);
     93        refcount_init(&assoc->refcnt);
    9494
    9595        /* Initialize receive queue */
    … …  
    145145{
    146146        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: upd_assoc_addref(%p)", assoc->name, assoc);
    147         atomic_inc(&assoc->refcnt);
     147        refcount_up(&assoc->refcnt);
    148148}
    149149
    … …  
    158158        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_assoc_delref(%p)", assoc->name, assoc);
    159159
    160         if (atomic_predec(&assoc->refcnt) == 0)
     160        if (refcount_down(&assoc->refcnt))
    161161                udp_assoc_free(assoc);
    162162}

  • uspace/srv/net/udp/udp_type.h

    rb13d80b r498ced1  
    4141#include <inet/endpoint.h>
    4242#include <ipc/loc.h>
     43#include <refcount.h>
    4344#include <stdbool.h>
    4445#include <stddef.h>
    … …  
    114115        fibril_mutex_t lock;
    115116        /** Reference count */
    116         atomic_t refcnt;
     117        atomic_refcount_t refcnt;
    117118
    118119        /** Receive queue */

  • uspace/srv/vfs/vfs.c

    rb13d80b r498ced1  
    4949#include <str.h>
    5050#include <as.h>
    51 #include <atomic.h>
    5251#include <macros.h>
    5352#include "vfs.h"

  • uspace/srv/volsrv/part.c

    rb13d80b r498ced1  
    179179        }
    180180
    181         atomic_set(&part->refcnt, 1);
     181        refcount_init(&part->refcnt);
    182182        link_initialize(&part->lparts);
    183183        part->parts = NULL;
    … …  
    524524                if (part->svc_id == sid) {
    525525                        /* Add reference */
    526                         atomic_inc(&part->refcnt);
     526                        refcount_up(&part->refcnt);
    527527                        *rpart = part;
    528528                        return EOK;
    … …  
    547547void vol_part_del_ref(vol_part_t *part)
    548548{
    549         if (atomic_predec(&part->refcnt) == 0)
     549        if (refcount_down(&part->refcnt))
    550550                vol_part_delete(part);
    551551}

  • uspace/srv/volsrv/types/part.h

    rb13d80b r498ced1  
    3939
    4040#include <adt/list.h>
    41 #include <atomic.h>
     41#include <refcount.h>
    4242#include <fibril_synch.h>
    4343#include <stdbool.h>
    … …  
    5151        link_t lparts;
    5252        /** Reference count */
    53         atomic_t refcnt;
     53        atomic_refcount_t refcnt;
    5454        /** Service ID */
    5555        service_id_t svc_id;

  • uspace/srv/volsrv/types/volume.h

    rb13d80b r498ced1  
    3939
    4040#include <adt/list.h>
    41 #include <atomic.h>
     41#include <refcount.h>
    4242#include <fibril_synch.h>
    4343#include <sif.h>
    … …  
    5050        link_t lvolumes;
    5151        /** Reference count */
    52         atomic_t refcnt;
     52        atomic_refcount_t refcnt;
    5353        /** Volume label */
    5454        char *label;

  • uspace/srv/volsrv/volume.c

    rb13d80b r498ced1  
    8383        }
    8484
    85         atomic_set(&volume->refcnt, 1);
     85        refcount_init(&volume->refcnt);
    8686        link_initialize(&volume->lvolumes);
    8787        volume->volumes = NULL;
    … …  
    245245                    str_size(label) > 0) {
    246246                        /* Add reference */
    247                         atomic_inc(&volume->refcnt);
     247                        refcount_up(&volume->refcnt);
    248248                        *rvolume = volume;
    249249                        return EOK;
    … …  
    309309void vol_volume_del_ref(vol_volume_t *volume)
    310310{
    311         if (atomic_predec(&volume->refcnt) == 0) {
     311        if (refcount_down(&volume->refcnt)) {
    312312                /* No more references. Check if volume is persistent. */
    313313                if (!vol_volume_is_persist(volume)) {
Note: See TracChangeset for help on using the changeset viewer.