Changeset b598460a in mainline for uspace/lib/fdisk/src/fdisk.c

Timestamp:

2015-10-21T09:27:06Z (9 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

852664b9

Parents:

68b5dd11

Message:

Suggest maximum available free space as the default for partition size.

File:

• uspace/lib/fdisk/src/fdisk.c (modified) (13 diffs)

uspace/lib/fdisk/src/fdisk.c

@@ -67 +67 @@
 static uint64_t fdisk_ba_align_up(fdisk_dev_t *, uint64_t);
 static uint64_t fdisk_ba_align_down(fdisk_dev_t *, uint64_t);
+static int fdisk_part_get_max_free_range(fdisk_dev_t *, fdisk_spc_t, aoff64_t *,
+    aoff64_t *);
+static void fdisk_free_range_first(fdisk_dev_t *, fdisk_spc_t, fdisk_free_range_t *);
+static bool fdisk_free_range_next(fdisk_free_range_t *);
+static bool fdisk_free_range_get(fdisk_free_range_t *, aoff64_t *, aoff64_t *);
 
 static void fdisk_dev_info_delete(fdisk_dev_info_t *info)
@@ -278 +283 @@
         }
 
-        printf("vol_part_add(%zu)...\n", pinfo.svc_id);
-        /*
-         * Normally vol service discovers the partition asynchronously.
-         * Here we need to make sure the partition is already known to it.
-         */
-        rc = vol_part_add(dev->fdisk->vol, pinfo.svc_id);
-        printf("vol_part_add->rc = %d\n", rc);
-        if (rc != EOK && rc != EEXIST) {
-                rc = EIO;
-                goto error;
-        }
-
-        printf("vol_part_info(%zu)\n", pinfo.svc_id);
-        rc = vol_part_info(dev->fdisk->vol, pinfo.svc_id, &vpinfo);
-        printf("vol_part_info->rc = %d\n", rc);
-        if (rc != EOK) {
-                rc = EIO;
-                goto error;
+        if (pinfo.svc_id != 0) {
+                printf("vol_part_add(%zu)...\n", pinfo.svc_id);
+                /*
+                 * Normally vol service discovers the partition asynchronously.
+                 * Here we need to make sure the partition is already known to it.
+                 */
+                rc = vol_part_add(dev->fdisk->vol, pinfo.svc_id);
+                printf("vol_part_add->rc = %d\n", rc);
+                if (rc != EOK && rc != EEXIST) {
+                        rc = EIO;
+                        goto error;
+                }
+
+                printf("vol_part_info(%zu)\n", pinfo.svc_id);
+                rc = vol_part_info(dev->fdisk->vol, pinfo.svc_id, &vpinfo);
+                printf("vol_part_info->rc = %d\n", rc);
+                if (rc != EOK) {
+                        rc = EIO;
+                        goto error;
+                }
+
+                part->pcnt = vpinfo.pcnt;
+                part->fstype = vpinfo.fstype;
         }
 
@@ -304 +314 @@
         part->pkind = pinfo.pkind;
         part->svc_id = pinfo.svc_id;
-        part->pcnt = vpinfo.pcnt;
-        part->fstype = vpinfo.fstype;
 
         switch (part->pkind) {
@@ -620 +628 @@
 {
         vbd_disk_info_t vinfo;
+        uint64_t b0, nb;
+        uint64_t hdrb;
         int rc;
 
@@ -630 +640 @@
         info->ltype = vinfo.ltype;
         info->flags = vinfo.flags;
+
+        if ((info->flags & lf_can_create_pri) != 0 ||
+            (info->flags & lf_can_create_ext) != 0) {
+                /* Verify there is enough space to create partition */
+
+                rc = fdisk_part_get_max_free_range(dev, spc_pri, &b0, &nb);
+                if (rc != EOK)
+                        info->flags &= ~(lf_can_create_pri | lf_can_create_ext);
+        }
+
+        if ((info->flags & lf_can_create_log) != 0) {
+                /* Verify there is enough space to create logical partition */
+                hdrb = max(1, dev->align);
+                rc = fdisk_part_get_max_free_range(dev, spc_log, &b0, &nb);
+                if (rc != EOK || nb <= hdrb)
+                        info->flags &= ~lf_can_create_log;
+        }
+
         return EOK;
 error:
@@ -735 +763 @@
 }
 
-int fdisk_part_get_max_avail(fdisk_dev_t *dev, fdisk_cap_t *cap)
-{
+int fdisk_part_get_max_avail(fdisk_dev_t *dev, fdisk_spc_t spc, fdisk_cap_t *cap)
+{
+        int rc;
+        uint64_t b0;
+        uint64_t nb;
+        aoff64_t hdrb;
+
+        rc = fdisk_part_get_max_free_range(dev, spc, &b0, &nb);
+        if (rc != EOK)
+                return rc;
+
+        /* For logical partitions we need to subtract header size */
+        if (spc == spc_log) {
+                hdrb = max(1, dev->align);
+                if (nb <= hdrb)
+                        return ENOSPC;
+                nb -= hdrb;
+        }
+
+        cap->value = nb * dev->dinfo.block_size;
+        cap->cunit = cu_byte;
         return EOK;
 }
@@ -767 +814 @@
         }
 
-        rc = vol_part_mkfs(dev->fdisk->vol, part->svc_id, pspec->fstype);
-        if (rc != EOK && rc != ENOTSUP) {
-                printf("mkfs failed\n");
-                fdisk_part_remove(part);
-                (void) vbd_part_delete(dev->fdisk->vbd, partid);
-                return EIO;
+        if (part->svc_id != 0) {
+                rc = vol_part_mkfs(dev->fdisk->vol, part->svc_id, pspec->fstype);
+                if (rc != EOK && rc != ENOTSUP) {
+                        printf("mkfs failed\n");
+                        fdisk_part_remove(part);
+                        (void) vbd_part_delete(dev->fdisk->vbd, partid);
+                        return EIO;
+                }
         }
 
         printf("fdisk_part_create() - done\n");
-        part->pcnt = vpc_fs;
-        part->fstype = pspec->fstype;
+        if (part->svc_id != 0) {
+                part->pcnt = vpc_fs;
+                part->fstype = pspec->fstype;
+        }
+
         part->capacity = pspec->capacity;
 
@@ -966 +1018 @@
  */
 static int fdisk_part_get_free_range(fdisk_dev_t *dev, aoff64_t nblocks,
+    fdisk_spc_t spc, aoff64_t *rblock0, aoff64_t *rnblocks)
+{
+        fdisk_free_range_t fr;
+        uint64_t b0;
+        uint64_t nb;
+
+        fdisk_free_range_first(dev, spc, &fr);
+        do {
+                if (fdisk_free_range_get(&fr, &b0, &nb)) {
+                        printf("free range: [%" PRIu64 ",+%" PRIu64 "]\n",
+                            b0, nb);
+                        if (nb >= nblocks) {
+                                printf("accepted.\n");
+                                *rblock0 = b0;
+                                *rnblocks = nb;
+                                return EOK;
+                        }
+                }
+        } while (fdisk_free_range_next(&fr));
+
+        /* No conforming free range found */
+        return ENOSPC;
+}
+
+/** Get largest free range of blocks.
+ *
+ * Get free range of blocks of the maximum size.
+ */
+static int fdisk_part_get_max_free_range(fdisk_dev_t *dev, fdisk_spc_t spc,
     aoff64_t *rblock0, aoff64_t *rnblocks)
 {
-        link_t *link;
-        fdisk_part_t *part;
-        uint64_t avail;
-        uint64_t pb0;
-        uint64_t nba;
-
-        printf("fdisk_part_get_free_range: align=%" PRIu64 "\n",
-            dev->align);
-
-        link = list_first(&dev->pri_ba);
-        nba = fdisk_ba_align_up(dev, dev->dinfo.ablock0);
-        while (link != NULL) {
-                part = list_get_instance(link, fdisk_part_t, lpri_ba);
-                pb0 = fdisk_ba_align_down(dev, part->block0);
-                if (pb0 >= nba && pb0 - nba >= nblocks)
-                        break;
-                nba = fdisk_ba_align_up(dev, part->block0 + part->nblocks);
-                link = list_next(link, &dev->pri_ba);
-        }
-
-        if (link != NULL) {
-                printf("nba=%" PRIu64 " pb0=%" PRIu64 "\n",
-                    nba, pb0);
-                /* Free range before a partition */
-                avail = pb0 - nba;
-        } else {
-                /* Free range at the end */
-                pb0 = fdisk_ba_align_down(dev, dev->dinfo.ablock0 +
-                    dev->dinfo.anblocks);
-                if (pb0 < nba)
-                        return ELIMIT;
-                avail = pb0 - nba;
-                printf("nba=%" PRIu64 " avail=%" PRIu64 "\n",
-                    nba, avail);
-
-        }
-
-        /* Verify that the range is large enough */
-        if (avail < nblocks)
-                return ELIMIT;
-
-        *rblock0 = nba;
-        *rnblocks = avail;
-        return EOK;
-}
-
-/** 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;
-        uint64_t pb0;
-        uint64_t nba;
-
-        printf("fdisk_part_get_log_free_range\n");
-        /* Number of header blocks */
-        hdrb = max(1, dev->align);
-
-        link = list_first(&dev->log_ba);
-        nba = fdisk_ba_align_up(dev, dev->ext_part->block0);
-        while (link != NULL) {
-                part = list_get_instance(link, fdisk_part_t, llog_ba);
-                pb0 = fdisk_ba_align_down(dev, part->block0);
-                if (pb0 >= nba && pb0 - nba >= nblocks)
-                        break;
-                nba = fdisk_ba_align_up(dev, part->block0 + part->nblocks);
-                link = list_next(link, &dev->log_ba);
-        }
-
-        if (link != NULL) {
-                /* Free range before a partition */
-                avail = pb0 - nba;
-        } else {
-                /* Free range at the end */
-                pb0 = fdisk_ba_align_down(dev, dev->ext_part->block0 +
-                    dev->ext_part->nblocks);
-                if (pb0 < nba) {
-                        printf("not enough space\n");
-                        return ELIMIT;
+        fdisk_free_range_t fr;
+        uint64_t b0;
+        uint64_t nb;
+        uint64_t best_b0;
+        uint64_t best_nb;
+
+        best_b0 = best_nb = 0;
+        fdisk_free_range_first(dev, spc, &fr);
+        do {
+                if (fdisk_free_range_get(&fr, &b0, &nb)) {
+                        if (nb > best_nb) {
+                                best_b0 = b0;
+                                best_nb = nb;
+                        }
                 }
-
-                avail = pb0 - nba;
-
-                printf("nba=%" PRIu64 " pb0=%" PRIu64" avail=%" PRIu64 "\n",
-                    nba, pb0, avail);
-        }
-        /* Verify that the range is large enough */
-        if (avail < hdrb + nblocks) {
-                printf("not enough space\n");
-                return ELIMIT;
-        }
-
-        *rhdrb = hdrb;
-        *rblock0 = nba + hdrb;
-        *rnblocks = avail;
-        printf("hdrb=%" PRIu64 " block0=%" PRIu64" avail=%" PRIu64 "\n",
-            hdrb, nba + hdrb, avail);
+        } while (fdisk_free_range_next(&fr));
+
+        if (best_nb == 0)
+                return ENOSPC;
+
+        *rblock0 = best_b0;
+        *rnblocks = best_nb;
         return EOK;
 }
@@ -1082 +1080 @@
         uint64_t cbytes;
         aoff64_t req_blocks;
-        aoff64_t fhdr;
         aoff64_t fblock0;
         aoff64_t fnblocks;
+        aoff64_t hdrb;
         uint64_t block_size;
         label_pcnt_t pcnt;
@@ -1136 +1134 @@
 
                 printf("fdisk_part_spec_prepare() - get free range\n");
-                rc = fdisk_part_get_free_range(dev, req_blocks, &fblock0, &fnblocks);
+                rc = fdisk_part_get_free_range(dev, req_blocks, spc_pri,
+                    &fblock0, &fnblocks);
                 if (rc != EOK)
                         return EIO;
@@ -1149 +1148 @@
         case lpk_logical:
                 printf("fdisk_part_spec_prepare() - log\n");
-                rc = fdisk_part_get_log_free_range(dev, req_blocks, &fhdr,
+                hdrb = max(1, dev->align);
+                rc = fdisk_part_get_free_range(dev, hdrb + req_blocks, spc_log,
                     &fblock0, &fnblocks);
                 if (rc != EOK)
@@ -1155 +1155 @@
 
                 memset(vpspec, 0, sizeof(vbd_part_spec_t));
-                vpspec->hdr_blocks = fhdr;
-                vpspec->block0 = fblock0;
+                vpspec->hdr_blocks = hdrb;
+                vpspec->block0 = fblock0 + hdrb;
                 vpspec->nblocks = req_blocks;
                 vpspec->pkind = lpk_logical;
-                vpspec->ptype.fmt = lptf_num;
-                vpspec->ptype.t.num = 42;
                 break;
         }
@@ -1209 +1207 @@
 }
 
+static void fdisk_free_range_first(fdisk_dev_t *dev, fdisk_spc_t spc,
+    fdisk_free_range_t *fr)
+{
+        link_t *link;
+
+        fr->dev = dev;
+        fr->spc = spc;
+
+        if (fr->spc == spc_pri) {
+                /* Primary partitions */
+                fr->b0 = fdisk_ba_align_up(fr->dev, fr->dev->dinfo.ablock0);
+
+                link = list_first(&dev->pri_ba);
+                if (link != NULL)
+                        fr->npart = list_get_instance(link, fdisk_part_t, lpri_ba);
+                else
+                        fr->npart = NULL;
+        } else { /* fr->spc == spc_log */
+                /* Logical partitions */
+                fr->b0 = fdisk_ba_align_up(fr->dev, fr->dev->ext_part->block0);
+
+                link = list_first(&dev->log_ba);
+                if (link != NULL)
+                        fr->npart = list_get_instance(link, fdisk_part_t, llog_ba);
+                else
+                        fr->npart = NULL;
+        }
+}
+
+static bool fdisk_free_range_next(fdisk_free_range_t *fr)
+{
+        link_t *link;
+
+        if (fr->npart == NULL)
+                return false;
+
+        fr->b0 = fdisk_ba_align_up(fr->dev, fr->npart->block0 +
+            fr->npart->nblocks);
+
+        if (fr->spc == spc_pri) {
+                /* Primary partitions */
+                link = list_next(&fr->npart->lpri_ba, &fr->dev->pri_ba);
+                if (link != NULL)
+                        fr->npart = list_get_instance(link, fdisk_part_t, lpri_ba);
+                else
+                        fr->npart = NULL;
+        } else { /* fr->spc == spc_log */
+                /* Logical partitions */
+                link = list_next(&fr->npart->llog_ba, &fr->dev->log_ba);
+                if (link != NULL)
+                        fr->npart = list_get_instance(link, fdisk_part_t, llog_ba);
+                else
+                        fr->npart = NULL;
+        }
+
+        return true;
+}
+
+static bool fdisk_free_range_get(fdisk_free_range_t *fr,
+    aoff64_t *b0, aoff64_t *nb)
+{
+        aoff64_t b1;
+
+        if (fr->npart != NULL) {
+                b1 = fdisk_ba_align_down(fr->dev, fr->npart->block0);
+        } else {
+                if (fr->spc == spc_pri) {
+                        b1 = fdisk_ba_align_down(fr->dev,
+                            fr->dev->dinfo.ablock0 + fr->dev->dinfo.anblocks);
+                } else { /* fr->spc == spc_log */
+                        b1 = fdisk_ba_align_down(fr->dev,
+                            fr->dev->ext_part->block0 + fr->dev->ext_part->nblocks);
+                }
+        }
+
+        if (b1 < fr->b0)
+                return false;
+
+        *b0 = fr->b0;
+        *nb = b1 - fr->b0;
+
+        return true;
+}
+
 /** @}
  */