Changeset e89a06a in mainline


Ignore:
Timestamp:
2018-07-06T22:13:20Z (7 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
be0f5e4
Parents:
6419c6e
Message:

Encapsulate partitions list in volume server. (Global state is not good coding practice.)

Location:
uspace
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/barber/barber.c

    r6419c6e re89a06a  
    205205}
    206206
    207 static void loc_callback(void)
     207static void loc_callback(void *arg)
    208208{
    209209        category_id_t led_cat;
    … …  
    255255
    256256        list_initialize(&led_devs);
    257         errno_t rc = loc_register_cat_change_cb(loc_callback);
     257        errno_t rc = loc_register_cat_change_cb(loc_callback, NULL);
    258258        if (rc != EOK) {
    259259                printf("Unable to register callback for device discovery.\n");

  • uspace/lib/c/generic/loc.c

    r6419c6e re89a06a  
    4848static bool loc_callback_created = false;
    4949static loc_cat_change_cb_t cat_change_cb = NULL;
     50static void *cat_change_arg = NULL;
    5051
    5152static async_sess_t *loc_supp_block_sess = NULL;
    … …  
    7071                        fibril_mutex_lock(&loc_callback_mutex);
    7172                        loc_cat_change_cb_t cb_fun = cat_change_cb;
     73                        void *cb_arg = cat_change_arg;
    7274                        fibril_mutex_unlock(&loc_callback_mutex);
    7375
    … …  
    7577
    7678                        if (cb_fun != NULL)
    77                                 (*cb_fun)();
     79                                (*cb_fun)(cb_arg);
    7880
    7981                        break;
    … …  
    859861}
    860862
    861 errno_t loc_register_cat_change_cb(loc_cat_change_cb_t cb_fun)
     863errno_t loc_register_cat_change_cb(loc_cat_change_cb_t cb_fun, void *cb_arg)
    862864{
    863865        fibril_mutex_lock(&loc_callback_mutex);
     866        if (cat_change_cb != NULL) {
     867                fibril_mutex_unlock(&loc_callback_mutex);
     868                return EEXIST;
     869        }
     870
    864871        if (loc_callback_create() != EOK) {
    865872                fibril_mutex_unlock(&loc_callback_mutex);
    … …  
    868875
    869876        cat_change_cb = cb_fun;
     877        cat_change_arg = cb_arg;
    870878        fibril_mutex_unlock(&loc_callback_mutex);
    871879

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

    r6419c6e re89a06a  
    4040#include <stdbool.h>
    4141
    42 typedef void (*loc_cat_change_cb_t)(void);
     42typedef void (*loc_cat_change_cb_t)(void *);
    4343
    4444extern async_exch_t *loc_exchange_begin_blocking(iface_t);
    … …  
    7575extern size_t loc_get_services(service_id_t, loc_sdesc_t **);
    7676extern errno_t loc_get_categories(category_id_t **, size_t *);
    77 extern errno_t loc_register_cat_change_cb(loc_cat_change_cb_t);
    78 
     77extern errno_t loc_register_cat_change_cb(loc_cat_change_cb_t, void *);
    7978
    8079#endif

  • uspace/lib/hound/include/hound/server.h

    r6419c6e re89a06a  
    4040#include <loc.h>
    4141
    42 typedef void (*dev_change_callback_t)(void);
     42typedef void (*dev_change_callback_t)(void *);
    4343typedef errno_t (*device_callback_t)(service_id_t, const char *);
    4444
    4545errno_t hound_server_register(const char *name, service_id_t *id);
    4646void hound_server_unregister(service_id_t id);
    47 errno_t hound_server_set_device_change_callback(dev_change_callback_t cb);
     47errno_t hound_server_set_device_change_callback(dev_change_callback_t cb,
     48    void *);
    4849errno_t hound_server_devices_iterate(device_callback_t callback);
    4950

  • uspace/lib/hound/src/protocol.c

    r6419c6e re89a06a  
    750750 * @return Error code.
    751751 */
    752 errno_t hound_server_set_device_change_callback(dev_change_callback_t cb)
    753 {
    754         return loc_register_cat_change_cb(cb);
     752errno_t hound_server_set_device_change_callback(dev_change_callback_t cb,
     753    void *arg)
     754{
     755        return loc_register_cat_change_cb(cb, arg);
    755756}
    756757

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

    r6419c6e re89a06a  
    6262}
    6363
    64 static void scan_for_devices(void)
     64static void scan_for_devices(void *arg)
    6565{
    6666        hound_server_devices_iterate(device_callback);
    … …  
    9494        }
    9595
    96         ret = hound_server_set_device_change_callback(scan_for_devices);
     96        ret = hound_server_set_device_change_callback(scan_for_devices, NULL);
    9797        if (ret != EOK) {
    9898                log_fatal("Failed to register for device changes: %s",
    … …  
    103103        log_info("Running with service id %" PRIun, id);
    104104
    105         scan_for_devices();
     105        scan_for_devices(NULL);
    106106        task_retval(0);
    107107        async_manager();

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

    r6419c6e re89a06a  
    447447}
    448448
    449 static void vbds_disk_cat_change_cb(void)
     449static void vbds_disk_cat_change_cb(void *arg)
    450450{
    451451        (void) vbds_disks_check_new();
    … …  
    456456        errno_t rc;
    457457
    458         rc = loc_register_cat_change_cb(vbds_disk_cat_change_cb);
     458        rc = loc_register_cat_change_cb(vbds_disk_cat_change_cb, NULL);
    459459        if (rc != EOK) {
    460460                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback "

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

    r6419c6e re89a06a  
    22622262}
    22632263
    2264 static void category_change_cb(void)
     2264static void category_change_cb(void *arg)
    22652265{
    22662266        discover_viewports();
    … …  
    23112311        }
    23122312
    2313         rc = loc_register_cat_change_cb(category_change_cb);
     2313        rc = loc_register_cat_change_cb(category_change_cb, NULL);
    23142314        if (rc != EOK) {
    23152315                printf("%s: Failed to register category change callback\n", NAME);

  • uspace/srv/hid/input/input.c

    r6419c6e re89a06a  
    818818}
    819819
    820 static void cat_change_cb(void)
     820static void cat_change_cb(void *arg)
    821821{
    822822        dev_check_new();
    … …  
    826826static errno_t input_start_dev_discovery(void)
    827827{
    828         errno_t rc = loc_register_cat_change_cb(cat_change_cb);
     828        errno_t rc = loc_register_cat_change_cb(cat_change_cb, NULL);
    829829        if (rc != EOK) {
    830830                printf("%s: Failed registering callback for device discovery: "

  • uspace/srv/hid/output/port/chardev.c

    r6419c6e re89a06a  
    155155 * fibril blocked in chardev_init().
    156156 */
    157 static void check_for_dev(void)
     157static void check_for_dev(void *arg)
    158158{
    159159        errno_t rc;
    … …  
    236236        }
    237237
    238         rc = loc_register_cat_change_cb(check_for_dev);
     238        rc = loc_register_cat_change_cb(check_for_dev, NULL);
    239239        if (rc != EOK) {
    240240                printf("%s: Failed to register callback for device discovery.\n",
    … …  
    243243        }
    244244
    245         check_for_dev();
     245        check_for_dev(NULL);
    246246
    247247        fibril_mutex_lock(&discovery_lock);

  • uspace/srv/net/ethip/ethip_nic.c

    r6419c6e re89a06a  
    224224}
    225225
    226 static void ethip_nic_cat_change_cb(void)
     226static void ethip_nic_cat_change_cb(void *arg)
    227227{
    228228        (void) ethip_nic_check_new();
    … …  
    323323errno_t ethip_nic_discovery_start(void)
    324324{
    325         errno_t rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
     325        errno_t rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb, NULL);
    326326        if (rc != EOK) {
    327327                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for NIC "

  • uspace/srv/net/nconfsrv/iplink.c

    r6419c6e re89a06a  
    170170}
    171171
    172 static void ncs_link_cat_change_cb(void)
     172static void ncs_link_cat_change_cb(void *arg)
    173173{
    174174        (void) ncs_link_check_new();
    … …  
    179179        errno_t rc;
    180180
    181         rc = loc_register_cat_change_cb(ncs_link_cat_change_cb);
     181        rc = loc_register_cat_change_cb(ncs_link_cat_change_cb, NULL);
    182182        if (rc != EOK) {
    183183                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for IP link "

  • uspace/srv/volsrv/part.c

    r6419c6e re89a06a  
    3535 */
    3636
    37 #include <stdbool.h>
     37#include <adt/list.h>
    3838#include <errno.h>
    39 #include <str_error.h>
    4039#include <fibril_synch.h>
    4140#include <io/log.h>
    4241#include <loc.h>
     42#include <stdbool.h>
    4343#include <stdlib.h>
    4444#include <str.h>
     45#include <str_error.h>
    4546#include <vfs/vfs.h>
    4647
    … …  
    5051#include "types/part.h"
    5152
    52 static errno_t vol_part_add_locked(service_id_t);
     53static errno_t vol_part_add_locked(vol_parts_t *, service_id_t);
    5354static void vol_part_remove_locked(vol_part_t *);
    54 static errno_t vol_part_find_by_id_ref_locked(service_id_t, vol_part_t **);
    55 
    56 static LIST_INITIALIZE(vol_parts); /* of vol_part_t */
    57 static FIBRIL_MUTEX_INITIALIZE(vol_parts_lock);
     55static errno_t vol_part_find_by_id_ref_locked(vol_parts_t *, service_id_t,
     56    vol_part_t **);
    5857
    5958struct fsname_type {
    … …  
    8786
    8887/** Check for new and removed partitions */
    89 static errno_t vol_part_check_new(void)
     88static errno_t vol_part_check_new(vol_parts_t *parts)
    9089{
    9190        bool already_known;
    … …  
    9897        errno_t rc;
    9998
    100         fibril_mutex_lock(&vol_parts_lock);
     99        fibril_mutex_lock(&parts->lock);
    101100
    102101        rc = loc_category_get_id("partition", &part_cat, IPC_FLAG_BLOCKING);
    103102        if (rc != EOK) {
    104103                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'partition'.");
    105                 fibril_mutex_unlock(&vol_parts_lock);
     104                fibril_mutex_unlock(&parts->lock);
    106105                return ENOENT;
    107106        }
    … …  
    111110                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of partition "
    112111                    "devices.");
    113                 fibril_mutex_unlock(&vol_parts_lock);
     112                fibril_mutex_unlock(&parts->lock);
    114113                return EIO;
    115114        }
    … …  
    120119
    121120                // XXX Make this faster
    122                 list_foreach(vol_parts, lparts, vol_part_t, part) {
     121                list_foreach(parts->parts, lparts, vol_part_t, part) {
    123122                        if (part->svc_id == svcs[i]) {
    124123                                already_known = true;
    … …  
    130129                        log_msg(LOG_DEFAULT, LVL_NOTE, "Found partition '%lu'",
    131130                            (unsigned long) svcs[i]);
    132                         rc = vol_part_add_locked(svcs[i]);
     131                        rc = vol_part_add_locked(parts, svcs[i]);
    133132                        if (rc != EOK) {
    134133                                log_msg(LOG_DEFAULT, LVL_ERROR, "Could not add "
    … …  
    139138
    140139        /* Check for removed partitions */
    141         cur = list_first(&vol_parts);
     140        cur = list_first(&parts->parts);
    142141        while (cur != NULL) {
    143                 next = list_next(cur, &vol_parts);
     142                next = list_next(cur, &parts->parts);
    144143                part = list_get_instance(cur, vol_part_t, lparts);
    145144
    … …  
    164163        free(svcs);
    165164
    166         fibril_mutex_unlock(&vol_parts_lock);
     165        fibril_mutex_unlock(&parts->lock);
    167166        return EOK;
    168167}
    … …  
    180179        atomic_set(&part->refcnt, 1);
    181180        link_initialize(&part->lparts);
     181        part->parts = NULL;
    182182        part->pcnt = vpc_empty;
    183183
    … …  
    206206        log_msg(LOG_DEFAULT, LVL_NOTE, "Probe partition %s", part->svc_name);
    207207
    208         assert(fibril_mutex_is_locked(&vol_parts_lock));
     208        assert(fibril_mutex_is_locked(&part->parts->lock));
    209209
    210210        fst = &fstab[0];
    … …  
    324324}
    325325
    326 static errno_t vol_part_add_locked(service_id_t sid)
     326static errno_t vol_part_add_locked(vol_parts_t *parts, service_id_t sid)
    327327{
    328328        vol_part_t *part;
    329329        errno_t rc;
    330330
    331         assert(fibril_mutex_is_locked(&vol_parts_lock));
     331        assert(fibril_mutex_is_locked(&parts->lock));
    332332        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_add_locked(%zu)", sid);
    333333
    334334        /* Check for duplicates */
    335         rc = vol_part_find_by_id_ref_locked(sid, &part);
     335        rc = vol_part_find_by_id_ref_locked(parts, sid, &part);
    336336        if (rc == EOK) {
    337337                vol_part_del_ref(part);
    … …  
    346346
    347347        part->svc_id = sid;
     348        part->parts = parts;
    348349
    349350        rc = loc_service_get_name(sid, &part->svc_name);
    … …  
    361362                goto error;
    362363
    363         list_append(&part->lparts, &vol_parts);
     364        list_append(&part->lparts, &parts->parts);
    364365
    365366        log_msg(LOG_DEFAULT, LVL_NOTE, "Added partition %zu", part->svc_id);
    … …  
    374375static void vol_part_remove_locked(vol_part_t *part)
    375376{
    376         assert(fibril_mutex_is_locked(&vol_parts_lock));
    377         log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_remove_locked(%zu)", part->svc_id);
     377        assert(fibril_mutex_is_locked(&part->parts->lock));
     378        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_remove_locked(%zu)",
     379            part->svc_id);
    378380
    379381        list_remove(&part->lparts);
    … …  
    383385}
    384386
    385 errno_t vol_part_add(service_id_t sid)
    386 {
    387         errno_t rc;
    388 
    389         fibril_mutex_lock(&vol_parts_lock);
    390         rc = vol_part_add_locked(sid);
    391         fibril_mutex_unlock(&vol_parts_lock);
     387errno_t vol_part_add(vol_parts_t *parts, service_id_t sid)
     388{
     389        errno_t rc;
     390
     391        fibril_mutex_lock(&parts->lock);
     392        rc = vol_part_add_locked(parts, sid);
     393        fibril_mutex_unlock(&parts->lock);
    392394
    393395        return rc;
    394396}
    395397
    396 static void vol_part_cat_change_cb(void)
    397 {
    398         (void) vol_part_check_new();
    399 }
    400 
    401 errno_t vol_part_init(void)
    402 {
    403         return EOK;
    404 }
    405 
    406 errno_t vol_part_discovery_start(void)
    407 {
    408         errno_t rc;
    409 
    410         rc = loc_register_cat_change_cb(vol_part_cat_change_cb);
     398static void vol_part_cat_change_cb(void *arg)
     399{
     400        vol_parts_t *parts = (vol_parts_t *) arg;
     401
     402        (void) vol_part_check_new(parts);
     403}
     404
     405errno_t vol_parts_create(vol_parts_t **rparts)
     406{
     407        vol_parts_t *parts;
     408
     409        parts = calloc(1, sizeof(vol_parts_t));
     410        if (parts == NULL)
     411                return ENOMEM;
     412
     413        fibril_mutex_initialize(&parts->lock);
     414        list_initialize(&parts->parts);
     415
     416        *rparts = parts;
     417        return EOK;
     418}
     419
     420void vol_parts_destroy(vol_parts_t *parts)
     421{
     422        if (parts == NULL)
     423                return;
     424
     425        assert(list_empty(&parts->parts));
     426        free(parts);
     427}
     428
     429errno_t vol_part_discovery_start(vol_parts_t *parts)
     430{
     431        errno_t rc;
     432
     433        rc = loc_register_cat_change_cb(vol_part_cat_change_cb, parts);
    411434        if (rc != EOK) {
    412435                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback "
    … …  
    415438        }
    416439
    417         return vol_part_check_new();
     440        return vol_part_check_new(parts);
    418441}
    419442
    420443/** Get list of partitions as array of service IDs. */
    421 errno_t vol_part_get_ids(service_id_t *id_buf, size_t buf_size, size_t *act_size)
     444errno_t vol_part_get_ids(vol_parts_t *parts, service_id_t *id_buf,
     445    size_t buf_size, size_t *act_size)
    422446{
    423447        size_t act_cnt;
    424448        size_t buf_cnt;
    425449
    426         fibril_mutex_lock(&vol_parts_lock);
     450        fibril_mutex_lock(&parts->lock);
    427451
    428452        buf_cnt = buf_size / sizeof(service_id_t);
    429453
    430         act_cnt = list_count(&vol_parts);
     454        act_cnt = list_count(&parts->parts);
    431455        *act_size = act_cnt * sizeof(service_id_t);
    432456
    433457        if (buf_size % sizeof(service_id_t) != 0) {
    434                 fibril_mutex_unlock(&vol_parts_lock);
     458                fibril_mutex_unlock(&parts->lock);
    435459                return EINVAL;
    436460        }
    437461
    438462        size_t pos = 0;
    439         list_foreach(vol_parts, lparts, vol_part_t, part) {
     463        list_foreach(parts->parts, lparts, vol_part_t, part) {
    440464                if (pos < buf_cnt)
    441465                        id_buf[pos] = part->svc_id;
    … …  
    443467        }
    444468
    445         fibril_mutex_unlock(&vol_parts_lock);
    446         return EOK;
    447 }
    448 
    449 static errno_t vol_part_find_by_id_ref_locked(service_id_t sid,
    450     vol_part_t **rpart)
    451 {
    452         assert(fibril_mutex_is_locked(&vol_parts_lock));
    453 
    454         list_foreach(vol_parts, lparts, vol_part_t, part) {
     469        fibril_mutex_unlock(&parts->lock);
     470        return EOK;
     471}
     472
     473static errno_t vol_part_find_by_id_ref_locked(vol_parts_t *parts,
     474    service_id_t sid, vol_part_t **rpart)
     475{
     476        assert(fibril_mutex_is_locked(&parts->lock));
     477
     478        list_foreach(parts->parts, lparts, vol_part_t, part) {
    455479                if (part->svc_id == sid) {
    456480                        /* Add reference */
    … …  
    464488}
    465489
    466 errno_t vol_part_find_by_id_ref(service_id_t sid, vol_part_t **rpart)
    467 {
    468         errno_t rc;
    469 
    470         fibril_mutex_lock(&vol_parts_lock);
    471         rc = vol_part_find_by_id_ref_locked(sid, rpart);
    472         fibril_mutex_unlock(&vol_parts_lock);
     490errno_t vol_part_find_by_id_ref(vol_parts_t *parts, service_id_t sid,
     491    vol_part_t **rpart)
     492{
     493        errno_t rc;
     494
     495        fibril_mutex_lock(&parts->lock);
     496        rc = vol_part_find_by_id_ref_locked(parts, sid, rpart);
     497        fibril_mutex_unlock(&parts->lock);
    473498
    474499        return rc;
    … …  
    539564        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_mkfs_part()");
    540565
    541         fibril_mutex_lock(&vol_parts_lock);
     566        fibril_mutex_lock(&part->parts->lock);
    542567
    543568        rc = volsrv_part_mkfs(part->svc_id, fstype, label);
    … …  
    545570                log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_mkfs_part() - failed %s",
    546571                    str_error(rc));
    547                 fibril_mutex_unlock(&vol_parts_lock);
     572                fibril_mutex_unlock(&part->parts->lock);
    548573                return rc;
    549574        }
    … …  
    556581        rc = vol_part_probe(part);
    557582        if (rc != EOK) {
    558                 fibril_mutex_unlock(&vol_parts_lock);
     583                fibril_mutex_unlock(&part->parts->lock);
    559584                return rc;
    560585        }
    … …  
    562587        rc = vol_part_mount(part);
    563588        if (rc != EOK) {
    564                 fibril_mutex_unlock(&vol_parts_lock);
     589                fibril_mutex_unlock(&part->parts->lock);
    565590                return rc;
    566591        }
    567592
    568         fibril_mutex_unlock(&vol_parts_lock);
     593        fibril_mutex_unlock(&part->parts->lock);
    569594        return EOK;
    570595}

  • uspace/srv/volsrv/part.h

    r6419c6e re89a06a  
    4343#include "types/part.h"
    4444
    45 extern errno_t vol_part_init(void);
    46 extern errno_t vol_part_discovery_start(void);
    47 extern errno_t vol_part_add(service_id_t);
    48 extern errno_t vol_part_get_ids(service_id_t *, size_t, size_t *);
    49 extern errno_t vol_part_find_by_id_ref(service_id_t, vol_part_t **);
     45extern errno_t vol_parts_create(vol_parts_t **);
     46extern void vol_parts_destroy(vol_parts_t *);
     47extern errno_t vol_part_discovery_start(vol_parts_t *);
     48extern errno_t vol_part_add(vol_parts_t *, service_id_t);
     49extern errno_t vol_part_get_ids(vol_parts_t *, service_id_t *, size_t,
     50    size_t *);
     51extern errno_t vol_part_find_by_id_ref(vol_parts_t *, service_id_t,
     52    vol_part_t **);
    5053extern void vol_part_del_ref(vol_part_t *);
    5154extern errno_t vol_part_eject_part(vol_part_t *);

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

    r6419c6e re89a06a  
    4040#include <adt/list.h>
    4141#include <atomic.h>
     42#include <fibril_synch.h>
    4243#include <stdbool.h>
    4344#include <types/label.h>
    … …  
    4546/** Partition */
    4647typedef struct {
     48        /** Containing partition list */
     49        struct vol_parts *parts;
    4750        /** Link to vol_parts */
    4851        link_t lparts;
    … …  
    6568} vol_part_t;
    6669
     70/** Partitions */
     71typedef struct vol_parts {
     72        /** Synchronize access to list of partitions */
     73        fibril_mutex_t lock;
     74        /** Partitions (list of vol_part_t) */
     75        list_t parts;
     76} vol_parts_t;
     77
    6778#endif
    6879

  • uspace/srv/volsrv/volsrv.c

    r6419c6e re89a06a  
    5757{
    5858        errno_t rc;
     59        vol_parts_t *parts = NULL;
     60
    5961        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_init()");
    6062
    61         rc = vol_part_init();
     63        rc = vol_parts_create(&parts);
    6264        if (rc != EOK)
    63                 return rc;
    64 
    65         rc = vol_part_discovery_start();
     65                goto error;
     66
     67        rc = vol_part_discovery_start(parts);
    6668        if (rc != EOK)
    67                 return rc;
    68 
    69         async_set_fallback_port_handler(vol_client_conn, NULL);
     69                goto error;
     70
     71        async_set_fallback_port_handler(vol_client_conn, parts);
    7072
    7173        rc = loc_server_register(NAME);
    7274        if (rc != EOK) {
    7375                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
    74                 return EEXIST;
     76                rc = EEXIST;
    7577        }
    7678
    … …  
    7981        if (rc != EOK) {
    8082                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));
    81                 return EEXIST;
     83                rc = EEXIST;
     84                goto error;
    8285        }
    8386
    8487        return EOK;
    85 }
    86 
    87 static void vol_get_parts_srv(ipc_call_t *icall)
     88error:
     89        vol_parts_destroy(parts);
     90        return rc;
     91}
     92
     93static void vol_get_parts_srv(vol_parts_t *parts, ipc_call_t *icall)
    8894{
    8995        ipc_call_t call;
    … …  
    105111        }
    106112
    107         rc = vol_part_get_ids(id_buf, size, &act_size);
     113        rc = vol_part_get_ids(parts, id_buf, size, &act_size);
    108114        if (rc != EOK) {
    109115                async_answer_0(&call, rc);
    … …  
    118124}
    119125
    120 static void vol_part_add_srv(ipc_call_t *icall)
    121 {
    122         service_id_t sid;
    123         errno_t rc;
    124 
    125         sid = IPC_GET_ARG1(*icall);
    126 
    127         rc = vol_part_add(sid);
    128         if (rc != EOK) {
    129                 async_answer_0(icall, rc);
    130                 return;
    131         }
    132 
    133         async_answer_0(icall, EOK);
    134 }
    135 
    136 static void vol_part_info_srv(ipc_call_t *icall)
     126static void vol_part_add_srv(vol_parts_t *parts, ipc_call_t *icall)
     127{
     128        service_id_t sid;
     129        errno_t rc;
     130
     131        sid = IPC_GET_ARG1(*icall);
     132
     133        rc = vol_part_add(parts, sid);
     134        if (rc != EOK) {
     135                async_answer_0(icall, rc);
     136                return;
     137        }
     138
     139        async_answer_0(icall, EOK);
     140}
     141
     142static void vol_part_info_srv(vol_parts_t *parts, ipc_call_t *icall)
    137143{
    138144        service_id_t sid;
    … …  
    144150        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_info_srv(%zu)",
    145151            sid);
    146         rc = vol_part_find_by_id_ref(sid, &part);
     152        rc = vol_part_find_by_id_ref(parts, sid, &part);
    147153        if (rc != EOK) {
    148154                async_answer_0(icall, ENOENT);
    … …  
    183189}
    184190
    185 static void vol_part_eject_srv(ipc_call_t *icall)
     191static void vol_part_eject_srv(vol_parts_t *parts, ipc_call_t *icall)
    186192{
    187193        service_id_t sid;
    … …  
    192198        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_eject_srv(%zu)", sid);
    193199
    194         rc = vol_part_find_by_id_ref(sid, &part);
     200        rc = vol_part_find_by_id_ref(parts, sid, &part);
    195201        if (rc != EOK) {
    196202                async_answer_0(icall, ENOENT);
    … …  
    209215}
    210216
    211 static void vol_part_empty_srv(ipc_call_t *icall)
     217static void vol_part_empty_srv(vol_parts_t *parts, ipc_call_t *icall)
    212218{
    213219        service_id_t sid;
    … …  
    218224        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_empty_srv(%zu)", sid);
    219225
    220         rc = vol_part_find_by_id_ref(sid, &part);
     226        rc = vol_part_find_by_id_ref(parts, sid, &part);
    221227        if (rc != EOK) {
    222228                async_answer_0(icall, ENOENT);
    … …  
    235241}
    236242
    237 static void vol_part_get_lsupp_srv(ipc_call_t *icall)
     243static void vol_part_get_lsupp_srv(vol_parts_t *parts, ipc_call_t *icall)
    238244{
    239245        vol_fstype_t fstype;
    … …  
    273279
    274280
    275 static void vol_part_mkfs_srv(ipc_call_t *icall)
     281static void vol_part_mkfs_srv(vol_parts_t *parts, ipc_call_t *icall)
    276282{
    277283        service_id_t sid;
    … …  
    298304        }
    299305
    300         rc = vol_part_find_by_id_ref(sid, &part);
     306        rc = vol_part_find_by_id_ref(parts, sid, &part);
    301307        if (rc != EOK) {
    302308                free(label);
    … …  
    319325static void vol_client_conn(ipc_call_t *icall, void *arg)
    320326{
     327        vol_parts_t *parts = (vol_parts_t *) arg;
     328
    321329        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_client_conn()");
    322330
    … …  
    337345                switch (method) {
    338346                case VOL_GET_PARTS:
    339                         vol_get_parts_srv(&call);
     347                        vol_get_parts_srv(parts, &call);
    340348                        break;
    341349                case VOL_PART_ADD:
    342                         vol_part_add_srv(&call);
     350                        vol_part_add_srv(parts, &call);
    343351                        break;
    344352                case VOL_PART_INFO:
    345                         vol_part_info_srv(&call);
     353                        vol_part_info_srv(parts, &call);
    346354                        break;
    347355                case VOL_PART_EJECT:
    348                         vol_part_eject_srv(&call);
     356                        vol_part_eject_srv(parts, &call);
    349357                        break;
    350358                case VOL_PART_EMPTY:
    351                         vol_part_empty_srv(&call);
     359                        vol_part_empty_srv(parts, &call);
    352360                        break;
    353361                case VOL_PART_LSUPP:
    354                         vol_part_get_lsupp_srv(&call);
     362                        vol_part_get_lsupp_srv(parts, &call);
    355363                        break;
    356364                case VOL_PART_MKFS:
    357                         vol_part_mkfs_srv(&call);
     365                        vol_part_mkfs_srv(parts, &call);
    358366                        break;
    359367                default:
Note: See TracChangeset for help on using the changeset viewer.