Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset c24b0dcb in mainline


Ignore:
Timestamp:
2019-09-30T16:38:33Z (13 months ago)
Author:
Jakub Jermar <jakub@…>
Branches:
master
Children:
8f57fb2
Parents:
ef0a3375
git-author:
Jakub Jermar <jakub@…> (2019-09-30 16:34:10)
git-committer:
Jakub Jermar <jakub@…> (2019-09-30 16:38:33)
Message:

Rename capacity-related 'cap' to 'capa'

This allows to use 'cap' for capabilities.

Location:
uspace
Files:
9 edited
3 moved

Legend:

Unmodified
Added
Removed
  • uspace/app/bdsh/cmds/modules/ls/ls.c

    ref0a3375 rc24b0dcb  
    4242#include <vfs/vfs.h>
    4343#include <str.h>
    44 #include <cap.h>
     44#include <capa.h>
    4545
    4646#include "ls.h"
     
    106106                }
    107107
    108                 cap_spec_t cap;
    109                 cap_from_blocks(de->s.size, 1, &cap);
    110                 cap_simplify(&cap);
     108                capa_spec_t capa;
     109                capa_from_blocks(de->s.size, 1, &capa);
     110                capa_simplify(&capa);
    111111
    112112                char *rptr;
    113                 errno_t rc = cap_format(&cap, &rptr);
     113                errno_t rc = capa_format(&capa, &rptr);
    114114                if (rc != EOK) {
    115115                        return rc;
  • uspace/app/df/df.c

    ref0a3375 rc24b0dcb  
    3535 */
    3636
    37 #include <cap.h>
     37#include <capa.h>
    3838#include <stdbool.h>
    3939#include <stdio.h>
     
    124124static errno_t size_to_human_readable(uint64_t nblocks, size_t block_size, char **rptr)
    125125{
    126         cap_spec_t cap;
    127 
    128         cap_from_blocks(nblocks, block_size, &cap);
    129         cap_simplify(&cap);
    130         return cap_format(&cap, rptr);
     126        capa_spec_t capa;
     127
     128        capa_from_blocks(nblocks, block_size, &capa);
     129        capa_simplify(&capa);
     130        return capa_format(&capa, rptr);
    131131}
    132132
  • uspace/app/fdisk/fdisk.c

    ref0a3375 rc24b0dcb  
    3434 */
    3535
    36 #include <cap.h>
     36#include <capa.h>
    3737#include <errno.h>
    3838#include <fdisk.h>
     
    136136        nchoice_t *choice = NULL;
    137137        char *svcname = NULL;
    138         cap_spec_t cap;
     138        capa_spec_t capa;
    139139        fdisk_dev_info_t *sdev;
    140         char *scap = NULL;
     140        char *scapa = NULL;
    141141        char *dtext = NULL;
    142142        service_id_t svcid;
     
    177177                }
    178178
    179                 rc = fdisk_dev_info_capacity(info, &cap);
     179                rc = fdisk_dev_info_capacity(info, &capa);
    180180                if (rc != EOK) {
    181181                        printf("Error getting device capacity "
     
    185185                }
    186186
    187                 cap_simplify(&cap);
    188 
    189                 rc = cap_format(&cap, &scap);
     187                capa_simplify(&capa);
     188
     189                rc = capa_format(&capa, &scapa);
    190190                if (rc != EOK) {
    191191                        assert(rc == ENOMEM);
     
    194194                }
    195195
    196                 int ret = asprintf(&dtext, "%s (%s)", svcname, scap);
     196                int ret = asprintf(&dtext, "%s (%s)", svcname, scapa);
    197197                if (ret < 0) {
    198198                        rc = ENOMEM;
     
    203203                free(svcname);
    204204                svcname = NULL;
    205                 free(scap);
    206                 scap = NULL;
     205                free(scapa);
     206                scapa = NULL;
    207207
    208208                rc = nchoice_add(choice, dtext, info, 0);
     
    261261        free(dtext);
    262262        free(svcname);
    263         free(scap);
     263        free(scapa);
    264264        return rc;
    265265}
     
    432432        errno_t rc;
    433433        fdisk_part_spec_t pspec;
    434         cap_spec_t cap;
    435         cap_spec_t mcap;
     434        capa_spec_t capa;
     435        capa_spec_t mcapa;
    436436        vol_label_supp_t vlsupp;
    437437        vol_fstype_t fstype = 0;
    438438        tinput_t *tinput = NULL;
    439439        fdisk_spc_t spc;
    440         char *scap;
    441         char *smcap = NULL;
     440        char *scapa;
     441        char *smcapa = NULL;
    442442        char *label = NULL;
    443443        char *mountp = NULL;
     
    448448                spc = spc_pri;
    449449
    450         rc = fdisk_part_get_max_avail(dev, spc, &mcap);
     450        rc = fdisk_part_get_max_avail(dev, spc, &mcapa);
    451451        if (rc != EOK) {
    452452                rc = EIO;
     
    454454        }
    455455
    456         cap_simplify(&mcap);
    457 
    458         rc = cap_format(&mcap, &smcap);
     456        capa_simplify(&mcapa);
     457
     458        rc = capa_format(&mcapa, &smcapa);
    459459        if (rc != EOK) {
    460460                rc = ENOMEM;
     
    474474        while (true) {
    475475                printf("Enter capacity of new partition.\n");
    476                 rc = tinput_read_i(tinput, smcap, &scap);
     476                rc = tinput_read_i(tinput, smcapa, &scapa);
    477477                if (rc != EOK)
    478478                        goto error;
    479479
    480                 rc = cap_parse(scap, &cap);
     480                rc = capa_parse(scapa, &capa);
    481481                if (rc == EOK)
    482482                        break;
     
    485485        tinput_destroy(tinput);
    486486        tinput = NULL;
    487         free(smcap);
    488         smcap = NULL;
     487        free(smcapa);
     488        smcapa = NULL;
    489489
    490490        if (pkind != lpk_extended) {
     
    545545
    546546        fdisk_pspec_init(&pspec);
    547         pspec.capacity = cap;
     547        pspec.capacity = capa;
    548548        pspec.pkind = pkind;
    549549        pspec.fstype = fstype;
     
    561561        return EOK;
    562562error:
    563         free(smcap);
     563        free(smcapa);
    564564        free(label);
    565565        free(mountp);
     
    581581        fdisk_part_t *part;
    582582        fdisk_part_info_t pinfo;
    583         char *scap = NULL;
     583        char *scapa = NULL;
    584584        char *spkind = NULL;
    585585        char *sfstype = NULL;
     
    596596                }
    597597
    598                 cap_simplify(&pinfo.capacity);
    599 
    600                 rc = cap_format(&pinfo.capacity, &scap);
     598                capa_simplify(&pinfo.capacity);
     599
     600                rc = capa_format(&pinfo.capacity, &scapa);
    601601                if (rc != EOK) {
    602602                        printf("Out of memory.\n");
     
    623623
    624624                        int ret = asprintf(&sdesc, "%s %s, %s, %s", label,
    625                             scap, spkind, sfstype);
     625                            scapa, spkind, sfstype);
    626626                        if (ret < 0) {
    627627                                rc = ENOMEM;
     
    630630
    631631                } else {
    632                         int ret = asprintf(&sdesc, "%s, %s", scap, spkind);
     632                        int ret = asprintf(&sdesc, "%s, %s", scapa, spkind);
    633633                        if (ret < 0) {
    634634                                rc = ENOMEM;
     
    644644                }
    645645
    646                 free(scap);
    647                 scap = NULL;
     646                free(scapa);
     647                scapa = NULL;
    648648                free(spkind);
    649649                spkind = NULL;
     
    658658        return EOK;
    659659error:
    660         free(scap);
     660        free(scapa);
    661661        free(spkind);
    662662        free(sfstype);
     
    907907        fdisk_part_t *part;
    908908        fdisk_part_info_t pinfo;
    909         cap_spec_t cap;
    910         cap_spec_t mcap;
     909        capa_spec_t capa;
     910        capa_spec_t mcapa;
    911911        fdisk_dev_flags_t dflags;
    912912        char *sltype = NULL;
    913         char *sdcap = NULL;
    914         char *scap = NULL;
    915         char *smcap = NULL;
     913        char *sdcapa = NULL;
     914        char *scapa = NULL;
     915        char *smcapa = NULL;
    916916        char *sfstype = NULL;
    917917        char *svcname = NULL;
     
    936936        }
    937937
    938         rc = fdisk_dev_capacity(dev, &cap);
     938        rc = fdisk_dev_capacity(dev, &capa);
    939939        if (rc != EOK) {
    940940                printf("Error getting device capacity.\n");
     
    942942        }
    943943
    944         cap_simplify(&cap);
    945 
    946         rc = cap_format(&cap, &sdcap);
     944        capa_simplify(&capa);
     945
     946        rc = capa_format(&capa, &sdcapa);
    947947        if (rc != EOK) {
    948948                printf("Out of memory.\n");
     
    958958        fdisk_dev_get_flags(dev, &dflags);
    959959
    960         printf("Device: %s (%s)\n", svcname, sdcap);
    961         free(sdcap);
    962         sdcap = NULL;
     960        printf("Device: %s (%s)\n", svcname, sdcapa);
     961        free(sdcapa);
     962        sdcapa = NULL;
    963963
    964964        rc = fdisk_label_get_info(dev, &linfo);
     
    996996                }
    997997
    998                 cap_simplify(&pinfo.capacity);
    999 
    1000                 rc = cap_format(&pinfo.capacity, &scap);
     998                capa_simplify(&pinfo.capacity);
     999
     1000                rc = capa_format(&pinfo.capacity, &scapa);
    10011001                if (rc != EOK) {
    10021002                        printf("Out of memory.\n");
     
    10161016
    10171017                if (linfo.ltype == lt_none)
    1018                         printf("Entire disk: %s %s", label, scap);
     1018                        printf("Entire disk: %s %s", label, scapa);
    10191019                else
    1020                         printf("Partition %d: %s %s", npart, label, scap);
     1020                        printf("Partition %d: %s %s", npart, label, scapa);
    10211021
    10221022                if ((linfo.flags & lf_ext_supp) != 0) {
     
    10371037                printf("\n");
    10381038
    1039                 free(scap);
    1040                 scap = NULL;
     1039                free(scapa);
     1040                scapa = NULL;
    10411041                free(sfstype);
    10421042                sfstype = NULL;
     
    10471047        /* Display available space */
    10481048        if ((linfo.flags & lf_can_create_pri) != 0) {
    1049                 rc = fdisk_part_get_max_avail(dev, spc_pri, &mcap);
     1049                rc = fdisk_part_get_max_avail(dev, spc_pri, &mcapa);
    10501050                if (rc != EOK) {
    10511051                        rc = EIO;
     
    10531053                }
    10541054
    1055                 cap_simplify(&mcap);
    1056 
    1057                 rc = cap_format(&mcap, &smcap);
     1055                capa_simplify(&mcapa);
     1056
     1057                rc = capa_format(&mcapa, &smcapa);
    10581058                if (rc != EOK) {
    10591059                        rc = ENOMEM;
     
    10621062
    10631063                if ((linfo.flags & lf_ext_supp) != 0)
    1064                         printf("Maximum free primary block: %s\n", smcap);
     1064                        printf("Maximum free primary block: %s\n", smcapa);
    10651065                else
    1066                         printf("Maximum free block: %s\n", smcap);
    1067 
    1068                 free(smcap);
    1069                 smcap = NULL;
    1070 
    1071                 rc = fdisk_part_get_tot_avail(dev, spc_pri, &mcap);
     1066                        printf("Maximum free block: %s\n", smcapa);
     1067
     1068                free(smcapa);
     1069                smcapa = NULL;
     1070
     1071                rc = fdisk_part_get_tot_avail(dev, spc_pri, &mcapa);
    10721072                if (rc != EOK) {
    10731073                        rc = EIO;
     
    10751075                }
    10761076
    1077                 cap_simplify(&mcap);
    1078 
    1079                 rc = cap_format(&mcap, &smcap);
     1077                capa_simplify(&mcapa);
     1078
     1079                rc = capa_format(&mcapa, &smcapa);
    10801080                if (rc != EOK) {
    10811081                        rc = ENOMEM;
     
    10841084
    10851085                if ((linfo.flags & lf_ext_supp) != 0)
    1086                         printf("Total free primary space: %s\n", smcap);
     1086                        printf("Total free primary space: %s\n", smcapa);
    10871087                else
    1088                         printf("Total free space: %s\n", smcap);
    1089 
    1090                 free(smcap);
    1091                 smcap = NULL;
     1088                        printf("Total free space: %s\n", smcapa);
     1089
     1090                free(smcapa);
     1091                smcapa = NULL;
    10921092        }
    10931093
    10941094        /* Display available space */
    10951095        if ((linfo.flags & lf_can_create_log) != 0) {
    1096                 rc = fdisk_part_get_max_avail(dev, spc_log, &mcap);
     1096                rc = fdisk_part_get_max_avail(dev, spc_log, &mcapa);
    10971097                if (rc != EOK) {
    10981098                        rc = EIO;
     
    11001100                }
    11011101
    1102                 cap_simplify(&mcap);
    1103 
    1104                 rc = cap_format(&mcap, &smcap);
     1102                capa_simplify(&mcapa);
     1103
     1104                rc = capa_format(&mcapa, &smcapa);
    11051105                if (rc != EOK) {
    11061106                        rc = ENOMEM;
     
    11081108                }
    11091109
    1110                 printf("Maximum free logical block: %s\n", smcap);
    1111                 free(smcap);
    1112                 smcap = NULL;
    1113 
    1114                 rc = fdisk_part_get_tot_avail(dev, spc_log, &mcap);
     1110                printf("Maximum free logical block: %s\n", smcapa);
     1111                free(smcapa);
     1112                smcapa = NULL;
     1113
     1114                rc = fdisk_part_get_tot_avail(dev, spc_log, &mcapa);
    11151115                if (rc != EOK) {
    11161116                        rc = EIO;
     
    11181118                }
    11191119
    1120                 cap_simplify(&mcap);
    1121 
    1122                 rc = cap_format(&mcap, &smcap);
     1120                capa_simplify(&mcapa);
     1121
     1122                rc = capa_format(&mcapa, &smcapa);
    11231123                if (rc != EOK) {
    11241124                        rc = ENOMEM;
     
    11261126                }
    11271127
    1128                 printf("Total free logical space: %s\n", smcap);
    1129                 free(smcap);
    1130                 smcap = NULL;
     1128                printf("Total free logical space: %s\n", smcapa);
     1129                free(smcapa);
     1130                smcapa = NULL;
    11311131        }
    11321132
     
    12791279        return EOK;
    12801280error:
    1281         free(sdcap);
    1282         free(scap);
    1283         free(smcap);
     1281        free(sdcapa);
     1282        free(scapa);
     1283        free(smcapa);
    12841284        free(sfstype);
    12851285        free(svcname);
  • uspace/app/sysinst/sysinst.c

    ref0a3375 rc24b0dcb  
    3838#include <block.h>
    3939#include <byteorder.h>
    40 #include <cap.h>
     40#include <capa.h>
    4141#include <errno.h>
    4242#include <fdisk.h>
     
    9898        fdisk_part_spec_t pspec;
    9999        fdisk_part_info_t pinfo;
    100         cap_spec_t cap;
     100        capa_spec_t capa;
    101101        service_id_t sid;
    102102        errno_t rc;
     
    137137        printf("sysinst_label_dev(): create partition\n");
    138138
    139         rc = fdisk_part_get_max_avail(fdev, spc_pri, &cap);
     139        rc = fdisk_part_get_max_avail(fdev, spc_pri, &capa);
    140140        if (rc != EOK) {
    141141                printf("Error getting available capacity: %s.\n", str_error(rc));
     
    144144
    145145        fdisk_pspec_init(&pspec);
    146         pspec.capacity = cap;
     146        pspec.capacity = capa;
    147147        pspec.pkind = lpk_primary;
    148148        pspec.fstype = fs_ext4; /* Cannot be changed without modifying core.img */
  • uspace/lib/c/generic/capa.c

    ref0a3375 rc24b0dcb  
    3434 */
    3535
    36 #include <cap.h>
     36#include <capa.h>
    3737#include <errno.h>
    3838#include <imath.h>
     
    4343enum {
    4444        /** Simplified capacity maximum integer digits */
    45         scap_max_idig = 3,
     45        scapa_max_idig = 3,
    4646        /** Simplified capacity maximum significant digits */
    47         scap_max_sdig = 4
     47        scapa_max_sdig = 4
    4848};
    4949
     
    6060};
    6161
    62 void cap_from_blocks(uint64_t nblocks, size_t block_size, cap_spec_t *cap)
     62void capa_from_blocks(uint64_t nblocks, size_t block_size, capa_spec_t *capa)
    6363{
    6464        uint64_t tsize;
    6565
    6666        tsize = nblocks * block_size;
    67         cap->m = tsize;
    68         cap->dp = 0;
    69         cap->cunit = cu_byte;
     67        capa->m = tsize;
     68        capa->dp = 0;
     69        capa->cunit = cu_byte;
    7070}
    7171
     
    8181 * and @c cv_max gives the maximum value.
    8282 */
    83 errno_t cap_to_blocks(cap_spec_t *cap, cap_vsel_t cvsel, size_t block_size,
     83errno_t capa_to_blocks(capa_spec_t *capa, capa_vsel_t cvsel, size_t block_size,
    8484    uint64_t *rblocks)
    8585{
     
    9292        errno_t rc;
    9393
    94         exp = cap->cunit * 3 - cap->dp;
     94        exp = capa->cunit * 3 - capa->dp;
    9595        if (exp < 0) {
    9696                rc = ipow10_u64(-exp, &f);
    9797                if (rc != EOK)
    9898                        return ERANGE;
    99                 bytes = (cap->m + (f / 2)) / f;
    100                 if (bytes * f - (f / 2) != cap->m)
     99                bytes = (capa->m + (f / 2)) / f;
     100                if (bytes * f - (f / 2) != capa->m)
    101101                        return ERANGE;
    102102        } else {
     
    118118                }
    119119
    120                 bytes = cap->m * f + adj;
    121                 if ((bytes - adj) / f != cap->m)
     120                bytes = capa->m * f + adj;
     121                if ((bytes - adj) / f != capa->m)
    122122                        return ERANGE;
    123123        }
     
    138138 * digits and at most two fractional digits, e.g abc.xy <unit>.
    139139 */
    140 void cap_simplify(cap_spec_t *cap)
     140void capa_simplify(capa_spec_t *capa)
    141141{
    142142        uint64_t div;
     
    146146        errno_t rc;
    147147
    148         /* Change units so that we have at most @c scap_max_idig integer digits */
    149         rc = ipow10_u64(scap_max_idig, &maxv);
     148        /* Change units so that we have at most @c scapa_max_idig integer digits */
     149        rc = ipow10_u64(scapa_max_idig, &maxv);
    150150        assert(rc == EOK);
    151151
    152         rc = ipow10_u64(cap->dp, &div);
     152        rc = ipow10_u64(capa->dp, &div);
    153153        assert(rc == EOK);
    154154
    155         while (cap->m / div >= maxv) {
    156                 ++cap->cunit;
    157                 cap->dp += 3;
     155        while (capa->m / div >= maxv) {
     156                ++capa->cunit;
     157                capa->dp += 3;
    158158                div = div * 1000;
    159159        }
    160160
    161         /* Round the number so that we have at most @c scap_max_sdig significant digits */
    162         sdig = 1 + ilog10_u64(cap->m); /* number of significant digits */
    163         if (sdig > scap_max_sdig) {
     161        /* Round the number so that we have at most @c scapa_max_sdig significant digits */
     162        sdig = 1 + ilog10_u64(capa->m); /* number of significant digits */
     163        if (sdig > scapa_max_sdig) {
    164164                /* Number of digits to remove */
    165                 rdig = sdig - scap_max_sdig;
    166                 if (rdig > cap->dp)
    167                         rdig = cap->dp;
     165                rdig = sdig - scapa_max_sdig;
     166                if (rdig > capa->dp)
     167                        rdig = capa->dp;
    168168
    169169                rc = ipow10_u64(rdig, &div);
    170170                assert(rc == EOK);
    171171
    172                 cap->m = (cap->m + (div / 2)) / div;
    173                 cap->dp -= rdig;
    174         }
    175 }
    176 
    177 errno_t cap_format(cap_spec_t *cap, char **rstr)
     172                capa->m = (capa->m + (div / 2)) / div;
     173                capa->dp -= rdig;
     174        }
     175}
     176
     177errno_t capa_format(capa_spec_t *capa, char **rstr)
    178178{
    179179        errno_t rc;
     
    186186        sunit = NULL;
    187187
    188         assert(cap->cunit < CU_LIMIT);
    189 
    190         rc = ipow10_u64(cap->dp, &div);
     188        assert(capa->cunit < CU_LIMIT);
     189
     190        rc = ipow10_u64(capa->dp, &div);
    191191        if (rc != EOK)
    192192                return rc;
    193193
    194         ipart = cap->m / div;
    195         fpart = cap->m % div;
    196 
    197         sunit = cu_str[cap->cunit];
    198         if (cap->dp > 0) {
     194        ipart = capa->m / div;
     195        fpart = capa->m % div;
     196
     197        sunit = cu_str[capa->cunit];
     198        if (capa->dp > 0) {
    199199                ret = asprintf(rstr, "%" PRIu64 ".%0*" PRIu64 " %s", ipart,
    200                     (int)cap->dp, fpart, sunit);
     200                    (int)capa->dp, fpart, sunit);
    201201        } else {
    202202                ret = asprintf(rstr, "%" PRIu64 " %s", ipart, sunit);
     
    208208}
    209209
    210 static errno_t cap_digit_val(char c, int *val)
     210static errno_t capa_digit_val(char c, int *val)
    211211{
    212212        switch (c) {
     
    248248}
    249249
    250 errno_t cap_parse(const char *str, cap_spec_t *cap)
     250errno_t capa_parse(const char *str, capa_spec_t *capa)
    251251{
    252252        const char *eptr;
     
    260260
    261261        eptr = str;
    262         while (cap_digit_val(*eptr, &d) == EOK) {
     262        while (capa_digit_val(*eptr, &d) == EOK) {
    263263                m = m * 10 + d;
    264264                ++eptr;
     
    268268                ++eptr;
    269269                dp = 0;
    270                 while (cap_digit_val(*eptr, &d) == EOK) {
     270                while (capa_digit_val(*eptr, &d) == EOK) {
    271271                        m = m * 10 + d;
    272272                        ++dp;
     
    281281
    282282        if (*eptr == '\0') {
    283                 cap->cunit = cu_byte;
     283                capa->cunit = cu_byte;
    284284        } else {
    285285                for (i = 0; i < CU_LIMIT; i++) {
     
    296296                return EINVAL;
    297297        found:
    298                 cap->cunit = i;
    299         }
    300 
    301         cap->m = m;
    302         cap->dp = dp;
     298                capa->cunit = i;
     299        }
     300
     301        capa->m = m;
     302        capa->dp = dp;
    303303        return EOK;
    304304}
  • uspace/lib/c/include/capa.h

    ref0a3375 rc24b0dcb  
    5555        cu_zbyte,
    5656        cu_ybyte
    57 } cap_unit_t;
     57} capa_unit_t;
    5858
    5959/** Which of values within the precision of the capacity */
     
    6565        /** The maximum value */
    6666        cv_max
    67 } cap_vsel_t;
     67} capa_vsel_t;
    6868
    6969#define CU_LIMIT (cu_ybyte + 1)
     
    8787        unsigned dp;
    8888        /** Capacity unit */
    89         cap_unit_t cunit;
    90 } cap_spec_t;
     89        capa_unit_t cunit;
     90} capa_spec_t;
    9191
    92 extern errno_t cap_format(cap_spec_t *, char **);
    93 extern errno_t cap_parse(const char *, cap_spec_t *);
    94 extern void cap_simplify(cap_spec_t *);
    95 extern void cap_from_blocks(uint64_t, size_t, cap_spec_t *);
    96 extern errno_t cap_to_blocks(cap_spec_t *, cap_vsel_t, size_t, uint64_t *);
     92extern errno_t capa_format(capa_spec_t *, char **);
     93extern errno_t capa_parse(const char *, capa_spec_t *);
     94extern void capa_simplify(capa_spec_t *);
     95extern void capa_from_blocks(uint64_t, size_t, capa_spec_t *);
     96extern errno_t capa_to_blocks(capa_spec_t *, capa_vsel_t, size_t, uint64_t *);
    9797
    9898#endif
  • uspace/lib/c/meson.build

    ref0a3375 rc24b0dcb  
    6565        'generic/bd_srv.c',
    6666        'generic/perm.c',
    67         'generic/cap.c',
     67        'generic/capa.c',
    6868        'generic/clipboard.c',
    6969        'generic/config.c',
     
    204204        'test/adt/circ_buf.c',
    205205        'test/adt/odict.c',
    206         'test/cap.c',
     206        'test/capa.c',
    207207        'test/casting.c',
    208208        'test/double_to_str.c',
  • uspace/lib/c/test/capa.c

    ref0a3375 rc24b0dcb  
    2828
    2929#include <pcut/pcut.h>
    30 #include <cap.h>
     30#include <capa.h>
    3131
    3232PCUT_INIT;
    3333
    34 PCUT_TEST_SUITE(cap);
    35 
    36 PCUT_TEST(cap_format)
     34PCUT_TEST_SUITE(capa);
     35
     36PCUT_TEST(capa_format)
    3737{
    3838        int block_size = 4;
     
    8686        };
    8787
    88         cap_spec_t cap;
     88        capa_spec_t capa;
    8989        char *str;
    9090        errno_t rc;
     
    9393        for (i = 0; i < input_size; i++) {
    9494                for (x = 0; x < block_size; x++) {
    95                         cap_from_blocks(input[i], block[x], &cap);
    96                         cap_simplify(&cap);
    97 
    98                         rc = cap_format(&cap, &str);
     95                        capa_from_blocks(input[i], block[x], &capa);
     96                        capa_simplify(&capa);
     97
     98                        rc = capa_format(&capa, &str);
    9999
    100100                        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     
    102102                        free(str);
    103103
    104                         cap_from_blocks(block[x], input[i], &cap);
    105                         cap_simplify(&cap);
    106 
    107                         rc = cap_format(&cap, &str);
     104                        capa_from_blocks(block[x], input[i], &capa);
     105                        capa_simplify(&capa);
     106
     107                        rc = capa_format(&capa, &str);
    108108
    109109                        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     
    114114}
    115115
    116 PCUT_TEST(cap_format_rounding)
     116PCUT_TEST(capa_format_rounding)
    117117{
    118118        int input_size = 8;
     
    139139        };
    140140
    141         cap_spec_t cap;
     141        capa_spec_t capa;
    142142        char *str;
    143143        errno_t rc;
     
    145145        int i;
    146146        for (i = 0; i < input_size; i++) {
    147                 cap_from_blocks(input[i], 1, &cap);
    148                 cap_simplify(&cap);
    149 
    150                 rc = cap_format(&cap, &str);
     147                capa_from_blocks(input[i], 1, &capa);
     148                capa_simplify(&capa);
     149
     150                rc = capa_format(&capa, &str);
    151151
    152152                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     
    154154                free(str);
    155155
    156                 cap_from_blocks(1, input[i], &cap);
    157                 cap_simplify(&cap);
    158 
    159                 rc = cap_format(&cap, &str);
     156                capa_from_blocks(1, input[i], &capa);
     157                capa_simplify(&capa);
     158
     159                rc = capa_format(&capa, &str);
    160160
    161161                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     
    165165}
    166166
    167 PCUT_TEST(cap_parse)
     167PCUT_TEST(capa_parse)
    168168{
    169169        int input_size = 4;
     
    196196        };
    197197
    198         cap_spec_t cap;
     198        capa_spec_t capa;
    199199        errno_t rc;
    200200        int i;
    201201
    202202        for (i = 0; i < input_size; i++) {
    203                 rc = cap_parse(input[i], &cap);
    204 
    205                 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    206                 PCUT_ASSERT_INT_EQUALS(out_cunit[i], cap.cunit);
    207                 PCUT_ASSERT_INT_EQUALS(out_dp[i], cap.dp);
    208                 PCUT_ASSERT_INT_EQUALS(out_m[i], cap.m);
    209         }
    210 }
    211 
    212 PCUT_TEST(cap_to_blocks)
     203                rc = capa_parse(input[i], &capa);
     204
     205                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     206                PCUT_ASSERT_INT_EQUALS(out_cunit[i], capa.cunit);
     207                PCUT_ASSERT_INT_EQUALS(out_dp[i], capa.dp);
     208                PCUT_ASSERT_INT_EQUALS(out_m[i], capa.m);
     209        }
     210}
     211
     212PCUT_TEST(capa_to_blocks)
    213213{
    214214        int input_size = 0;
     
    261261        };
    262262
    263         cap_spec_t cap;
     263        capa_spec_t capa;
    264264        errno_t rc;
    265265        int i;
     
    267267
    268268        for (i = 0; i < input_size; i++) {
    269                 cap.m = input_m[i];
    270                 cap.dp = input_dp[i];
    271                 cap.cunit = cu_kbyte;
    272 
    273                 rc = cap_to_blocks(&cap, cv_nom, block[i], &ret);
     269                capa.m = input_m[i];
     270                capa.dp = input_dp[i];
     271                capa.cunit = cu_kbyte;
     272
     273                rc = capa_to_blocks(&capa, cv_nom, block[i], &ret);
    274274                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    275275                PCUT_ASSERT_INT_EQUALS(out_nom[i], ret);
    276276
    277                 rc = cap_to_blocks(&cap, cv_min, block[i], &ret);
     277                rc = capa_to_blocks(&capa, cv_min, block[i], &ret);
    278278                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    279279                PCUT_ASSERT_INT_EQUALS(out_min[i], ret);
    280280
    281                 rc = cap_to_blocks(&cap, cv_max, block[i], &ret);
     281                rc = capa_to_blocks(&capa, cv_max, block[i], &ret);
    282282                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    283283                PCUT_ASSERT_INT_EQUALS(out_max[i], ret);
     
    285285}
    286286
    287 PCUT_EXPORT(cap);
     287PCUT_EXPORT(capa);
  • uspace/lib/c/test/main.c

    ref0a3375 rc24b0dcb  
    3232PCUT_INIT;
    3333
    34 PCUT_IMPORT(cap);
     34PCUT_IMPORT(capa);
    3535PCUT_IMPORT(casting);
    3636PCUT_IMPORT(circ_buf);
  • uspace/lib/fdisk/include/fdisk.h

    ref0a3375 rc24b0dcb  
    5050extern errno_t fdisk_dev_info_get_svcname(fdisk_dev_info_t *, char **);
    5151extern void fdisk_dev_info_get_svcid(fdisk_dev_info_t *, service_id_t *);
    52 extern errno_t fdisk_dev_info_capacity(fdisk_dev_info_t *, cap_spec_t *);
     52extern errno_t fdisk_dev_info_capacity(fdisk_dev_info_t *, capa_spec_t *);
    5353
    5454extern errno_t fdisk_dev_open(fdisk_t *, service_id_t, fdisk_dev_t **);
     
    5757extern void fdisk_dev_get_flags(fdisk_dev_t *, fdisk_dev_flags_t *);
    5858extern errno_t fdisk_dev_get_svcname(fdisk_dev_t *, char **);
    59 extern errno_t fdisk_dev_capacity(fdisk_dev_t *, cap_spec_t *);
     59extern errno_t fdisk_dev_capacity(fdisk_dev_t *, capa_spec_t *);
    6060
    6161extern errno_t fdisk_label_get_info(fdisk_dev_t *, fdisk_label_info_t *);
     
    6666extern fdisk_part_t *fdisk_part_next(fdisk_part_t *);
    6767extern errno_t fdisk_part_get_info(fdisk_part_t *, fdisk_part_info_t *);
    68 extern errno_t fdisk_part_get_max_avail(fdisk_dev_t *, fdisk_spc_t, cap_spec_t *);
    69 extern errno_t fdisk_part_get_tot_avail(fdisk_dev_t *, fdisk_spc_t, cap_spec_t *);
     68extern errno_t fdisk_part_get_max_avail(fdisk_dev_t *, fdisk_spc_t, capa_spec_t *);
     69extern errno_t fdisk_part_get_tot_avail(fdisk_dev_t *, fdisk_spc_t, capa_spec_t *);
    7070extern errno_t fdisk_part_create(fdisk_dev_t *, fdisk_part_spec_t *,
    7171    fdisk_part_t **);
  • uspace/lib/fdisk/include/types/fdisk.h

    ref0a3375 rc24b0dcb  
    3838
    3939#include <adt/list.h>
    40 #include <cap.h>
     40#include <capa.h>
    4141#include <loc.h>
    4242#include <stdint.h>
     
    126126        link_t llog_ba;
    127127        /** Capacity */
    128         cap_spec_t capacity;
     128        capa_spec_t capacity;
    129129        /** Partition kind */
    130130        label_pkind_t pkind;
     
    150150typedef struct {
    151151        /** Desired capacity */
    152         cap_spec_t capacity;
     152        capa_spec_t capacity;
    153153        /** Partition kind */
    154154        label_pkind_t pkind;
     
    164164typedef struct {
    165165        /** Capacity */
    166         cap_spec_t capacity;
     166        capa_spec_t capacity;
    167167        /** Partition kind */
    168168        label_pkind_t pkind;
  • uspace/lib/fdisk/src/fdisk.c

    ref0a3375 rc24b0dcb  
    3535
    3636#include <adt/list.h>
    37 #include <cap.h>
     37#include <capa.h>
    3838#include <errno.h>
    3939#include <fdisk.h>
     
    219219}
    220220
    221 errno_t fdisk_dev_info_capacity(fdisk_dev_info_t *info, cap_spec_t *cap)
     221errno_t fdisk_dev_info_capacity(fdisk_dev_info_t *info, capa_spec_t *capa)
    222222{
    223223        vbd_disk_info_t vinfo;
     
    228228                return EIO;
    229229
    230         cap_from_blocks(vinfo.nblocks, vinfo.block_size, cap);
     230        capa_from_blocks(vinfo.nblocks, vinfo.block_size, capa);
    231231        return EOK;
    232232}
     
    295295                dev->ext_part = part;
    296296
    297         cap_from_blocks(part->nblocks, dev->dinfo.block_size,
     297        capa_from_blocks(part->nblocks, dev->dinfo.block_size,
    298298            &part->capacity);
    299299        part->part_id = partid;
     
    536536}
    537537
    538 errno_t fdisk_dev_capacity(fdisk_dev_t *dev, cap_spec_t *cap)
    539 {
    540         cap_from_blocks(dev->dinfo.nblocks, dev->dinfo.block_size, cap);
     538errno_t fdisk_dev_capacity(fdisk_dev_t *dev, capa_spec_t *capa)
     539{
     540        capa_from_blocks(dev->dinfo.nblocks, dev->dinfo.block_size, capa);
    541541        return EOK;
    542542}
     
    679679
    680680/** Get size of largest free block. */
    681 errno_t fdisk_part_get_max_avail(fdisk_dev_t *dev, fdisk_spc_t spc, cap_spec_t *cap)
     681errno_t fdisk_part_get_max_avail(fdisk_dev_t *dev, fdisk_spc_t spc,
     682    capa_spec_t *capa)
    682683{
    683684        errno_t rc;
     
    698699        }
    699700
    700         cap_from_blocks(nb, dev->dinfo.block_size, cap);
     701        capa_from_blocks(nb, dev->dinfo.block_size, capa);
    701702        return EOK;
    702703}
     
    704705/** Get total free space capacity. */
    705706errno_t fdisk_part_get_tot_avail(fdisk_dev_t *dev, fdisk_spc_t spc,
    706     cap_spec_t *cap)
     707    capa_spec_t *capa)
    707708{
    708709        fdisk_free_range_t fr;
     
    726727        } while (fdisk_free_range_next(&fr));
    727728
    728         cap_from_blocks(totb, dev->dinfo.block_size, cap);
     729        capa_from_blocks(totb, dev->dinfo.block_size, capa);
    729730        return EOK;
    730731}
     
    938939        errno_t rc;
    939940
    940         rc = cap_to_blocks(&pspec->capacity, cv_nom, dev->dinfo.block_size,
     941        rc = capa_to_blocks(&pspec->capacity, cv_nom, dev->dinfo.block_size,
    941942            &nom_blocks);
    942943        if (rc != EOK)
    943944                return rc;
    944945
    945         rc = cap_to_blocks(&pspec->capacity, cv_min, dev->dinfo.block_size,
     946        rc = capa_to_blocks(&pspec->capacity, cv_min, dev->dinfo.block_size,
    946947            &min_blocks);
    947948        if (rc != EOK)
    948949                return rc;
    949950
    950         rc = cap_to_blocks(&pspec->capacity, cv_max, dev->dinfo.block_size,
     951        rc = capa_to_blocks(&pspec->capacity, cv_max, dev->dinfo.block_size,
    951952            &max_blocks);
    952953        if (rc != EOK)
Note: See TracChangeset for help on using the changeset viewer.