Changeset c24b0dcb in mainline for uspace/app/fdisk/fdisk.c


Ignore:
Timestamp:
2019-09-30T16:38:33Z (5 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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);
Note: See TracChangeset for help on using the changeset viewer.