Changeset edebb4a1 in mainline


Ignore:
Timestamp:
2015-10-14T22:30:12Z (9 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ea0ff6b
Parents:
4b6635a7
Message:

Handle dummy partition addition/removal during label destruction/creation. Handle dummy label properly in fdisk.

Location:
uspace
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/fdisk/fdisk.c

    r4b6635a7 redebb4a1  
    565565                }
    566566
    567                 printf("Partition %d: %s", npart, scap);
     567                if (linfo.ltype == lt_none)
     568                        printf("Entire disk: %s", scap);
     569                else
     570                        printf("Partition %d: %s", npart, scap);
     571
    568572                if ((linfo.flags & lf_ext_supp) != 0) {
    569573                        rc = fdisk_pkind_format(pinfo.pkind, &spkind);
    … …  
    653657        }
    654658
    655         if (npart > 0) {
     659        if ((linfo.flags & lf_can_delete_part) != 0) {
    656660                rc = nchoice_add(choice, "Delete partition",
    657661                    (void *)devac_delete_part);

  • uspace/lib/c/generic/vol.c

    r4b6635a7 redebb4a1  
    188188}
    189189
     190/** Add partition.
     191 *
     192 * After a partition is created (e.g. as a result of deleting a label
     193 * the dummy partition is created), it can take some (unknown) time
     194 * until it is discovered.
     195 */
     196int vol_part_add(vol_t *vol, service_id_t sid)
     197{
     198        async_exch_t *exch;
     199        int retval;
     200
     201        exch = async_exchange_begin(vol->sess);
     202        retval = async_req_1_0(exch, VOL_PART_ADD, sid);
     203        async_exchange_end(exch);
     204
     205        if (retval != EOK)
     206                return retval;
     207
     208        return EOK;
     209}
     210
    190211/** Get partition information. */
    191212int vol_part_info(vol_t *vol, service_id_t sid, vol_part_info_t *vinfo)

  • uspace/lib/c/include/ipc/vol.h

    r4b6635a7 redebb4a1  
    3838typedef enum {
    3939        VOL_GET_PARTS = IPC_FIRST_USER_METHOD,
     40        VOL_PART_ADD,
    4041        VOL_PART_INFO,
    4142        VOL_PART_EMPTY

  • uspace/lib/c/include/types/label.h

    r4b6635a7 redebb4a1  
    8181        /** Currently it is possible to create an extended partition */
    8282        lf_can_create_ext = 0x8,
    83         /** Currrently it is possible to create a logical partition */
    84         lf_can_create_log = 0x10
     83        /** Currently it is possible to create a logical partition */
     84        lf_can_create_log = 0x10,
     85        /** Currently it is possible to delete a partition */
     86        lf_can_delete_part = 0x20
    8587} label_flags_t;
    8688

  • uspace/lib/c/include/types/vol.h

    r4b6635a7 redebb4a1  
    5555#define VOL_FSTYPE_LIMIT (fs_ext4 + 1)
    5656
     57/** Volume service */
     58typedef struct vol {
     59        /** Volume service session */
     60        async_sess_t *sess;
     61} vol_t;
     62
     63/** Partition information */
     64typedef struct {
     65        /** Partition content type */
     66        vol_part_cnt_t pcnt;
     67        /** Filesystem type */
     68        vol_fstype_t fstype;
     69} vol_part_info_t;
     70
    5771#endif
    5872

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

    r4b6635a7 redebb4a1  
    4242#include <types/vol.h>
    4343
    44 /** Volume service */
    45 typedef struct vol {
    46         /** Volume service session */
    47         async_sess_t *sess;
    48 } vol_t;
    49 
    50 /** Partition information */
    51 typedef struct {
    52         /** Partition content type */
    53         vol_part_cnt_t pcnt;
    54         /** Filesystem type */
    55         vol_fstype_t fstype;
    56 } vol_part_info_t;
    57 
    5844extern int vol_create(vol_t **);
    5945extern void vol_destroy(vol_t *);
    6046extern int vol_get_parts(vol_t *, service_id_t **, size_t *);
     47extern int vol_part_add(vol_t *, service_id_t);
    6148extern int vol_part_info(vol_t *, service_id_t, vol_part_info_t *);
    6249extern int vol_part_empty(vol_t *, service_id_t);

  • uspace/lib/fdisk/src/fdisk.c

    r4b6635a7 redebb4a1  
    5858};
    5959
     60static int fdisk_dev_add_parts(fdisk_dev_t *);
     61static void fdisk_dev_remove_parts(fdisk_dev_t *);
    6062static int fdisk_part_spec_prepare(fdisk_dev_t *, fdisk_part_spec_t *,
    6163    vbd_part_spec_t *);
    … …  
    256258}
    257259
     260/** Add partition to our inventory. */
    258261static int fdisk_part_add(fdisk_dev_t *dev, vbd_part_id_t partid,
    259262    fdisk_part_t **rpart)
    … …  
    268271                return ENOMEM;
    269272
     273        printf("vbd_part_get_info(%zu)\n", partid);
    270274        rc = vbd_part_get_info(dev->fdisk->vbd, partid, &pinfo);
    271275        if (rc != EOK) {
    … …  
    274278        }
    275279
     280        printf("vol_part_add(%zu)...\n", pinfo.svc_id);
     281        /*
     282         * Normally vol service discovers the partition asynchronously.
     283         * Here we need to make sure the partition is already known to it.
     284         */
     285        rc = vol_part_add(dev->fdisk->vol, pinfo.svc_id);
     286        printf("vol_part_add->rc = %d\n", rc);
     287        if (rc != EOK && rc != EEXIST) {
     288                rc = EIO;
     289                goto error;
     290        }
     291
     292        printf("vol_part_info(%zu)\n", pinfo.svc_id);
    276293        rc = vol_part_info(dev->fdisk->vol, pinfo.svc_id, &vpinfo);
     294        printf("vol_part_info->rc = %d\n", rc);
    277295        if (rc != EOK) {
    278296                rc = EIO;
    … …  
    316334}
    317335
     336/** Remove partition from our inventory. */
     337static void fdisk_part_remove(fdisk_part_t *part)
     338{
     339        list_remove(&part->lparts);
     340        if (link_used(&part->lpri_ba))
     341                list_remove(&part->lpri_ba);
     342        if (link_used(&part->lpri_idx))
     343                list_remove(&part->lpri_idx);
     344        if (link_used(&part->llog_ba))
     345                list_remove(&part->llog_ba);
     346        free(part);
     347}
     348
    318349static void fdisk_pri_part_insert_lists(fdisk_dev_t *dev, fdisk_part_t *part)
    319350{
    … …  
    373404}
    374405
    375 int fdisk_dev_open(fdisk_t *fdisk, service_id_t sid, fdisk_dev_t **rdev)
    376 {
    377         vbd_disk_info_t vinfo;
    378         fdisk_dev_t *dev = NULL;
     406static int fdisk_dev_add_parts(fdisk_dev_t *dev)
     407{
    379408        service_id_t *psids = NULL;
    380409        size_t nparts, i;
    381410        int rc;
    382 
    383         dev = calloc(1, sizeof(fdisk_dev_t));
    384         if (dev == NULL)
    385                 return ENOMEM;
    386 
    387         dev->fdisk = fdisk;
    388         dev->sid = sid;
    389         list_initialize(&dev->parts);
    390         list_initialize(&dev->pri_idx);
    391         list_initialize(&dev->pri_ba);
    392         list_initialize(&dev->log_ba);
    393 
    394         rc = vbd_disk_info(fdisk->vbd, sid, &vinfo);
    395         if (rc != EOK) {
    396                 rc = EIO;
    397                 goto error;
    398         }
    399411
    400412        printf("get label info\n");
    … …  
    408420        printf("block size: %zu\n", dev->dinfo.block_size);
    409421        printf("get partitions\n");
    410         rc = vbd_label_get_parts(fdisk->vbd, sid, &psids, &nparts);
     422        rc = vbd_label_get_parts(dev->fdisk->vbd, dev->sid, &psids, &nparts);
    411423        if (rc != EOK) {
    412424                printf("failed\n");
    … …  
    428440
    429441        free(psids);
     442        return EOK;
     443error:
     444        fdisk_dev_remove_parts(dev);
     445        return rc;
     446}
     447
     448static void fdisk_dev_remove_parts(fdisk_dev_t *dev)
     449{
     450        fdisk_part_t *part;
     451
     452        part = fdisk_part_first(dev);
     453        while (part != NULL) {
     454                fdisk_part_remove(part);
     455                part = fdisk_part_first(dev);
     456        }
     457}
     458
     459int fdisk_dev_open(fdisk_t *fdisk, service_id_t sid, fdisk_dev_t **rdev)
     460{
     461        vbd_disk_info_t vinfo;
     462        fdisk_dev_t *dev = NULL;
     463        service_id_t *psids = NULL;
     464        size_t nparts, i;
     465        int rc;
     466
     467        dev = calloc(1, sizeof(fdisk_dev_t));
     468        if (dev == NULL)
     469                return ENOMEM;
     470
     471        dev->fdisk = fdisk;
     472        dev->sid = sid;
     473        list_initialize(&dev->parts);
     474        list_initialize(&dev->pri_idx);
     475        list_initialize(&dev->pri_ba);
     476        list_initialize(&dev->log_ba);
     477
     478        rc = vbd_disk_info(fdisk->vbd, sid, &vinfo);
     479        if (rc != EOK) {
     480                rc = EIO;
     481                goto error;
     482        }
     483
     484        printf("get label info\n");
     485        rc = fdisk_update_dev_info(dev);
     486        if (rc != EOK) {
     487                printf("failed\n");
     488                rc = EIO;
     489                goto error;
     490        }
     491
     492        printf("block size: %zu\n", dev->dinfo.block_size);
     493        printf("get partitions\n");
     494        rc = vbd_label_get_parts(fdisk->vbd, sid, &psids, &nparts);
     495        if (rc != EOK) {
     496                printf("failed\n");
     497                rc = EIO;
     498                goto error;
     499        }
     500        printf("OK\n");
     501
     502        printf("found %zu partitions.\n", nparts);
     503        for (i = 0; i < nparts; i++) {
     504                printf("add partition sid=%zu\n", psids[i]);
     505                rc = fdisk_part_add(dev, psids[i], NULL);
     506                if (rc != EOK) {
     507                        printf("failed\n");
     508                        goto error;
     509                }
     510                printf("OK\n");
     511        }
     512
     513        free(psids);
    430514        *rdev = dev;
    431515        return EOK;
    … …  
    440524                return;
    441525
    442         /* XXX Clean up partitions */
     526        fdisk_dev_remove_parts(dev);
    443527        free(dev);
    444528}
    … …  
    504588{
    505589        int rc;
     590
     591        /* Remove dummy partition */
     592        fdisk_dev_remove_parts(dev);
    506593
    507594        rc = vbd_label_create(dev->fdisk->vbd, dev->sid, ltype);
    … …  
    533620                return EIO;
    534621
     622        rc = fdisk_dev_add_parts(dev);
     623        if (rc != EOK)
     624                return rc;
     625
    535626        return EOK;
    536627}
    … …  
    617708                return EIO;
    618709
    619         list_remove(&part->lparts);
    620         if (link_used(&part->lpri_ba))
    621                 list_remove(&part->lpri_ba);
    622         if (link_used(&part->lpri_idx))
    623                 list_remove(&part->lpri_idx);
    624         if (link_used(&part->llog_ba))
    625                 list_remove(&part->llog_ba);
    626         free(part);
     710        fdisk_part_remove(part);
    627711        return EOK;
    628712}

  • uspace/lib/label/src/gpt.c

    r4b6635a7 redebb4a1  
    544544}
    545545
     546static bool gpt_can_delete_part(label_t *label)
     547{
     548        return list_count(&label->parts) > 0;
     549}
     550
    546551static int gpt_get_info(label_t *label, label_info_t *linfo)
    547552{
    … …  
    551556        if (gpt_can_create_pri(label))
    552557                linfo->flags = linfo->flags | lf_can_create_pri;
     558        if (gpt_can_delete_part(label))
     559                linfo->flags = linfo->flags | lf_can_delete_part;
    553560        linfo->ablock0 = label->ablock0;
    554561        linfo->anblocks = label->anblocks;

  • uspace/lib/label/src/mbr.c

    r4b6635a7 redebb4a1  
    399399}
    400400
     401static bool mbr_can_delete_part(label_t *label)
     402{
     403        return list_count(&label->parts) > 0;
     404}
     405
    401406static int mbr_get_info(label_t *label, label_info_t *linfo)
    402407{
    … …  
    416421        if (label->ext_part != NULL)
    417422                linfo->flags |= lf_can_create_log;
     423        /* Can delete partition */
     424        if (mbr_can_delete_part(label))
     425                linfo->flags |= lf_can_delete_part;
    418426
    419427        linfo->ablock0 = label->ablock0;

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

    r4b6635a7 redebb4a1  
    907907        }
    908908
     909        log_msg(LOG_DEFAULT, LVL_NOTE, "loc_service_register('%s')",
     910            name);
    909911        rc = loc_service_register(name, &psid);
    910912        if (rc != EOK) {

  • uspace/srv/volsrv/part.c

    r4b6635a7 redebb4a1  
    4747#include "types/part.h"
    4848
    49 static int vol_part_add(service_id_t);
    50 
     49static int vol_part_add_locked(service_id_t);
    5150static LIST_INITIALIZE(vol_parts); /* of vol_part_t */
    5251static FIBRIL_MUTEX_INITIALIZE(vol_parts_lock);
    … …  
    9190                        log_msg(LOG_DEFAULT, LVL_NOTE, "Found partition '%lu'",
    9291                            (unsigned long) svcs[i]);
    93                         rc = vol_part_add(svcs[i]);
     92                        rc = vol_part_add_locked(svcs[i]);
    9493                        if (rc != EOK) {
    9594                                log_msg(LOG_DEFAULT, LVL_ERROR, "Could not add "
    … …  
    128127}
    129128
    130 static int vol_part_add(service_id_t sid)
     129static int vol_part_add_locked(service_id_t sid)
    131130{
    132131        vol_part_t *part;
    … …  
    135134
    136135        assert(fibril_mutex_is_locked(&vol_parts_lock));
     136
     137        /* Check for duplicates */
     138        rc = vol_part_find_by_id(sid, &part);
     139        if (rc == EOK)
     140                return EEXIST;
    137141
    138142        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_add()");
    … …  
    160164        list_append(&part->lparts, &vol_parts);
    161165
     166        log_msg(LOG_DEFAULT, LVL_NOTE, "Added partition %zu", part->svc_id);
     167
    162168        return EOK;
    163169
    164170error:
    165171        vol_part_delete(part);
     172        return rc;
     173}
     174
     175int vol_part_add(service_id_t sid)
     176{
     177        int rc;
     178
     179        fibril_mutex_lock(&vol_parts_lock);
     180        rc = vol_part_add_locked(sid);
     181        fibril_mutex_unlock(&vol_parts_lock);
     182
    166183        return rc;
    167184}

  • uspace/srv/volsrv/part.h

    r4b6635a7 redebb4a1  
    4040#include <loc.h>
    4141#include <sys/types.h>
    42 #include <vol.h>
     42#include <types/vol.h>
    4343#include "types/part.h"
    4444
    4545extern int vol_part_init(void);
    4646extern int vol_part_discovery_start(void);
     47extern int vol_part_add(service_id_t);
    4748extern int vol_part_get_ids(service_id_t *, size_t, size_t *);
    4849extern int vol_part_find_by_id(service_id_t, vol_part_t **);

  • uspace/srv/volsrv/volsrv.c

    r4b6635a7 redebb4a1  
    4444#include <stdlib.h>
    4545#include <task.h>
    46 #include <vol.h>
     46#include <types/vol.h>
    4747
    4848#include "part.h"
    … …  
    116116}
    117117
     118static void vol_part_add_srv(ipc_callid_t iid, ipc_call_t *icall)
     119{
     120        service_id_t sid;
     121        int rc;
     122
     123        sid = IPC_GET_ARG1(*icall);
     124
     125        rc = vol_part_add(sid);
     126        if (rc != EOK) {
     127                async_answer_0(iid, rc);
     128                return;
     129        }
     130
     131        async_answer_0(iid, EOK);
     132}
     133
     134
    118135static void vol_part_info_srv(ipc_callid_t iid, ipc_call_t *icall)
    119136{
    … …  
    124141
    125142        sid = IPC_GET_ARG1(*icall);
     143        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_info_srv(%zu)",
     144            sid);
    126145        rc = vol_part_find_by_id(sid, &part);
    127146        if (rc != EOK) {
    128147                async_answer_0(iid, ENOENT);
     148                log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_info_srv(%zu) - "
     149                    "not found", sid);
    129150                return;
    130151        }
    … …  
    133154        if (rc != EOK) {
    134155                async_answer_0(iid, EIO);
     156                log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_info_srv(%zu) - "
     157                    "get info failed (%d)", sid, rc);
    135158                return;
    136159        }
    … …  
    141164                async_answer_0(callid, EREFUSED);
    142165                async_answer_0(iid, EREFUSED);
     166                log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_info_srv(%zu) - "
     167                    "read receive failed", sid);
    143168                return;
    144169        }
    … …  
    147172                async_answer_0(callid, EINVAL);
    148173                async_answer_0(iid, EINVAL);
     174                log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_info_srv(%zu) - "
     175                    "incorrect size", sid);
    149176                return;
    150177        }
    … …  
    155182                async_answer_0(callid, rc);
    156183                async_answer_0(iid, rc);
    157                 return;
    158         }
    159 
     184                log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_info_srv(%zu) - "
     185                    "data read failed", sid);
     186                return;
     187        }
     188
     189        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_info_srv(%zu) - "
     190            "success", sid);
    160191        async_answer_0(iid, EOK);
    161192}
    … …  
    206237                        vol_get_parts_srv(callid, &call);
    207238                        break;
     239                case VOL_PART_ADD:
     240                        vol_part_add_srv(callid, &call);
     241                        break;
    208242                case VOL_PART_INFO:
    209243                        vol_part_info_srv(callid, &call);
Note: See TracChangeset for help on using the changeset viewer.