Changeset 03661d19 in mainline

Timestamp:

2015-10-29T10:16:08Z (9 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

55f8c6e7

Parents:

9854a8f

Message:

Handle simplified capacity entry.

Location:

uspace

Files:

• app/fdisk/fdisk.c (modified) (1 diff)
• lib/fdisk/include/fdisk.h (modified) (1 diff)
• lib/fdisk/include/types/fdisk.h (modified) (1 diff)
• lib/fdisk/src/cap.c (modified) (4 diffs)
• lib/fdisk/src/fdisk.c (modified) (4 diffs)
• lib/label/src/mbr.c (modified) (5 diffs)

uspace/app/fdisk/fdisk.c

@@ -429 +429 @@
         }
 
+        fdisk_cap_simplify(&mcap);
+
         rc = fdisk_cap_format(&mcap, &smcap);
         if (rc != EOK) {

uspace/lib/fdisk/include/fdisk.h

@@ -75 +75 @@
 extern void fdisk_cap_simplify(fdisk_cap_t *);
 extern void fdisk_cap_from_blocks(uint64_t, size_t, fdisk_cap_t *);
-extern int fdisk_cap_to_blocks(fdisk_cap_t *, size_t, uint64_t *);
+extern int fdisk_cap_to_blocks(fdisk_cap_t *, fdisk_cvsel_t, size_t, uint64_t *);
 
 extern int fdisk_ltype_format(label_type_t, char **);

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

@@ -57 +57 @@
         cu_ybyte
 } fdisk_cunit_t;
+
+/** Which of values within the precision of the capacity */
+typedef enum {
+        /** The nominal (middling) value */
+        fcv_nom,
+        /** The minimum value */
+        fcv_min,
+        /** The maximum value */
+        fcv_max
+} fdisk_cvsel_t;
 
 typedef enum {

uspace/lib/fdisk/src/cap.c

@@ -76 +76 @@
  * of bytes is not divisible by the number of blocks, it is rounded
  * up to an integer number of blocks.
- */
-int fdisk_cap_to_blocks(fdisk_cap_t *cap, size_t block_size,
-    uint64_t *blocks)
+ *
+ * A capacity value entails precision, i.e. it corresponds to a range
+ * of values. @a cvsel selects the value to return. @c fcv_nom gives
+ * the nominal (middle) value, @c fcv_min gives the minimum value
+ * and @c fcv_max gives the maximum value.
+ */
+int fdisk_cap_to_blocks(fdisk_cap_t *cap, fdisk_cvsel_t cvsel,
+    size_t block_size, uint64_t *rblocks)
 {
         int exp;
         uint64_t bytes;
         uint64_t f;
+        uint64_t adj;
+        uint64_t blocks;
+        uint64_t rem;
         int rc;
 
-        // XXX Check for overflow
+        printf("fdisk_cap_to_blocks: m=%" PRIu64 ", dp=%d, cunit=%d\n",
+            cap->m, cap->dp, cap->cunit);
 
         exp = cap->cunit * 3 - cap->dp;
@@ -93 +102 @@
                         return ERANGE;
                 bytes = (cap->m + (f / 2)) / f;
+                if (bytes * f - (f / 2) != cap->m)
+                        return ERANGE;
         } else {
                 rc = ipow10_u64(exp, &f);
                 if (rc != EOK)
                         return ERANGE;
-                bytes = cap->m * f;
-        }
-
-        *blocks = (bytes + block_size - 1) / block_size;
+
+                adj = 0;
+                switch (cvsel) {
+                case fcv_nom:
+                        adj = 0;
+                        break;
+                case fcv_min:
+                        adj = -(f / 2);
+                        break;
+                case fcv_max:
+                        adj = f / 2 - 1;
+                        break;
+                }
+
+                printf("f=%" PRIu64 ", adj=%" PRId64 "\n", f, adj);
+                bytes = cap->m * f + adj;
+                printf("bytes=%" PRIu64 "\n", bytes);
+                if ((bytes - adj) / f != cap->m)
+                        return ERANGE;
+        }
+
+        rem = bytes % block_size;
+        if ((bytes + rem) < bytes)
+                return ERANGE;
+
+        blocks = (bytes + rem) / block_size;
+        printf("blocks=%" PRIu64 "\n", blocks);
+
+        *rblocks = blocks;
         return EOK;
 }
@@ -185 +221 @@
 }
 
+static int fdisk_digit_val(char c, int *val)
+{
+        switch (c) {
+        case '0': *val = 0; break;
+        case '1': *val = 1; break;
+        case '2': *val = 2; break;
+        case '3': *val = 3; break;
+        case '4': *val = 4; break;
+        case '5': *val = 5; break;
+        case '6': *val = 6; break;
+        case '7': *val = 7; break;
+        case '8': *val = 8; break;
+        case '9': *val = 9; break;
+        default:
+                return EINVAL;
+        }
+
+        return EOK;
+}
+
 int fdisk_cap_parse(const char *str, fdisk_cap_t *cap)
 {
-        char *eptr;
-        char *p;
-        unsigned long val;
+        const char *eptr;
+        const char *p;
+        int d;
+        int dp;
+        unsigned long m;
         int i;
 
-        val = strtoul(str, &eptr, 10);
+        m = 0;
+
+        eptr = str;
+        while (fdisk_digit_val(*eptr, &d) == EOK) {
+                m = m * 10 + d;
+                ++eptr;
+        }
+
+        if (*eptr == '.') {
+                ++eptr;
+                dp = 0;
+                while (fdisk_digit_val(*eptr, &d) == EOK) {
+                        m = m * 10 + d;
+                        ++dp;
+                        ++eptr;
+                }
+        } else {
+                m = 0; dp = 0;
+        }
 
         while (*eptr == ' ')
@@ -216 +292 @@
         }
 
-        cap->m = val;
-        cap->dp = 0;
+        cap->m = m;
+        cap->dp = dp;
         return EOK;
 }

uspace/lib/fdisk/src/fdisk.c

@@ -1037 +1037 @@
     vbd_part_spec_t *vpspec)
 {
-        aoff64_t req_blocks;
+        aoff64_t nom_blocks;
+        aoff64_t min_blocks;
+        aoff64_t max_blocks;
+        aoff64_t act_blocks;
         aoff64_t fblock0;
         aoff64_t fnblocks;
         aoff64_t hdrb;
         label_pcnt_t pcnt;
+        fdisk_spc_t spc;
         int index;
         int rc;
@@ -1047 +1051 @@
         printf("fdisk_part_spec_prepare() - dev=%p pspec=%p vpspec=%p\n", dev, pspec,
             vpspec);
-        fdisk_cap_to_blocks(&pspec->capacity, dev->dinfo.block_size, &req_blocks);
-
-        req_blocks = fdisk_ba_align_up(dev, req_blocks);
+        rc = fdisk_cap_to_blocks(&pspec->capacity, fcv_nom, dev->dinfo.block_size,
+            &nom_blocks);
+        if (rc != EOK)
+                return rc;
+
+        rc = fdisk_cap_to_blocks(&pspec->capacity, fcv_min, dev->dinfo.block_size,
+            &min_blocks);
+        if (rc != EOK)
+                return rc;
+
+        rc = fdisk_cap_to_blocks(&pspec->capacity, fcv_max, dev->dinfo.block_size,
+            &max_blocks);
+        if (rc != EOK)
+                return rc;
+
+        nom_blocks = fdisk_ba_align_up(dev, nom_blocks);
+        min_blocks = fdisk_ba_align_up(dev, min_blocks);
+        max_blocks = fdisk_ba_align_up(dev, max_blocks);
+
+        printf("fdisk_part_spec_prepare: nom=%" PRIu64 ", min=%" PRIu64
+            ", max=%" PRIu64, nom_blocks, min_blocks, max_blocks);
 
         pcnt = -1;
@@ -1071 +1093 @@
                 return EINVAL;
 
-        printf("fdisk_part_spec_prepare() - switch\n");
-        switch (pspec->pkind) {
-        case lpk_primary:
-        case lpk_extended:
-                printf("fdisk_part_spec_prepare() - pri/ext\n");
+        if (pspec->pkind == lpk_logical) {
+                hdrb = max(1, dev->align);
+                spc = spc_log;
+        } else {
+                hdrb = 0;
+                spc = spc_pri;
+        }
+
+        rc = fdisk_part_get_free_range(dev, hdrb + nom_blocks, spc,
+            &fblock0, &fnblocks);
+
+        if (rc == EOK) {
+                /*
+                 * If the size of the free range would still give the same capacity
+                 * when rounded, allocate entire range. Otherwise allocate exactly
+                 * what we were asked for.
+                 */
+                if (fnblocks <= max_blocks) {
+                        act_blocks = fnblocks;
+                } else {
+                        act_blocks = hdrb + nom_blocks;
+                }
+        } else {
+                assert(rc == ENOSPC);
+
+                /*
+                 * There is no free range that can contain exactly the requested
+                 * capacity. Try to allocate at least such number of blocks
+                 * that would still fullfill the request within the limits
+                 * of the precision with witch the capacity was specified
+                 * (i.e. when rounded up).
+                 */
+                rc = fdisk_part_get_free_range(dev, hdrb + min_blocks, spc,
+                    &fblock0, &fnblocks);
+                if (rc != EOK)
+                        return rc;
+
+                assert(fnblocks < hdrb + nom_blocks);
+                act_blocks = fnblocks;
+        }
+
+        if (pspec->pkind != lpk_logical) {
                 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, spc_pri,
-                    &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;
-                break;
-        case lpk_logical:
-                printf("fdisk_part_spec_prepare() - log\n");
-                hdrb = max(1, dev->align);
-                rc = fdisk_part_get_free_range(dev, hdrb + req_blocks, spc_log,
-                    &fblock0, &fnblocks);
-                if (rc != EOK)
-                        return EIO;
-
-                memset(vpspec, 0, sizeof(vbd_part_spec_t));
-                vpspec->hdr_blocks = hdrb;
-                vpspec->block0 = fblock0 + hdrb;
-                vpspec->nblocks = req_blocks;
-                vpspec->pkind = lpk_logical;
-                break;
-        }
+        } else {
+                index = 0;
+        }
+
+        memset(vpspec, 0, sizeof(vbd_part_spec_t));
+        vpspec->index = index;
+        vpspec->hdr_blocks = hdrb;
+        vpspec->block0 = fblock0 + hdrb;
+        vpspec->nblocks = act_blocks;
+        vpspec->pkind = pspec->pkind;
 
         if (pspec->pkind != lpk_extended) {
@@ -1115 +1155 @@
                         return EIO;
         }
+
+        printf("fdisk_part_spec_prepare: hdrb=%" PRIu64 ", b0=%" PRIu64
+            ", nblocks=%" PRIu64 ", pkind=%d\n", vpspec->hdr_blocks,
+            vpspec->block0, vpspec->nblocks, vpspec->pkind);
 
         return EOK;

uspace/lib/label/src/mbr.c

@@ -512 +512 @@
         int rc;
 
+        log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_part_create");
         if (pspec->ptype.fmt != lptf_num)
                 return EINVAL;
@@ -521 +522 @@
 
         /* XXX Check if index is used */
-
         part->label = label;
         part->index = pspec->index;
@@ -545 +545 @@
                 break;
         case lpk_logical:
-                log_msg(LOG_DEFAULT, LVL_NOTE, "check index");
                 part->ptype = pspec->ptype;
                 if (pspec->index != 0) {
@@ -587 +586 @@
         } else {
                 /* Logical partition */
-
-                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);
@@ -601 +597 @@
                 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);