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

Changeset 8227d63 in mainline


Ignore:
Timestamp:
2015-06-22T21:20:23Z (6 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
1356f85a
Parents:
e96047c
Message:

UI for creating and deleting partitions.

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • .bzrignore

    re96047c r8227d63  
    3434uspace/app/dnsres/dnsres
    3535uspace/app/edit/edit
     36uspace/app/fdisk/fdisk
    3637uspace/app/fontviewer/fontviewer
    3738uspace/app/getterm/getterm
     
    9192uspace/dist/app/dnsres
    9293uspace/dist/app/edit
     94uspace/dist/app/fdisk
    9395uspace/dist/app/fontviewer
    9496uspace/dist/app/getterm
  • uspace/app/fdisk/fdisk.c

    re96047c r8227d63  
    6666        char *svcname = NULL;
    6767        fdisk_cap_t cap;
     68        fdisk_dev_info_t *sdev;
    6869        char *scap = NULL;
    6970        char *dtext = NULL;
    7071        service_id_t svcid;
    7172        void *sel;
     73        int ndevs;
    7274        int rc;
    7375
     
    9395
    9496        info = fdisk_dev_first(devlist);
     97        ndevs = 0;
    9598        while (info != NULL) {
    96                 rc = fdisk_dev_get_svcname(info, &svcname);
     99                ++ndevs;
     100
     101                rc = fdisk_dev_info_get_svcname(info, &svcname);
    97102                if (rc != EOK) {
    98103                        printf("Error getting device service name.\n");
     
    100105                }
    101106
    102                 rc = fdisk_dev_capacity(info, &cap);
     107                rc = fdisk_dev_info_capacity(info, &cap);
    103108                if (rc != EOK) {
    104109                        printf("Error getting device capacity.\n");
     
    138143        }
    139144
     145        if (ndevs == 0) {
     146                printf("No disk devices found.\n");
     147                rc = ENOENT;
     148                goto error;
     149        }
     150
     151        rc = nchoice_add(choice, "Exit", NULL);
     152        if (rc != EOK) {
     153                assert(rc == ENOMEM);
     154                printf("Out of memory.\n");
     155                goto error;
     156        }
     157
    140158        rc = nchoice_get(choice, &sel);
    141159        if (rc != EOK) {
     
    144162        }
    145163
    146         fdisk_dev_get_svcid((fdisk_dev_info_t *)sel, &svcid);
     164        sdev = (fdisk_dev_info_t *)sel;
     165        if (sdev != NULL) {
     166                fdisk_dev_info_get_svcid(sdev, &svcid);
     167        } else {
     168                svcid = 0;
     169        }
     170
    147171        fdisk_dev_list_free(devlist);
    148 
    149         printf("Selected dev with sid=%zu\n", svcid);
    150172
    151173        nchoice_destroy(choice);
     
    167189        nchoice_t *choice = NULL;
    168190        void *sel;
     191        char *sltype = NULL;
     192        int i;
    169193        int rc;
    170194
     
    183207        }
    184208
    185         rc = nchoice_add(choice, "GPT", (void *)fdl_gpt);
    186         if (rc != EOK) {
    187                 assert(rc == ENOMEM);
    188                 printf("Out of memory.\n");
    189                 goto error;
    190         }
    191 
    192         rc = nchoice_add(choice, "MBR", (void *)fdl_mbr);
    193         if (rc != EOK) {
    194                 assert(rc == ENOMEM);
    195                 printf("Out of memory.\n");
    196                 goto error;
     209        for (i = FDL_CREATE_LO; i < FDL_CREATE_HI; i++) {
     210                rc = fdisk_ltype_format(i, &sltype);
     211                if (rc != EOK)
     212                        goto error;
     213
     214                rc = nchoice_add(choice, sltype, (void *)(uintptr_t)i);
     215                if (rc != EOK) {
     216                        assert(rc == ENOMEM);
     217                        printf("Out of memory.\n");
     218                        goto error;
     219                }
     220
     221                free(sltype);
     222                sltype = NULL;
    197223        }
    198224
     
    212238        return EOK;
    213239error:
     240        free(sltype);
    214241        if (choice != NULL)
    215242                nchoice_destroy(choice);
     
    217244}
    218245
     246static int fdsk_delete_label(fdisk_dev_t *dev)
     247{
     248        int rc;
     249
     250        rc = fdisk_label_destroy(dev);
     251        if (rc != EOK) {
     252                printf("Error deleting label.\n");
     253                return rc;
     254        }
     255
     256        return EOK;
     257}
     258
     259static int fdsk_select_fstype(fdisk_fstype_t *fstype)
     260{
     261        nchoice_t *choice = NULL;
     262        void *sel;
     263        char *sfstype;
     264        int i;
     265        int rc;
     266
     267        rc = nchoice_create(&choice);
     268        if (rc != EOK) {
     269                assert(rc == ENOMEM);
     270                printf("Out of memory.\n");
     271                goto error;
     272        }
     273
     274        rc = nchoice_set_prompt(choice, "Select file system type");
     275        if (rc != EOK) {
     276                assert(rc == ENOMEM);
     277                printf("Out of memory.\n");
     278                goto error;
     279        }
     280
     281        for (i = FDFS_CREATE_LO; i < FDFS_CREATE_HI; i++) {
     282                rc = fdisk_fstype_format(i, &sfstype);
     283                if (rc != EOK)
     284                        goto error;
     285
     286                rc = nchoice_add(choice, sfstype, (void *)(uintptr_t)i);
     287                if (rc != EOK) {
     288                        assert(rc == ENOMEM);
     289                        printf("Out of memory.\n");
     290                        goto error;
     291                }
     292
     293                free(sfstype);
     294                sfstype = NULL;
     295        }
     296
     297        rc = nchoice_get(choice, &sel);
     298        if (rc != EOK) {
     299                printf("Error getting user selection.\n");
     300                goto error;
     301        }
     302
     303        nchoice_destroy(choice);
     304        *fstype = (fdisk_fstype_t)sel;
     305        return EOK;
     306error:
     307        free(sfstype);
     308        if (choice != NULL)
     309                nchoice_destroy(choice);
     310        return rc;
     311}
     312
     313static int fdsk_create_part(fdisk_dev_t *dev)
     314{
     315        int rc;
     316        fdisk_part_spec_t pspec;
     317        fdisk_cap_t cap;
     318        fdisk_fstype_t fstype;
     319        tinput_t *tinput = NULL;
     320        char *scap;
     321
     322        tinput = tinput_new();
     323        if (tinput == NULL) {
     324                rc = ENOMEM;
     325                goto error;
     326        }
     327
     328        rc = tinput_set_prompt(tinput, "?> ");
     329        if (rc != EOK)
     330                goto error;
     331
     332        while (true) {
     333                printf("Enter capacity of new partition.\n");
     334                rc = tinput_read(tinput, &scap);
     335                if (rc != EOK)
     336                        goto error;
     337
     338                rc = fdisk_cap_parse(scap, &cap);
     339                if (rc == EOK)
     340                        break;
     341        }
     342
     343        tinput_destroy(tinput);
     344
     345        rc = fdsk_select_fstype(&fstype);
     346        if (rc != EOK)
     347                goto error;
     348
     349        fdisk_pspec_init(&pspec);
     350        pspec.capacity = cap;
     351        pspec.fstype = fstype;
     352
     353        rc = fdisk_part_create(dev, &pspec, NULL);
     354        if (rc != EOK) {
     355                printf("Error creating partition.\n");
     356                goto error;
     357        }
     358
     359        return EOK;
     360error:
     361        if (tinput != NULL)
     362                tinput_destroy(tinput);
     363        return rc;
     364}
     365
     366static int fdsk_delete_part(fdisk_dev_t *dev)
     367{
     368        nchoice_t *choice = NULL;
     369        fdisk_part_t *part;
     370        fdisk_part_info_t pinfo;
     371        char *scap = NULL;
     372        char *sfstype = NULL;
     373        char *sdesc = NULL;
     374        void *sel;
     375        int rc;
     376
     377        rc = nchoice_create(&choice);
     378        if (rc != EOK) {
     379                assert(rc == ENOMEM);
     380                printf("Out of memory.\n");
     381                goto error;
     382        }
     383
     384        rc = nchoice_set_prompt(choice, "Select partition to delete");
     385        if (rc != EOK) {
     386                assert(rc == ENOMEM);
     387                printf("Out of memory.\n");
     388                goto error;
     389        }
     390
     391        part = fdisk_part_first(dev);
     392        while (part != NULL) {
     393                rc = fdisk_part_get_info(part, &pinfo);
     394                if (rc != EOK) {
     395                        printf("Error getting partition information.\n");
     396                        goto error;
     397                }
     398
     399                rc = fdisk_cap_format(&pinfo.capacity, &scap);
     400                if (rc != EOK) {
     401                        printf("Out of memory.\n");
     402                        goto error;
     403                }
     404
     405                rc = fdisk_fstype_format(pinfo.fstype, &sfstype);
     406                if (rc != EOK) {
     407                        printf("Out of memory.\n");
     408                        goto error;
     409                }
     410
     411                rc = asprintf(&sdesc, "%s, %s", scap, sfstype);
     412                if (rc < 0) {
     413                        rc = ENOMEM;
     414                        goto error;
     415                }
     416
     417                rc = nchoice_add(choice, sdesc, (void *)part);
     418                if (rc != EOK) {
     419                        assert(rc == ENOMEM);
     420                        printf("Out of memory.\n");
     421                        goto error;
     422                }
     423
     424                free(scap);
     425                scap = NULL;
     426                free(sfstype);
     427                sfstype = NULL;
     428                free(sdesc);
     429                sdesc = NULL;
     430
     431                part = fdisk_part_next(part);
     432        }
     433
     434        rc = nchoice_get(choice, &sel);
     435        if (rc != EOK) {
     436                printf("Error getting user selection.\n");
     437                goto error;
     438        }
     439
     440        rc = fdisk_part_destroy((fdisk_part_t *)sel);
     441        if (rc != EOK) {
     442                printf("Error deleting partition.\n");
     443                return rc;
     444        }
     445
     446        nchoice_destroy(choice);
     447        return EOK;
     448error:
     449        free(scap);
     450        free(sfstype);
     451        free(sdesc);
     452
     453        if (choice != NULL)
     454                nchoice_destroy(choice);
     455        return rc;
     456}
     457
    219458/** Device menu */
    220459static int fdsk_dev_menu(fdisk_dev_t *dev)
     
    222461        nchoice_t *choice = NULL;
    223462        fdisk_label_info_t linfo;
     463        fdisk_part_t *part;
     464        fdisk_part_info_t pinfo;
     465        fdisk_cap_t cap;
    224466        char *sltype = NULL;
    225         int rc;
     467        char *sdcap = NULL;
     468        char *scap = NULL;
     469        char *sfstype = NULL;
     470        char *svcname = NULL;
     471        int rc;
     472        int npart;
    226473        void *sel;
    227474
     
    240487        }
    241488
     489        rc = fdisk_dev_capacity(dev, &cap);
     490        if (rc != EOK) {
     491                printf("Error getting device capacity.\n");
     492                goto error;
     493        }
     494
     495        rc = fdisk_cap_format(&cap, &sdcap);
     496        if (rc != EOK) {
     497                printf("Out of memory.\n");
     498                goto error;
     499        }
     500
     501        rc = fdisk_dev_get_svcname(dev, &svcname);
     502        if (rc != EOK) {
     503                printf("Error getting device service name.\n");
     504                goto error;
     505        }
     506
    242507        rc = fdisk_label_get_info(dev, &linfo);
    243508        if (rc != EOK) {
     
    253518        }
    254519
     520        printf("Device: %s, %s\n", sdcap, svcname);
    255521        printf("Label type: %s\n", sltype);
    256522        free(sltype);
    257523        sltype = NULL;
     524        free(sdcap);
     525        sdcap = NULL;
     526
     527        part = fdisk_part_first(dev);
     528        npart = 0;
     529        while (part != NULL) {
     530                ++npart;
     531                rc = fdisk_part_get_info(part, &pinfo);
     532                if (rc != EOK) {
     533                        printf("Error getting partition information.\n");
     534                        goto error;
     535                }
     536
     537                rc = fdisk_cap_format(&pinfo.capacity, &scap);
     538                if (rc != EOK) {
     539                        printf("Out of memory.\n");
     540                        goto error;
     541                }
     542
     543                rc = fdisk_fstype_format(pinfo.fstype, &sfstype);
     544                if (rc != EOK) {
     545                        printf("Out of memory.\n");
     546                        goto error;
     547                }
     548
     549                printf("Partition %d: %s, %s\n", npart, scap, sfstype);
     550                free(scap);
     551                scap = NULL;
     552                free(sfstype);
     553                sfstype = NULL;
     554
     555                part = fdisk_part_next(part);
     556        }
    258557
    259558        rc = nchoice_set_prompt(choice, "Select action");
     
    262561                printf("Out of memory.\n");
    263562                goto error;
     563        }
     564
     565        if (linfo.ltype != fdl_none) {
     566                rc = nchoice_add(choice, "Create partition",
     567                    (void *)devac_create_part);
     568                if (rc != EOK) {
     569                        assert(rc == ENOMEM);
     570                        printf("Out of memory.\n");
     571                        goto error;
     572                }
     573        }
     574
     575        if (npart > 0) {
     576                rc = nchoice_add(choice, "Delete partition",
     577                    (void *)devac_delete_part);
     578                if (rc != EOK) {
     579                        assert(rc == ENOMEM);
     580                        printf("Out of memory.\n");
     581                        goto error;
     582                }
    264583        }
    265584
     
    280599                        goto error;
    281600                }
    282         }
    283 
    284         rc = nchoice_add(choice, "Create partition",
    285             (void *)devac_create_part);
    286         if (rc != EOK) {
    287                 assert(rc == ENOMEM);
    288                 printf("Out of memory.\n");
    289                 goto error;
    290         }
    291 
    292         rc = nchoice_add(choice, "Delete partition",
    293             (void *)devac_delete_part);
    294         if (rc != EOK) {
    295                 assert(rc == ENOMEM);
    296                 printf("Out of memory.\n");
    297                 goto error;
    298601        }
    299602
     
    318621                break;
    319622        case devac_delete_label:
    320                 rc = fdisk_label_destroy(dev);
     623                rc = fdsk_delete_label(dev);
    321624                if (rc != EOK)
    322625                        goto error;
    323626                break;
    324627        case devac_create_part:
     628                rc = fdsk_create_part(dev);
     629                if (rc != EOK)
     630                        goto error;
    325631                break;
    326632        case devac_delete_part:
     633                rc = fdsk_delete_part(dev);
     634                if (rc != EOK)
     635                        goto error;
    327636                break;
    328637        case devac_exit:
     
    334643        return EOK;
    335644error:
     645        free(sdcap);
     646        free(scap);
     647        free(sfstype);
     648        free(svcname);
    336649        if (choice != NULL)
    337650                nchoice_destroy(choice);
     
    349662                return 1;
    350663
     664        if (svcid == 0)
     665                return 0;
     666
    351667        rc = fdisk_dev_open(svcid, &dev);
    352668        if (rc != EOK) {
  • uspace/lib/c/generic/str.c

    re96047c r8227d63  
    519519        wchar_t c1 = 0;
    520520        wchar_t c2 = 0;
    521        
     521
    522522        size_t off1 = 0;
    523523        size_t off2 = 0;
     
    529529                if (c1 < c2)
    530530                        return -1;
    531                
     531
    532532                if (c1 > c2)
    533533                        return 1;
    534534
    535535                if (c1 == 0 || c2 == 0)
    536                         break;         
     536                        break;
    537537        }
    538538
     
    566566        wchar_t c1 = 0;
    567567        wchar_t c2 = 0;
    568        
     568
    569569        size_t off1 = 0;
    570570        size_t off2 = 0;
    571        
     571
    572572        size_t len = 0;
    573573
     
    578578                c1 = str_decode(s1, &off1, STR_NO_LIMIT);
    579579                c2 = str_decode(s2, &off2, STR_NO_LIMIT);
     580
     581                if (c1 < c2)
     582                        return -1;
     583
     584                if (c1 > c2)
     585                        return 1;
     586
     587                if (c1 == 0 || c2 == 0)
     588                        break;
     589
     590                ++len;
     591        }
     592
     593        return 0;
     594
     595}
     596
     597/** Compare two NULL terminated strings in case-insensitive manner.
     598 *
     599 * Do a char-by-char comparison of two NULL-terminated strings.
     600 * The strings are considered equal iff their length is equal
     601 * and both strings consist of the same sequence of characters
     602 * when converted to lower case.
     603 *
     604 * A string S1 is less than another string S2 if it has a character with
     605 * lower value at the first character position where the strings differ.
     606 * If the strings differ in length, the shorter one is treated as if
     607 * padded by characters with a value of zero.
     608 *
     609 * @param s1 First string to compare.
     610 * @param s2 Second string to compare.
     611 *
     612 * @return 0 if the strings are equal, -1 if the first is less than the second,
     613 *         1 if the second is less than the first.
     614 *
     615 */
     616int str_casecmp(const char *s1, const char *s2)
     617{
     618        wchar_t c1 = 0;
     619        wchar_t c2 = 0;
     620
     621        size_t off1 = 0;
     622        size_t off2 = 0;
     623
     624        while (true) {
     625                c1 = tolower(str_decode(s1, &off1, STR_NO_LIMIT));
     626                c2 = tolower(str_decode(s2, &off2, STR_NO_LIMIT));
     627
     628                if (c1 < c2)
     629                        return -1;
     630
     631                if (c1 > c2)
     632                        return 1;
     633
     634                if (c1 == 0 || c2 == 0)
     635                        break;
     636        }
     637
     638        return 0;
     639}
     640
     641/** Compare two NULL terminated strings with length limit in case-insensitive
     642 * manner.
     643 *
     644 * Do a char-by-char comparison of two NULL-terminated strings.
     645 * The strings are considered equal iff
     646 * min(str_length(s1), max_len) == min(str_length(s2), max_len)
     647 * and both strings consist of the same sequence of characters,
     648 * up to max_len characters.
     649 *
     650 * A string S1 is less than another string S2 if it has a character with
     651 * lower value at the first character position where the strings differ.
     652 * If the strings differ in length, the shorter one is treated as if
     653 * padded by characters with a value of zero. Only the first max_len
     654 * characters are considered.
     655 *
     656 * @param s1      First string to compare.
     657 * @param s2      Second string to compare.
     658 * @param max_len Maximum number of characters to consider.
     659 *
     660 * @return 0 if the strings are equal, -1 if the first is less than the second,
     661 *         1 if the second is less than the first.
     662 *
     663 */
     664int str_lcasecmp(const char *s1, const char *s2, size_t max_len)
     665{
     666        wchar_t c1 = 0;
     667        wchar_t c2 = 0;
     668       
     669        size_t off1 = 0;
     670        size_t off2 = 0;
     671       
     672        size_t len = 0;
     673
     674        while (true) {
     675                if (len >= max_len)
     676                        break;
     677
     678                c1 = tolower(str_decode(s1, &off1, STR_NO_LIMIT));
     679                c2 = tolower(str_decode(s2, &off2, STR_NO_LIMIT));
    580680
    581681                if (c1 < c2)
  • uspace/lib/c/include/str.h

    re96047c r8227d63  
    8282extern int str_cmp(const char *s1, const char *s2);
    8383extern int str_lcmp(const char *s1, const char *s2, size_t max_len);
     84extern int str_casecmp(const char *s1, const char *s2);
     85extern int str_lcasecmp(const char *s1, const char *s2, size_t max_len);
    8486
    8587extern bool str_test_prefix(const char *s, const char *p);
  • uspace/lib/fdisk/include/fdisk.h

    re96047c r8227d63  
    4444extern fdisk_dev_info_t *fdisk_dev_first(fdisk_dev_list_t *);
    4545extern fdisk_dev_info_t *fdisk_dev_next(fdisk_dev_info_t *);
    46 extern int fdisk_dev_get_svcname(fdisk_dev_info_t *, char **);
    47 extern void fdisk_dev_get_svcid(fdisk_dev_info_t *, service_id_t *);
    48 extern int fdisk_dev_capacity(fdisk_dev_info_t *, fdisk_cap_t *);
     46extern int fdisk_dev_info_get_svcname(fdisk_dev_info_t *, char **);
     47extern void fdisk_dev_info_get_svcid(fdisk_dev_info_t *, service_id_t *);
     48extern int fdisk_dev_info_capacity(fdisk_dev_info_t *, fdisk_cap_t *);
    4949
    5050extern int fdisk_dev_open(service_id_t, fdisk_dev_t **);
    5151extern void fdisk_dev_close(fdisk_dev_t *);
     52extern int fdisk_dev_get_svcname(fdisk_dev_t *, char **);
     53extern int fdisk_dev_capacity(fdisk_dev_t *, fdisk_cap_t *);
    5254
    5355extern int fdisk_label_get_info(fdisk_dev_t *, fdisk_label_info_t *);
     
    5759extern fdisk_part_t *fdisk_part_first(fdisk_dev_t *);
    5860extern fdisk_part_t *fdisk_part_next(fdisk_part_t *);
     61extern int fdisk_part_get_info(fdisk_part_t *, fdisk_part_info_t *);
    5962extern int fdisk_part_get_max_avail(fdisk_dev_t *, fdisk_cap_t *);
    60 extern int fdisk_part_create(fdisk_dev_t *, fdisk_partspec_t *,
     63extern int fdisk_part_create(fdisk_dev_t *, fdisk_part_spec_t *,
    6164    fdisk_part_t **);
    6265extern int fdisk_part_destroy(fdisk_part_t *);
     66extern void fdisk_pspec_init(fdisk_part_spec_t *);
    6367
    6468extern int fdisk_cap_format(fdisk_cap_t *, char **);
     69extern int fdisk_cap_parse(const char *, fdisk_cap_t *);
    6570extern int fdisk_ltype_format(fdisk_label_type_t, char **);
     71extern int fdisk_fstype_format(fdisk_fstype_t, char **);
    6672
    6773#endif
  • uspace/lib/fdisk/include/types/fdisk.h

    re96047c r8227d63  
    4141#include <stdint.h>
    4242
     43typedef enum {
     44        cu_byte = 0,
     45        cu_kbyte,
     46        cu_mbyte,
     47        cu_gbyte,
     48        cu_tbyte,
     49        cu_pbyte,
     50        cu_ebyte,
     51        cu_zbyte,
     52        cu_ybyte
     53} fdisk_cunit_t;
     54
     55#define CU_LIMIT (cu_ybyte + 1)
     56
     57/** File system type */
     58typedef enum {
     59        fdfs_none = 0,
     60        fdfs_unknown,
     61        fdfs_exfat,
     62        fdfs_fat,
     63        fdfs_minix,
     64        fdfs_ext4
     65} fdisk_fstype_t;
     66
     67/** Highest fstype value + 1 */
     68#define FDFS_LIMIT (fdfs_ext4 + 1)
     69/** Lowest fstype allowed for creation */
     70#define FDFS_CREATE_LO fdfs_exfat
     71/** Highest fstype allowed for creation + 1 */
     72#define FDFS_CREATE_HI (fdfs_ext4 + 1)
     73
     74/** Partition capacity */
     75typedef struct {
     76        uint64_t value;
     77        fdisk_cunit_t cunit;
     78} fdisk_cap_t;
     79
    4380/** List of devices available for managing by fdisk */
    4481typedef struct {
     
    70107} fdisk_label_type_t;
    71108
     109/** Highest label type + 1 */
     110#define FDL_LIMIT (fdl_gpt + 1)
     111/** Lowest label type allowed for creation */
     112#define FDL_CREATE_LO fdl_mbr
     113/** Highest label type allowed for creation + 1 */
     114#define FDL_CREATE_HI (fdl_gpt + 1)
     115
    72116/** Open fdisk device */
    73117typedef struct {
     118        /** Label type */
    74119        fdisk_label_type_t ltype;
     120        /** Partitions */
     121        list_t parts; /* of fdisk_part_t */
     122        /** Service ID */
     123        service_id_t sid;
    75124} fdisk_dev_t;
    76125
     
    82131/** Partition */
    83132typedef struct {
     133        /** Containing device */
     134        fdisk_dev_t *dev;
     135        /** Link to fdisk_dev_t.parts */
     136        link_t ldev;
     137        /** Capacity */
     138        fdisk_cap_t capacity;
     139        /** File system type */
     140        fdisk_fstype_t fstype;
    84141} fdisk_part_t;
    85 
    86 typedef enum {
    87         cu_byte = 0,
    88         cu_kbyte,
    89         cu_mbyte,
    90         cu_gbyte,
    91         cu_tbyte,
    92         cu_pbyte,
    93         cu_ebyte,
    94         cu_zbyte,
    95         cu_ybyte
    96 } fdisk_cunit_t;
    97 
    98 /** Partition capacity */
    99 typedef struct {
    100         uint64_t value;
    101         fdisk_cunit_t cunit;
    102 } fdisk_cap_t;
    103142
    104143/** Specification of new partition */
    105144typedef struct {
    106 } fdisk_partspec_t;
     145        /** Desired capacity */
     146        fdisk_cap_t capacity;
     147        /** File system type */
     148        fdisk_fstype_t fstype;
     149} fdisk_part_spec_t;
     150
     151/** Partition info */
     152typedef struct {
     153        fdisk_cap_t capacity;
     154        /** File system type */
     155        fdisk_fstype_t fstype;
     156} fdisk_part_info_t;
    107157
    108158#endif
  • uspace/lib/fdisk/src/fdisk.c

    re96047c r8227d63  
    3939#include <fdisk.h>
    4040#include <loc.h>
     41#include <mem.h>
    4142#include <stdio.h>
    4243#include <stdlib.h>
    4344#include <str.h>
     45
     46static const char *cu_str[] = {
     47        [cu_byte] = "B",
     48        [cu_kbyte] = "kB",
     49        [cu_mbyte] = "MB",
     50        [cu_gbyte] = "GB",
     51        [cu_tbyte] = "TB",
     52        [cu_pbyte] = "PB",
     53        [cu_ebyte] = "EB",
     54        [cu_zbyte] = "ZB",
     55        [cu_ybyte] = "YB"
     56};
    4457
    4558static void fdisk_dev_info_delete(fdisk_dev_info_t *info)
     
    144157}
    145158
    146 void fdisk_dev_get_svcid(fdisk_dev_info_t *info, service_id_t *rsid)
     159void fdisk_dev_info_get_svcid(fdisk_dev_info_t *info, service_id_t *rsid)
    147160{
    148161        *rsid = info->svcid;
    149162}
    150163
    151 int fdisk_dev_get_svcname(fdisk_dev_info_t *info, char **rname)
     164int fdisk_dev_info_get_svcname(fdisk_dev_info_t *info, char **rname)
    152165{
    153166        char *name;
     
    169182}
    170183
    171 int fdisk_dev_capacity(fdisk_dev_info_t *info, fdisk_cap_t *cap)
     184int fdisk_dev_info_capacity(fdisk_dev_info_t *info, fdisk_cap_t *cap)
    172185{
    173186        size_t bsize;
     
    179192                if (rc != EOK)
    180193                        return rc;
     194
     195                info->blk_inited = true;
    181196        }
    182197
     
    204219
    205220        dev->ltype = fdl_none;
     221        dev->sid = sid;
     222        list_initialize(&dev->parts);
    206223        *rdev = dev;
    207224        return EOK;
     
    211228{
    212229        free(dev);
     230}
     231
     232int fdisk_dev_get_svcname(fdisk_dev_t *dev, char **rname)
     233{
     234        char *name;
     235        int rc;
     236
     237        rc = loc_service_get_name(dev->sid, &name);
     238        if (rc != EOK)
     239                return rc;
     240
     241        *rname = name;
     242        return EOK;
     243}
     244
     245int fdisk_dev_capacity(fdisk_dev_t *dev, fdisk_cap_t *cap)
     246{
     247        size_t bsize;
     248        aoff64_t nblocks;
     249        int rc;
     250
     251        rc = block_init(EXCHANGE_SERIALIZE, dev->sid, 2048);
     252        if (rc != EOK)
     253                return rc;
     254
     255        rc = block_get_bsize(dev->sid, &bsize);
     256        if (rc != EOK)
     257                return EIO;
     258
     259        rc = block_get_nblocks(dev->sid, &nblocks);
     260        if (rc != EOK)
     261                return EIO;
     262
     263        block_fini(dev->sid);
     264
     265        cap->value = bsize * nblocks;
     266        cap->cunit = cu_byte;
     267
     268        return EOK;
    213269}
    214270
     
    230286int fdisk_label_destroy(fdisk_dev_t *dev)
    231287{
     288        fdisk_part_t *part;
     289
    232290        if (dev->ltype == fdl_none)
    233291                return ENOENT;
    234292
     293        part = fdisk_part_first(dev);
     294        while (part != NULL) {
     295                (void) fdisk_part_destroy(part); /* XXX */
     296                part = fdisk_part_first(dev);
     297        }
     298
    235299        dev->ltype = fdl_none;
    236300        return EOK;
     
    239303fdisk_part_t *fdisk_part_first(fdisk_dev_t *dev)
    240304{
    241         return NULL;
     305        link_t *link;
     306
     307        link = list_first(&dev->parts);
     308        if (link == NULL)
     309                return NULL;
     310
     311        return list_get_instance(link, fdisk_part_t, ldev);
    242312}
    243313
    244314fdisk_part_t *fdisk_part_next(fdisk_part_t *part)
    245315{
    246         return NULL;
     316        link_t *link;
     317
     318        link = list_next(&part->ldev, &part->dev->parts);
     319        if (link == NULL)
     320                return NULL;
     321
     322        return list_get_instance(link, fdisk_part_t, ldev);
     323}
     324
     325int fdisk_part_get_info(fdisk_part_t *part, fdisk_part_info_t *info)
     326{
     327        info->capacity = part->capacity;
     328        info->fstype = part->fstype;
     329        return EOK;
    247330}
    248331
     
    252335}
    253336
    254 int fdisk_part_create(fdisk_dev_t *dev, fdisk_partspec_t *pspec,
     337int fdisk_part_create(fdisk_dev_t *dev, fdisk_part_spec_t *pspec,
    255338    fdisk_part_t **rpart)
    256339{
     340        fdisk_part_t *part;
     341
     342        part = calloc(1, sizeof(fdisk_part_t));
     343        if (part == NULL)
     344                return ENOMEM;
     345
     346        part->dev = dev;
     347        list_append(&part->ldev, &dev->parts);
     348        part->capacity = pspec->capacity;
     349        part->fstype = pspec->fstype;
     350
     351        if (rpart != NULL)
     352                *rpart = part;
    257353        return EOK;
    258354}
     
    260356int fdisk_part_destroy(fdisk_part_t *part)
    261357{
    262         return EOK;
     358        list_remove(&part->ldev);
     359        free(part);
     360        return EOK;
     361}
     362
     363void fdisk_pspec_init(fdisk_part_spec_t *pspec)
     364{
     365        memset(pspec, 0, sizeof(fdisk_part_spec_t));
    263366}
    264367
     
    266369{
    267370        int rc;
    268 
    269         rc = asprintf(rstr, "%" PRIu64 " B", cap->value);
     371        const char *sunit;
     372
     373        sunit = NULL;
     374
     375        if (cap->cunit < 0 || cap->cunit >= CU_LIMIT)
     376                assert(false);
     377
     378        sunit = cu_str[cap->cunit];
     379        rc = asprintf(rstr, "%" PRIu64 " %s", cap->value, sunit);
    270380        if (rc < 0)
    271381                return ENOMEM;
    272382
     383        return EOK;
     384}
     385
     386int fdisk_cap_parse(const char *str, fdisk_cap_t *cap)
     387{
     388        char *eptr;
     389        char *p;
     390        unsigned long val;
     391        int i;
     392
     393        val = strtoul(str, &eptr, 10);
     394
     395        while (*eptr == ' ')
     396                ++eptr;
     397
     398        if (*eptr == '\0') {
     399                cap->cunit = cu_byte;
     400        } else {
     401                for (i = 0; i < CU_LIMIT; i++) {
     402                        if (str_lcasecmp(eptr, cu_str[i],
     403                            str_length(cu_str[i])) == 0) {
     404                                p = eptr + str_size(cu_str[i]);
     405                                while (*p == ' ')
     406                                        ++p;
     407                                if (*p == '\0')
     408                                        goto found;
     409                        }
     410                }
     411
     412                return EINVAL;
     413found:
     414                cap->cunit = i;
     415        }
     416
     417        cap->value = val;
    273418        return EOK;
    274419}
     
    303448}
    304449
     450int fdisk_fstype_format(fdisk_fstype_t fstype, char **rstr)
     451{
     452        const char *sfstype;
     453        char *s;
     454
     455        sfstype = NULL;
     456        switch (fstype) {
     457        case fdfs_none:
     458                sfstype = "None";
     459                break;
     460        case fdfs_unknown:
     461                sfstype = "Unknown";
     462                break;
     463        case fdfs_exfat:
     464                sfstype = "ExFAT";
     465                break;
     466        case fdfs_fat:
     467                sfstype = "FAT";
     468                break;
     469        case fdfs_minix:
     470                sfstype = "MINIX";
     471                break;
     472        case fdfs_ext4:
     473                sfstype = "Ext4";
     474                break;
     475        }
     476
     477        s = str_dup(sfstype);
     478        if (s == NULL)
     479                return ENOMEM;
     480
     481        *rstr = s;
     482        return EOK;
     483}
     484
    305485/** @}
    306486 */
Note: See TracChangeset for help on using the changeset viewer.