Changeset e89a06a in mainline for uspace/srv/volsrv/part.c


Ignore:
Timestamp:
2018-07-06T22:13:20Z (6 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.)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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}
Note: See TracChangeset for help on using the changeset viewer.