Changeset c02d098 in mainline

Timestamp:

2015-07-29T20:35:40Z (9 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

100b1d1

Parents:

c43db5f

Message:

Most of logical partition support.

Location:

uspace

Files:

• lib/c/include/vbd.h (modified) (1 diff)
• lib/fdisk/include/types/fdisk.h (modified) (2 diffs)
• lib/fdisk/src/fdisk.c (modified) (15 diffs)
• lib/label/include/std/mbr.h (modified) (1 diff)
• lib/label/include/types/liblabel.h (modified) (3 diffs)
• lib/label/src/gpt.c (modified) (2 diffs)
• lib/label/src/mbr.c (modified) (17 diffs)
• srv/bd/vbd/disk.c (modified) (3 diffs)

uspace/lib/c/include/vbd.h

@@ -69 +69 @@
         /** Number of blocks */
         aoff64_t nblocks;
+        /** Number of header blocks (EBR for logical partitions) */
+        aoff64_t hdr_blocks;
         /** Partition kind */
         label_pkind_t pkind;

uspace/lib/fdisk/include/types/fdisk.h

@@ -106 +106 @@
         /** Service ID */
         service_id_t sid;
-        /** Partitions sorted by index */
-        list_t parts_idx; /* of fdisk_part_t */
-        /** Partitions sorted by block address */
-        list_t parts_ba;
+        /** All partitions */
+        list_t parts;
+        /** Primary partitions sorted by index */
+        list_t pri_idx; /* of fdisk_part_t */
+        /** Primary partitions sorted by block address */
+        list_t pri_ba;
+        /** Logical partitions sorted by block address */
+        list_t log_ba;
+        /** Extended partition or NULL */
+        struct fdisk_part *ext_part;
         /** Disk info */
         vbd_disk_info_t dinfo;
+        /** Alignment in blocks */
+        uint64_t align;
 } fdisk_dev_t;
 
@@ -124 +132 @@
 
 /** Partition */
-typedef struct {
+typedef struct fdisk_part {
         /** Containing device */
         fdisk_dev_t *dev;
-        /** Link to fdisk_dev_t.parts_idx */
-        link_t ldev_idx;
-        /** Link to fdisk_dev_t.parts_ba */
-        link_t ldev_ba;
+        /** Link to fdisk_dev_t.parts */
+        link_t lparts;
+        /** Link to fdisk_dev_t.pri_idx */
+        link_t lpri_idx;
+        /** Link to fdisk_dev_t.pri_ba */
+        link_t lpri_ba;
+        /** Link to fdisk_dev_t.log_ba */
+        link_t llog_ba;
         /** Capacity */
         fdisk_cap_t capacity;

uspace/lib/fdisk/src/fdisk.c

@@ -60 +60 @@
 static int fdisk_part_spec_prepare(fdisk_dev_t *, fdisk_part_spec_t *,
     vbd_part_spec_t *);
+static void fdisk_pri_part_insert_lists(fdisk_dev_t *, fdisk_part_t *);
+static void fdisk_log_part_insert_lists(fdisk_dev_t *, fdisk_part_t *);
+static int fdisk_update_dev_info(fdisk_dev_t *);
 
 static void fdisk_dev_info_delete(fdisk_dev_info_t *info)
@@ -252 +255 @@
     fdisk_part_t **rpart)
 {
-        fdisk_part_t *part, *p;
+        fdisk_part_t *part;
         vbd_part_info_t pinfo;
-        link_t *link;
         int rc;
 
@@ -273 +275 @@
         part->pkind = pinfo.pkind;
 
-        /* Insert to list by block address */
-        link = list_first(&dev->parts_ba);
-        while (link != NULL) {
-                p = list_get_instance(link, fdisk_part_t, ldev_ba);
-                if (p->block0 > part->block0) {
-                        list_insert_before(&part->ldev_ba, &p->ldev_ba);
-                        break;
-                }
-
-                link = list_next(link, &dev->parts_ba);
-        }
-
-        if (link == NULL)
-                list_append(&part->ldev_ba, &dev->parts_ba);
-
-        /* Insert to list by index */
-        link = list_first(&dev->parts_idx);
-        while (link != NULL) {
-                p = list_get_instance(link, fdisk_part_t, ldev_idx);
-                if (p->index > part->index) {
-                        list_insert_before(&part->ldev_idx, &p->ldev_idx);
-                        break;
-                }
-
-                link = list_next(link, &dev->parts_idx);
-        }
-
-        if (link == NULL)
-                list_append(&part->ldev_idx, &dev->parts_idx);
+        switch (part->pkind) {
+        case lpk_primary:
+        case lpk_extended:
+                fdisk_pri_part_insert_lists(dev, part);
+                break;
+        case lpk_logical:
+                fdisk_log_part_insert_lists(dev, part);
+                break;
+        }
+
+        list_append(&part->lparts, &dev->parts);
+
+        if (part->pkind == lpk_extended)
+                dev->ext_part = part;
 
         part->capacity.cunit = cu_byte;
@@ -315 +302 @@
 }
 
+static void fdisk_pri_part_insert_lists(fdisk_dev_t *dev, fdisk_part_t *part)
+{
+        link_t *link;
+        fdisk_part_t *p;
+
+        /* Insert to list by block address */
+        link = list_first(&dev->pri_ba);
+        while (link != NULL) {
+                p = list_get_instance(link, fdisk_part_t, lpri_ba);
+                if (p->block0 > part->block0) {
+                        list_insert_before(&part->lpri_ba, &p->lpri_ba);
+                        break;
+                }
+
+                link = list_next(link, &dev->pri_ba);
+        }
+
+        if (link == NULL)
+                list_append(&part->lpri_ba, &dev->pri_ba);
+
+        /* Insert to list by index */
+        link = list_first(&dev->pri_idx);
+        while (link != NULL) {
+                p = list_get_instance(link, fdisk_part_t, lpri_idx);
+                if (p->index > part->index) {
+                        list_insert_before(&part->lpri_idx, &p->lpri_idx);
+                        break;
+                }
+
+                link = list_next(link, &dev->pri_idx);
+        }
+
+        if (link == NULL)
+                list_append(&part->lpri_idx, &dev->pri_idx);
+}
+
+static void fdisk_log_part_insert_lists(fdisk_dev_t *dev, fdisk_part_t *part)
+{
+        link_t *link;
+        fdisk_part_t *p;
+
+        /* Insert to list by block address */
+        link = list_first(&dev->log_ba);
+        while (link != NULL) {
+                p = list_get_instance(link, fdisk_part_t, llog_ba);
+                if (p->block0 > part->block0) {
+                        list_insert_before(&part->llog_ba, &p->llog_ba);
+                        break;
+                }
+
+                link = list_next(link, &dev->log_ba);
+        }
+
+        if (link == NULL)
+                list_append(&part->llog_ba, &dev->log_ba);
+}
 
 int fdisk_dev_open(fdisk_t *fdisk, service_id_t sid, fdisk_dev_t **rdev)
@@ -330 +373 @@
         dev->fdisk = fdisk;
         dev->sid = sid;
-        list_initialize(&dev->parts_idx);
-        list_initialize(&dev->parts_ba);
+        list_initialize(&dev->parts);
+        list_initialize(&dev->pri_idx);
+        list_initialize(&dev->pri_ba);
+        list_initialize(&dev->log_ba);
 
         rc = vol_disk_info(fdisk->vol, sid, &vinfo);
@@ -345 +390 @@
 
         printf("get label info\n");
-        rc = vbd_disk_info(fdisk->vbd, sid, &dev->dinfo);
+        rc = fdisk_update_dev_info(dev);
         if (rc != EOK) {
                 printf("failed\n");
@@ -451 +496 @@
 int fdisk_label_create(fdisk_dev_t *dev, label_type_t ltype)
 {
-        return vol_label_create(dev->fdisk->vol, dev->sid, ltype);
+        int rc;
+
+        rc = vol_label_create(dev->fdisk->vol, dev->sid, ltype);
+        if (rc != EOK)
+                return rc;
+
+        rc = fdisk_update_dev_info(dev);
+        if (rc != EOK)
+                return rc;
+
+        return EOK;
 }
 
@@ -477 +532 @@
         link_t *link;
 
-        link = list_first(&dev->parts_ba);
+        link = list_first(&dev->parts);
         if (link == NULL)
                 return NULL;
 
-        return list_get_instance(link, fdisk_part_t, ldev_ba);
+        return list_get_instance(link, fdisk_part_t, lparts);
 }
 
@@ -488 +543 @@
         link_t *link;
 
-        link = list_next(&part->ldev_ba, &part->dev->parts_ba);
+        link = list_next(&part->lparts, &part->dev->parts);
         if (link == NULL)
                 return NULL;
 
-        return list_get_instance(link, fdisk_part_t, ldev_ba);
+        return list_get_instance(link, fdisk_part_t, lparts);
 }
 
@@ -552 +607 @@
                 return EIO;
 
-        list_remove(&part->ldev_ba);
-        list_remove(&part->ldev_idx);
+        list_remove(&part->lparts);
+        if (link_used(&part->lpri_ba))
+                list_remove(&part->lpri_ba);
+        if (link_used(&part->lpri_idx))
+                list_remove(&part->lpri_idx);
+        if (link_used(&part->llog_ba))
+                list_remove(&part->llog_ba);
         free(part);
         return EOK;
@@ -707 +767 @@
         int nidx;
 
-        link = list_first(&dev->parts_idx);
+        link = list_first(&dev->pri_idx);
         nidx = 1;
         while (link != NULL) {
-                part = list_get_instance(link, fdisk_part_t, ldev_idx);
+                part = list_get_instance(link, fdisk_part_t, lpri_idx);
                 if (part->index > nidx)
                         break;
                 nidx = part->index + 1;
-                link = list_next(link, &dev->parts_idx);
+                link = list_next(link, &dev->pri_idx);
         }
 
@@ -737 +797 @@
         int nba;
 
-        link = list_first(&dev->parts_ba);
+        link = list_first(&dev->pri_ba);
         nba = dev->dinfo.ablock0;
         while (link != NULL) {
-                part = list_get_instance(link, fdisk_part_t, ldev_ba);
+                part = list_get_instance(link, fdisk_part_t, lpri_ba);
                 if (part->block0 - nba >= nblocks)
                         break;
                 nba = part->block0 + part->nblocks;
-                link = list_next(link, &dev->parts_ba);
+                link = list_next(link, &dev->pri_ba);
         }
 
@@ -764 +824 @@
 }
 
+/** Get free range of blocks in extended partition.
+ *
+ * Get free range of blocks in extended partition that can accomodate
+ * a partition of at least the specified size plus the header (EBR + padding).
+ * Returns the header size in blocks, the start and length of the partition.
+ */
+static int fdisk_part_get_log_free_range(fdisk_dev_t *dev, aoff64_t nblocks,
+    aoff64_t *rhdrb, aoff64_t *rblock0, aoff64_t *rnblocks)
+{
+        link_t *link;
+        fdisk_part_t *part;
+        uint64_t avail;
+        uint64_t hdrb;
+        int nba;
+
+        /* Number of header blocks */
+        hdrb = max(1, dev->align);
+
+        link = list_first(&dev->log_ba);
+        nba = dev->ext_part->block0;
+        while (link != NULL) {
+                part = list_get_instance(link, fdisk_part_t, llog_ba);
+                if (part->block0 - nba >= nblocks)
+                        break;
+                nba = part->block0 + part->nblocks;
+                link = list_next(link, &dev->log_ba);
+        }
+
+        if (link != NULL) {
+                /* Free range before a partition */
+                avail = part->block0 - nba;
+        } else {
+                /* Free range at the end */
+                avail = dev->ext_part->block0 + dev->ext_part->nblocks - nba;
+
+                /* Verify that the range is large enough */
+                if (avail < hdrb + nblocks)
+                        return ELIMIT;
+        }
+
+        *rhdrb = hdrb;
+        *rblock0 = nba + hdrb;
+        *rnblocks = avail;
+        return EOK;
+}
+
 /** Prepare new partition specification for VBD. */
 static int fdisk_part_spec_prepare(fdisk_dev_t *dev, fdisk_part_spec_t *pspec,
@@ -770 +876 @@
         uint64_t cbytes;
         aoff64_t req_blocks;
+        aoff64_t fhdr;
         aoff64_t fblock0;
         aoff64_t fnblocks;
@@ -778 +885 @@
 
 //      pspec->fstype
-        printf("fdisk_part_spec_prepare()\n");
+        printf("fdisk_part_spec_prepare() - dev=%p pspec=%p vpspec=%p\n", dev, pspec,
+            vpspec);
+        printf("fdisk_part_spec_prepare() - block size\n");
         block_size = dev->dinfo.block_size;
+        printf("fdisk_part_spec_prepare() - cbytes\n");
         cbytes = pspec->capacity.value;
+        printf("fdisk_part_spec_prepare() - cunit\n");
         for (i = 0; i < pspec->capacity.cunit; i++)
                 cbytes = cbytes * 1000;
 
+        printf("fdisk_part_spec_prepare() - req_blocks block_size=%zu\n",
+            block_size);
         req_blocks = (cbytes + block_size - 1) / block_size;
 
-        rc = fdisk_part_get_free_idx(dev, &index);
+        printf("fdisk_part_spec_prepare() - switch\n");
+        switch (pspec->pkind) {
+        case lpk_primary:
+        case lpk_extended:
+                printf("fdisk_part_spec_prepare() - pri/ext\n");
+                rc = fdisk_part_get_free_idx(dev, &index);
+                if (rc != EOK)
+                        return EIO;
+
+                printf("fdisk_part_spec_prepare() - get free range\n");
+                rc = fdisk_part_get_free_range(dev, req_blocks, &fblock0, &fnblocks);
+                if (rc != EOK)
+                        return EIO;
+
+                printf("fdisk_part_spec_prepare() - memset\n");
+                memset(vpspec, 0, sizeof(vbd_part_spec_t));
+                vpspec->index = index;
+                vpspec->block0 = fblock0;
+                vpspec->nblocks = req_blocks;
+                vpspec->pkind = pspec->pkind;
+                if (pspec->pkind != lpk_extended)
+                        vpspec->ptype = 42;
+                break;
+        case lpk_logical:
+                printf("fdisk_part_spec_prepare() - log\n");
+                rc = fdisk_part_get_log_free_range(dev, req_blocks, &fhdr,
+                    &fblock0, &fnblocks);
+                if (rc != EOK)
+                        return EIO;
+
+                memset(vpspec, 0, sizeof(vbd_part_spec_t));
+                vpspec->hdr_blocks = fhdr;
+                vpspec->block0 = fblock0;
+                vpspec->nblocks = req_blocks;
+                vpspec->pkind = lpk_logical;
+                vpspec->ptype = 42;
+                break;
+        }
+
+        return EOK;
+}
+
+static int fdisk_update_dev_info(fdisk_dev_t *dev)
+{
+        int rc;
+        size_t align_bytes;
+
+        rc = vbd_disk_info(dev->fdisk->vbd, dev->sid, &dev->dinfo);
         if (rc != EOK)
                 return EIO;
 
-        rc = fdisk_part_get_free_range(dev, req_blocks, &fblock0, &fnblocks);
-        if (rc != EOK)
-                return EIO;
-
-        memset(vpspec, 0, sizeof(vbd_part_spec_t));
-        vpspec->index = index;
-        vpspec->block0 = fblock0;
-        vpspec->nblocks = req_blocks;
-        vpspec->pkind = pspec->pkind;
-        if (pspec->pkind != lpk_extended)
-                vpspec->ptype = 42;
-
+        align_bytes = 512; //1024 * 1024; /* 1 MiB */ /* XXX */
+        dev->align = align_bytes / dev->dinfo.block_size;
+        if (dev->align < 1)
+                dev->align = 1;
         return EOK;
 }

uspace/lib/label/include/std/mbr.h

@@ -49 +49 @@
 
         /** Boot record signature */
-        mbr_br_signature = 0xAA55
+        mbr_br_signature = 0xAA55,
+
+        /** EBR PTE slot describing partition corresponding to this EBR */
+        mbr_ebr_pte_this = 0,
+        /** EBR PTE slot describing the next EBR */
+        mbr_ebr_pte_next = 1
 };
 

uspace/lib/label/include/types/liblabel.h

@@ -99 +99 @@
         /** Index */
         int index;
+        /** Number of EBR blocks preceding a logical partition */
+        aoff64_t hdr_blocks;
         /** First block */
         aoff64_t block0;
@@ -117 +119 @@
         /** Number of blocks */
         aoff64_t nblocks;
+        /** Number of header blocks (EBR for logical partitions) */
+        aoff64_t hdr_blocks;
         /** Partition kind */
         label_pkind_t pkind;
@@ -155 +159 @@
         /** Number of primary partition entries */
         int pri_entries;
-        /** Index of extended partition or -1 if there is none */
-        int ext_part_idx;
+        /** Extended partition or NULL if there is none */
+        label_part_t *ext_part;
         /** Block size */
         size_t block_size;

uspace/lib/label/src/gpt.c

@@ -302 +302 @@
         label->pri_entries = num_entries;
         label->block_size = bsize;
-        label->ext_part_idx = -1;
 
         label->lt.gpt.hdr_ba[0] = gpt_hdr_ba;
@@ -449 +448 @@
         label->pri_entries = num_entries;
         label->block_size = bsize;
-        label->ext_part_idx = -1;
 
         label->lt.gpt.hdr_ba[0] = hdr_ba[0];

uspace/lib/label/src/mbr.c

@@ -44 +44 @@
 
 static int mbr_open(service_id_t, label_t **);
+static int mbr_open_ext(label_t *);
 static int mbr_create(service_id_t, label_t **);
 static void mbr_close(label_t *);
@@ -57 +58 @@
 static int mbr_part_to_pte(label_part_t *, mbr_pte_t *);
 static int mbr_pte_to_part(label_t *, mbr_pte_t *, int);
+static int mbr_pte_to_log_part(label_t *, uint64_t, mbr_pte_t *);
+static void mbr_log_part_to_ptes(label_part_t *, mbr_pte_t *, mbr_pte_t *);
 static int mbr_pte_update(label_t *, mbr_pte_t *, int);
+static int mbr_log_part_insert(label_t *, label_part_t *);
+static int mbr_ebr_create(label_t *, label_part_t *);
+static int mbr_ebr_delete(label_t *, label_part_t *);
+static int mbr_ebr_update_next(label_t *, label_part_t *);
+static void mbr_update_log_indices(label_t *);
 
 label_ops_t mbr_label_ops = {
@@ -132 +140 @@
         }
 
-        label->ext_part_idx = -1;
+
+        label->ext_part = NULL;
         for (entry = 0; entry < mbr_nprimary; entry++) {
                 eptr = &mbr->pte[entry];
@@ -150 +159 @@
         label->anblocks = nblocks - mbr_ablock0;
         label->pri_entries = mbr_nprimary;
+
+        if (label->ext_part != NULL) {
+                /* Open extended partition */
+                rc = mbr_open_ext(label);
+                if (rc != EOK)
+                        goto error;
+        }
+
         *rlabel = label;
         return EOK;
 error:
         free(mbr);
-        free(label);
+        mbr_close(label);
+        return rc;
+}
+
+/** Open extended partition */
+static int mbr_open_ext(label_t *label)
+{
+        mbr_br_block_t *ebr = NULL;
+        mbr_pte_t *ethis;
+        mbr_pte_t *enext;
+        uint64_t ebr_b0;
+        uint64_t ebr_nblocks_min;
+        uint64_t ebr_nblocks_max;
+        uint64_t pebr_b0;
+        uint64_t pebr_nblocks;
+        uint64_t pb0;
+        uint64_t pnblocks;
+        uint64_t ep_b0;
+        int rc;
+
+        ebr = calloc(1, label->block_size);
+        if (ebr == NULL) {
+                rc = ENOMEM;
+                goto error;
+        }
+
+        /* First block of extended partition */
+        ep_b0 = label->ext_part->block0;
+
+        /* First block of current EBR */
+        ebr_b0 = label->ext_part->block0;
+
+        /*
+         * We don't have bounds for the first EBR, so for purpose of
+         * verification let's say it contains at least one block and
+         * at most all blocks from the extended partition.
+         */
+        ebr_nblocks_min = 1;
+        ebr_nblocks_max = label->ext_part->nblocks;
+
+        while (true) {
+                /* Read EBR */
+                rc = block_read_direct(label->svc_id, ebr_b0, 1, ebr);
+                if (rc != EOK) {
+                        rc = EIO;
+                        goto error;
+                }
+
+                ethis = &ebr->pte[mbr_ebr_pte_this];
+                enext = &ebr->pte[mbr_ebr_pte_next];
+
+                pb0 = ebr_b0 + uint32_t_le2host(ethis->first_lba);
+                pnblocks = uint32_t_le2host(ethis->length);
+
+                if (ethis->ptype == mbr_pt_unused || pnblocks == 0)
+                        break;
+
+                /* Verify partition lies within the range of EBR */
+                if (pb0 + pnblocks > ebr_b0 + ebr_nblocks_max) {
+                        rc = EIO;
+                        goto error;
+                }
+
+                /* Create partition structure */
+                rc = mbr_pte_to_log_part(label, ebr_b0, ethis);
+                if (rc != EOK) {
+                        rc= EIO;
+                        goto error;
+                }
+
+                /* Save previous EBR range */
+                pebr_b0 = ebr_b0;
+                pebr_nblocks = ebr_nblocks_min;
+
+                /* Proceed to next EBR */
+                ebr_b0 = ep_b0 + uint32_t_le2host(enext->first_lba);
+                ebr_nblocks_min = uint32_t_le2host(enext->length);
+                ebr_nblocks_max = ebr_nblocks_min;
+
+                if (enext->ptype == mbr_pt_unused || ebr_nblocks_min == 0)
+                        break;
+
+                /* Verify next EBR does not overlap this EBR */
+                if (ebr_b0 < pebr_b0 + pebr_nblocks) {
+                        rc = EIO;
+                        goto error;
+                }
+
+                /* Verify next EBR does not extend beyond end of label */
+                if (ebr_b0 + ebr_nblocks_max > label->ablock0 + label->anblocks) {
+                        rc = EIO;
+                        goto error;
+                }
+        }
+
+        free(ebr);
+        return EOK;
+error:
+        /* Note that logical partitions need to be deleted by caller */
+        free(ebr);
         return rc;
 }
@@ -215 +331 @@
         label->anblocks = nblocks - mbr_ablock0;
         label->pri_entries = mbr_nprimary;
-        label->ext_part_idx = -1;
+        label->ext_part = NULL;
 
         *rlabel = label;
@@ -228 +344 @@
 {
         label_part_t *part;
+
+        if (label == NULL)
+                return;
 
         part = mbr_part_first(label);
@@ -291 +410 @@
                 linfo->flags |= lf_can_create_pri;
         /* Can create extended if there is a free slot and no extended */
-        if ((linfo->flags & lf_can_create_pri) != 0 && label->ext_part_idx < 0)
+        if ((linfo->flags & lf_can_create_pri) != 0 && label->ext_part == NULL)
                 linfo->flags |= lf_can_create_ext;
         /* Can create logical if there is an extended partition */
-        if (label->ext_part_idx >= 0)
+        if (label->ext_part != NULL)
                 linfo->flags |= lf_can_create_log;
 
@@ -323 +442 @@
 
         return list_get_instance(link, label_part_t, lparts);
+}
+
+static label_part_t *mbr_log_part_first(label_t *label)
+{
+        link_t *link;
+
+        link = list_first(&label->log_parts);
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, label_part_t, llog);
+}
+
+static label_part_t *mbr_log_part_next(label_part_t *part)
+{
+        link_t *link;
+
+        link = list_next(&part->llog, &part->label->log_parts);
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, label_part_t, llog);
+}
+
+static label_part_t *mbr_log_part_prev(label_part_t *part)
+{
+        link_t *link;
+
+        link = list_prev(&part->llog, &part->label->log_parts);
+        if (link == NULL)
+                return NULL;
+
+        return list_get_instance(link, label_part_t, llog);
 }
 
@@ -346 +498 @@
 {
         label_part_t *part;
+        label_part_t *prev;
+        label_part_t *next;
         mbr_pte_t pte;
         int rc;
@@ -360 +514 @@
         part->block0 = pspec->block0;
         part->nblocks = pspec->nblocks;
+        part->hdr_blocks = pspec->hdr_blocks;
 
         switch (pspec->pkind) {
@@ -371 +526 @@
                         goto error;
                 }
-                if (label->ext_part_idx >= 0) {
+                if (label->ext_part != NULL) {
                         rc = EEXISTS;
                         goto error;
@@ -377 +532 @@
                 break;
         case lpk_logical:
+                log_msg(LOG_DEFAULT, LVL_NOTE, "check index");
                 part->ptype = pspec->ptype;
                 if (pspec->index != 0) {
@@ -394 +550 @@
                 }
 
+                if (pspec->hdr_blocks != 0) {
+                        rc = EINVAL;
+                        goto error;
+                }
+
                 rc = mbr_part_to_pte(part, &pte);
                 if (rc != EOK) {
@@ -410 +571 @@
 
                 if (pspec->pkind == lpk_extended)
-                        label->ext_part_idx = pspec->index - 1;
+                        label->ext_part = part;
         } else {
                 /* Logical partition */
-                rc = ENOTSUP;
-                goto error;
-        }
-
+
+                log_msg(LOG_DEFAULT, LVL_NOTE, "call mbr_log_part_insert");
+                rc = mbr_log_part_insert(label, part);
+                if (rc != EOK)
+                        goto error;
+
+                log_msg(LOG_DEFAULT, LVL_NOTE, "call mbr_ebr_create");
+                /* Create EBR for new partition */
+                rc = mbr_ebr_create(label, part);
+                if (rc != EOK)
+                        goto error;
+
+                prev = mbr_log_part_prev(part);
+                if (prev != NULL) {
+                        log_msg(LOG_DEFAULT, LVL_NOTE, "update next");
+                        /* Update 'next' PTE in EBR of previous partition */
+                        rc = mbr_ebr_update_next(label, prev);
+                        if (rc != EOK) {
+                                log_msg(LOG_DEFAULT, LVL_NOTE, "failed to update next");
+                                goto error;
+                        }
+                } else {
+                        log_msg(LOG_DEFAULT, LVL_NOTE, "relocate first EBR");
+                        /* New partition is now the first one */
+                        next = mbr_log_part_next(part);
+                        if (next != NULL) {
+                                /*
+                                 * Create new, relocated EBR for the former
+                                 * first partition
+                                 */
+                                next->hdr_blocks = pspec->hdr_blocks;
+                                rc = mbr_ebr_create(label, next);
+                                if (rc != EOK)
+                                        goto error;
+                        }
+                }
+
+                /* This also sets index for the new partition. */
+                mbr_update_log_indices(label);
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_part_create success");
         *rpart = part;
         return EOK;
@@ -427 +626 @@
 {
         mbr_pte_t pte;
+        label_part_t *prev;
         int rc;
 
-        /* Prepare unused partition table entry */
-        mbr_unused_pte(&pte);
-
-        /* Modify partition table */
-        rc = mbr_pte_update(part->label, &pte, part->index - 1);
-        if (rc != EOK)
-                return EIO;
-
-        /* If it was the extended partition, clear ext. part. index */
-        if (part->index - 1 == part->label->ext_part_idx)
-                part->label->ext_part_idx = -1;
+        if (link_used(&part->lpri)) {
+                /* Primary/extended partition */
+
+                /* Prepare unused partition table entry */
+                mbr_unused_pte(&pte);
+
+                /* Modify partition table */
+                rc = mbr_pte_update(part->label, &pte, part->index - 1);
+                if (rc != EOK)
+                        return EIO;
+
+                /* If it was the extended partition, clear ext. part. pointer */
+                if (part == part->label->ext_part)
+                        part->label->ext_part = NULL;
+
+                list_remove(&part->lpri);
+        } else {
+                /* Logical partition */
+
+                prev = mbr_log_part_prev(part);
+                if (prev != NULL) {
+                        /* Update next link in previous EBR */
+                        list_remove(&part->llog);
+
+                        rc = mbr_ebr_update_next(part->label, prev);
+                        if (rc != EOK) {
+                                /* Roll back */
+                                list_insert_after(&part->llog, &prev->llog);
+                                return EIO;
+                        }
+                } else {
+                        list_remove(&part->llog);
+                }
+
+                /* Delete EBR */
+                mbr_ebr_delete(part->label, part);
+        }
 
         list_remove(&part->lparts);
-        if (link_used(&part->lpri))
-                list_remove(&part->lpri);
-        if (link_used(&part->llog))
-                list_remove(&part->llog);
         free(part);
         return EOK;
@@ -507 +729 @@
 
         if (pte->ptype == mbr_pt_extended)
-                label->ext_part_idx = index - 1;
-        return EOK;
+                label->ext_part = part;
+        return EOK;
+}
+
+static int mbr_pte_to_log_part(label_t *label, uint64_t ebr_b0,
+    mbr_pte_t *pte)
+{
+        label_part_t *part;
+        uint32_t block0;
+        uint32_t nblocks;
+        size_t nlparts;
+
+        block0 = ebr_b0 + uint32_t_le2host(pte->first_lba);
+        nblocks = uint32_t_le2host(pte->length);
+
+        if (pte->ptype == mbr_pt_unused || nblocks == 0)
+                return EOK;
+
+        part = calloc(1, sizeof(label_part_t));
+        if (part == NULL)
+                return ENOMEM;
+
+        nlparts = list_count(&label->log_parts);
+
+        part->ptype = pte->ptype;
+        part->index = mbr_nprimary + 1 + nlparts;
+        part->block0 = block0;
+        part->nblocks = nblocks;
+
+        part->label = label;
+        list_append(&part->lparts, &label->parts);
+        list_append(&part->llog, &label->log_parts);
+
+        return EOK;
+}
+#include <stdio.h>
+static void mbr_log_part_to_ptes(label_part_t *part, mbr_pte_t *pthis,
+    mbr_pte_t *pnext)
+{
+        label_part_t *next;
+        uint64_t ep_b0;
+        uint64_t totsize;
+
+        /* First block of extended partition */
+        ep_b0 = part->label->ext_part->block0;
+
+        assert(link_used(&part->llog));
+        assert(part->block0 >= ep_b0);
+        printf("part->hdr_blocks = %" PRIu64 "\n", part->hdr_blocks);
+        printf("part->block0 = %" PRIu64 "\n", part->block0);
+        printf("ep_b0 = %" PRIu64 "\n", ep_b0);
+        assert(part->hdr_blocks <= part->block0 - ep_b0);
+
+        /* 'This' EBR entry */
+        if (pthis != NULL) {
+                memset(pthis, 0, sizeof(mbr_pte_t));
+                pthis->ptype = part->ptype;
+                pthis->first_lba = host2uint32_t_le(part->hdr_blocks);
+                pthis->length = host2uint32_t_le(part->nblocks);
+        }
+
+        /* 'Next' EBR entry */
+        if (pnext != NULL) {
+                next = mbr_part_next(part);
+
+                memset(pnext, 0, sizeof(mbr_pte_t));
+                if (next != NULL) {
+                        /* Total size of EBR + partition */
+                        totsize = next->hdr_blocks + next->nblocks;
+
+                        pnext->ptype = mbr_pt_extended;
+                        pnext->first_lba = host2uint32_t_le(next->block0 -
+                            next->hdr_blocks - ep_b0);
+                        pnext->length = host2uint32_t_le(totsize);
+                }
+        }
 }
 
@@ -546 +842 @@
 }
 
+/** Insert logical partition into logical partition list. */
+static int mbr_log_part_insert(label_t *label, label_part_t *part)
+{
+        label_part_t *cur;
+
+        cur = mbr_log_part_first(label);
+        while (cur != NULL) {
+                if (cur->block0 + cur->nblocks > part->block0)
+                        break;
+                cur = mbr_log_part_next(part);
+        }
+
+        if (cur != NULL)
+                list_insert_before(&part->llog, &cur->llog);
+        else
+                list_append(&part->llog, &label->log_parts);
+
+        return EOK;
+}
+
+/** Create EBR for partition. */
+static int mbr_ebr_create(label_t *label, label_part_t *part)
+{
+        mbr_br_block_t *br;
+        uint64_t ba;
+        int rc;
+
+        br = calloc(1, label->block_size);
+        if (br == NULL)
+                return ENOMEM;
+
+        mbr_log_part_to_ptes(part, &br->pte[mbr_ebr_pte_this],
+            &br->pte[mbr_ebr_pte_next]);
+        br->signature = host2uint16_t_le(mbr_br_signature);
+
+        ba = part->block0 - part->hdr_blocks;
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "Write EBR to ba=%" PRIu64, ba);
+        rc = block_write_direct(label->svc_id, ba, 1, br);
+        if (rc != EOK) {
+                rc = EIO;
+                goto error;
+        }
+
+        free(br);
+        return EOK;
+error:
+        free(br);
+        return rc;
+}
+
+static int mbr_ebr_delete(label_t *label, label_part_t *part)
+{
+        mbr_br_block_t *br;
+        uint64_t ba;
+        int rc;
+
+        br = calloc(1, label->block_size);
+        if (br == NULL)
+                return ENOMEM;
+
+        ba = part->block0 - part->hdr_blocks;
+
+        rc = block_write_direct(label->svc_id, ba, 1, br);
+        if (rc != EOK) {
+                rc = EIO;
+                goto error;
+        }
+
+        free(br);
+        return EOK;
+error:
+        free(br);
+        return rc;
+}
+
+/** Update 'next' PTE in EBR of partition. */
+static int mbr_ebr_update_next(label_t *label, label_part_t *part)
+{
+        mbr_br_block_t *br;
+        uint64_t ba;
+        uint16_t sgn;
+        int rc;
+
+        ba = part->block0 - part->hdr_blocks;
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_ebr_update_next ba=%" PRIu64,
+            ba);
+
+        br = calloc(1, label->block_size);
+        if (br == NULL)
+                return ENOMEM;
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_ebr_update_next read ba=%" PRIu64,
+            ba);
+
+        rc = block_read_direct(label->svc_id, ba, 1, br);
+        if (rc != EOK) {
+                rc = EIO;
+                goto error;
+        }
+
+        /* Verify boot record signature */
+        sgn = uint16_t_le2host(br->signature);
+        if (sgn != mbr_br_signature) {
+                log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_ebr_update_next signature error");
+                rc = EIO;
+                goto error;
+        }
+
+        mbr_log_part_to_ptes(part, NULL, &br->pte[mbr_ebr_pte_next]);
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_ebr_update_next write ba=%" PRIu64,
+            ba);
+
+        rc = block_write_direct(label->svc_id, ba, 1, br);
+        if (rc != EOK) {
+                rc = EIO;
+                goto error;
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_ebr_update_next success");
+
+        free(br);
+        return EOK;
+error:
+        free(br);
+        return rc;
+}
+
+/** Update indices of logical partitions.
+ *
+ * Logical partition indices are unstable, i.e. they can change during
+ * the lifetime of a logical partition. Since the index corresponds to the
+ * position of the partition in order of block address, anytime a partition
+ * is created or deleted, indices of all partitions at higher addresses
+ * change.
+ */
+static void mbr_update_log_indices(label_t *label)
+{
+        label_part_t *part;
+        int idx;
+
+        idx = mbr_nprimary + 1;
+
+        part = mbr_log_part_first(label);
+        while (part != NULL) {
+                part->index = idx++;
+                part = mbr_log_part_next(part);
+        }
+}
+
 /** @}
  */

uspace/srv/bd/vbd/disk.c

@@ -346 +346 @@
         info->anblocks = linfo.anblocks;
         info->block_size = disk->block_size;
+        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_disk_info - block_size=%zu",
+            info->block_size);
         return EOK;
 }
@@ -438 +440 @@
         disk->label = label;
         disk->block_size = block_size;
+        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_label_create: block_size=%zu",
+            block_size);
         list_initialize(&disk->parts);
 
@@ -519 +523 @@
         lpspec.block0 = pspec->block0;
         lpspec.nblocks = pspec->nblocks;
+        lpspec.hdr_blocks = pspec->hdr_blocks;
         lpspec.pkind = pspec->pkind;
         lpspec.ptype = pspec->ptype;