Changeset 8227d63 in mainline for uspace/lib/fdisk


Ignore:
Timestamp:
2015-06-22T21:20:23Z (10 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1356f85a
Parents:
e96047c
Message:

UI for creating and deleting partitions.

Location:
uspace/lib/fdisk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • 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.