Changeset db9c889 in mainline for uspace


Ignore:
Timestamp:
2018-06-29T13:22:39Z (7 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
72c72d4
Parents:
5f36841
git-author:
Jiri Svoboda <jiri@…> (2018-06-28 17:22:13)
git-committer:
Jiri Svoboda <jiri@…> (2018-06-29 13:22:39)
Message:

Add volume administration utility.

Location:
uspace
Files:
4 added
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/Makefile

    r5f36841 rdb9c889  
    7979        app/untar \
    8080        app/usbinfo \
     81        app/vol \
    8182        app/vuhid \
    8283        app/nic \

  • uspace/app/fdisk/fdisk.c

    r5f36841 rdb9c889  
    3737#include <cap.h>
    3838#include <errno.h>
     39#include <fdisk.h>
     40#include <io/label.h>
    3941#include <nchoice.h>
    4042#include <stdbool.h>
    4143#include <stdio.h>
    4244#include <stdlib.h>
    43 #include <fdisk.h>
    4445#include <str.h>
     46#include <vol.h>
    4547
    4648#define NO_LABEL_CAPTION "(No name)"
    … …  
    6971} devac_t;
    7072
    71 static errno_t fdsk_pcnt_fs_format(vol_part_cnt_t pcnt, vol_fstype_t fstype,
    72     char **rstr)
    73 {
    74         errno_t rc;
    75         char *s;
    76 
    77         switch (pcnt) {
    78         case vpc_empty:
    79                 s = str_dup("Empty");
    80                 if (s == NULL)
    81                         return ENOMEM;
    82                 break;
    83         case vpc_fs:
    84                 rc = fdisk_fstype_format(fstype, &s);
    85                 if (rc != EOK)
    86                         return ENOMEM;
    87                 break;
    88         case vpc_unknown:
    89                 s = str_dup("Unknown");
    90                 if (s == NULL)
    91                         return ENOMEM;
    92                 break;
    93         }
    94 
    95         *rstr = s;
    96         return EOK;
    97 }
    98 
    9973/** Confirm user selection. */
    10074static errno_t fdsk_confirm(const char *msg, bool *rconfirm)
    … …  
    305279
    306280        for (i = LT_FIRST; i < LT_LIMIT; i++) {
    307                 rc = fdisk_ltype_format(i, &sltype);
     281                rc = label_type_format(i, &sltype);
    308282                if (rc != EOK)
    309283                        goto error;
    … …  
    413387
    414388        for (i = 0; i < VOL_FSTYPE_LIMIT; i++) {
    415                 rc = fdisk_fstype_format(i, &sfstype);
     389                rc = vol_fstype_format(i, &sfstype);
    416390                if (rc != EOK)
    417391                        goto error;
    … …  
    598572                }
    599573
    600                 rc = fdisk_pkind_format(pinfo.pkind, &spkind);
     574                rc = label_pkind_format(pinfo.pkind, &spkind);
    601575                if (rc != EOK) {
    602576                        printf("\nOut of memory.\n");
    … …  
    605579
    606580                if (pinfo.pkind != lpk_extended) {
    607                         rc = fdsk_pcnt_fs_format(pinfo.pcnt, pinfo.fstype, &sfstype);
     581                        rc = vol_pcnt_fs_format(pinfo.pcnt, pinfo.fstype, &sfstype);
    608582                        if (rc != EOK) {
    609583                                printf("Out of memory.\n");
    … …  
    773747                break;
    774748        default:
    775                 rc = fdisk_ltype_format(linfo.ltype, &sltype);
     749                rc = label_type_format(linfo.ltype, &sltype);
    776750                if (rc != EOK) {
    777751                        assert(rc == ENOMEM);
    … …  
    804778                }
    805779
    806                 rc = fdsk_pcnt_fs_format(pinfo.pcnt, pinfo.fstype, &sfstype);
     780                rc = vol_pcnt_fs_format(pinfo.pcnt, pinfo.fstype, &sfstype);
    807781                if (rc != EOK) {
    808782                        printf("Out of memory.\n");
    … …  
    821795
    822796                if ((linfo.flags & lf_ext_supp) != 0) {
    823                         rc = fdisk_pkind_format(pinfo.pkind, &spkind);
     797                        rc = label_pkind_format(pinfo.pkind, &spkind);
    824798                        if (rc != EOK) {
    825799                                printf("\nOut of memory.\n");

  • uspace/lib/c/Makefile

    r5f36841 rdb9c889  
    112112        generic/io/log.c \
    113113        generic/io/logctl.c \
     114        generic/io/label.c \
    114115        generic/io/kio.c \
    115116        generic/io/klog.c \

  • uspace/lib/c/generic/vol.c

    r5f36841 rdb9c889  
    304304}
    305305
     306/** Format file system type as string.
     307 *
     308 * @param fstype File system type
     309 * @param rstr Place to store pointer to newly allocated string
     310 * @return EOK on success, ENOMEM if out of memory
     311 */
     312errno_t vol_fstype_format(vol_fstype_t fstype, char **rstr)
     313{
     314        const char *sfstype;
     315        char *s;
     316
     317        sfstype = NULL;
     318        switch (fstype) {
     319        case fs_exfat:
     320                sfstype = "ExFAT";
     321                break;
     322        case fs_fat:
     323                sfstype = "FAT";
     324                break;
     325        case fs_minix:
     326                sfstype = "MINIX";
     327                break;
     328        case fs_ext4:
     329                sfstype = "Ext4";
     330                break;
     331        case fs_cdfs:
     332                sfstype = "ISO 9660";
     333                break;
     334        }
     335
     336        s = str_dup(sfstype);
     337        if (s == NULL)
     338                return ENOMEM;
     339
     340        *rstr = s;
     341        return EOK;
     342}
     343
     344/** Format partition content / file system type as string.
     345 *
     346 * @param pcnt Partition content
     347 * @param fstype File system type
     348 * @param rstr Place to store pointer to newly allocated string
     349 * @return EOK on success, ENOMEM if out of memory
     350 */
     351errno_t vol_pcnt_fs_format(vol_part_cnt_t pcnt, vol_fstype_t fstype,
     352    char **rstr)
     353{
     354        int rc;
     355        char *s = NULL;
     356
     357        switch (pcnt) {
     358        case vpc_empty:
     359                s = str_dup("Empty");
     360                if (s == NULL)
     361                        return ENOMEM;
     362                break;
     363        case vpc_fs:
     364                rc = vol_fstype_format(fstype, &s);
     365                if (rc != EOK)
     366                        return ENOMEM;
     367                break;
     368        case vpc_unknown:
     369                s = str_dup("Unknown");
     370                if (s == NULL)
     371                        return ENOMEM;
     372                break;
     373        }
     374
     375        assert(s != NULL);
     376        *rstr = s;
     377        return EOK;
     378}
     379
    306380/** @}
    307381 */

  • uspace/lib/c/include/types/vol.h

    r5f36841 rdb9c889  
    3737
    3838#include <async.h>
     39#include <ipc/vfs.h>
    3940#include <ipc/vol.h>
    4041#include <stdbool.h>
    … …  
    7576        /** Volume label */
    7677        char label[VOL_LABEL_MAXLEN + 1];
     78        /** Current mount point */
     79        char cur_mp[MAX_PATH_LEN + 1]; /* XXX too big */
     80        /** Current mount point is automatic */
     81        bool cur_mp_auto;
    7782} vol_part_info_t;
    7883

  • uspace/lib/c/include/vol.h

    r5f36841 rdb9c889  
    3737
    3838#include <async.h>
     39#include <errno.h>
    3940#include <loc.h>
    4041#include <stdint.h>
    … …  
    4748extern errno_t vol_part_add(vol_t *, service_id_t);
    4849extern errno_t vol_part_info(vol_t *, service_id_t, vol_part_info_t *);
     50extern errno_t vol_part_eject(vol_t *, service_id_t);
    4951extern errno_t vol_part_empty(vol_t *, service_id_t);
    5052extern errno_t vol_part_get_lsupp(vol_t *, vol_fstype_t, vol_label_supp_t *);
    5153extern errno_t vol_part_mkfs(vol_t *, service_id_t, vol_fstype_t, const char *);
     54
     55extern errno_t vol_fstype_format(vol_fstype_t, char **);
     56extern errno_t vol_pcnt_fs_format(vol_part_cnt_t, vol_fstype_t, char **);
    5257
    5358#endif

  • uspace/lib/fdisk/include/fdisk.h

    r5f36841 rdb9c889  
    3737#define LIBFDISK_FDISK_H_
    3838
     39#include <errno.h>
    3940#include <loc.h>
    4041#include <types/fdisk.h>
    … …  
    7273extern void fdisk_pspec_init(fdisk_part_spec_t *);
    7374
    74 extern errno_t fdisk_ltype_format(label_type_t, char **);
    75 extern errno_t fdisk_fstype_format(vol_fstype_t, char **);
    76 extern errno_t fdisk_pkind_format(label_pkind_t, char **);
    77 
    7875extern errno_t fdisk_get_vollabel_support(fdisk_dev_t *, vol_fstype_t,
    7976    vol_label_supp_t *);

  • uspace/lib/fdisk/src/fdisk.c

    r5f36841 rdb9c889  
    813813}
    814814
    815 errno_t fdisk_ltype_format(label_type_t ltype, char **rstr)
    816 {
    817         const char *sltype;
    818         char *s;
    819 
    820         sltype = NULL;
    821         switch (ltype) {
    822         case lt_none:
    823                 sltype = "None";
    824                 break;
    825         case lt_mbr:
    826                 sltype = "MBR";
    827                 break;
    828         case lt_gpt:
    829                 sltype = "GPT";
    830                 break;
    831         }
    832 
    833         s = str_dup(sltype);
    834         if (s == NULL)
    835                 return ENOMEM;
    836 
    837         *rstr = s;
    838         return EOK;
    839 }
    840 
    841 errno_t fdisk_fstype_format(vol_fstype_t fstype, char **rstr)
    842 {
    843         const char *sfstype;
    844         char *s;
    845 
    846         sfstype = NULL;
    847         switch (fstype) {
    848         case fs_exfat:
    849                 sfstype = "ExFAT";
    850                 break;
    851         case fs_fat:
    852                 sfstype = "FAT";
    853                 break;
    854         case fs_minix:
    855                 sfstype = "MINIX";
    856                 break;
    857         case fs_ext4:
    858                 sfstype = "Ext4";
    859                 break;
    860         case fs_cdfs:
    861                 sfstype = "ISO 9660";
    862                 break;
    863         }
    864 
    865         s = str_dup(sfstype);
    866         if (s == NULL)
    867                 return ENOMEM;
    868 
    869         *rstr = s;
    870         return EOK;
    871 }
    872 
    873 errno_t fdisk_pkind_format(label_pkind_t pkind, char **rstr)
    874 {
    875         const char *spkind;
    876         char *s;
    877 
    878         spkind = NULL;
    879         switch (pkind) {
    880         case lpk_primary:
    881                 spkind = "Primary";
    882                 break;
    883         case lpk_extended:
    884                 spkind = "Extended";
    885                 break;
    886         case lpk_logical:
    887                 spkind = "Logical";
    888                 break;
    889         }
    890 
    891         s = str_dup(spkind);
    892         if (s == NULL)
    893                 return ENOMEM;
    894 
    895         *rstr = s;
    896         return EOK;
    897 }
    898 
    899815/** Get free partition index. */
    900816static errno_t fdisk_part_get_free_idx(fdisk_dev_t *dev, int *rindex)

  • uspace/srv/volsrv/part.c

    r5f36841 rdb9c889  
    155155                return;
    156156
     157        free(part->cur_mp);
    157158        free(part->svc_name);
    158159        free(part);
    … …  
    219220}
    220221
    221 static int vol_part_mount(vol_part_t *part)
     222static errno_t vol_part_mount(vol_part_t *part)
    222223{
    223224        char *mp;
    224         int rc;
     225        int err;
     226        errno_t rc;
    225227
    226228        if (str_size(part->label) < 1) {
    … …  
    231233
    232234        log_msg(LOG_DEFAULT, LVL_NOTE, "Determine MP label='%s'", part->label);
    233         rc = asprintf(&mp, "/vol/%s", part->label);
    234         if (rc < 0) {
    235                 log_msg(LOG_DEFAULT, LVL_NOTE, "rc -> %d", rc);
     235        err = asprintf(&mp, "/vol/%s", part->label);
     236        if (err < 0) {
     237                log_msg(LOG_DEFAULT, LVL_ERROR, "Out of memory");
    236238                return ENOMEM;
    237239        }
    … …  
    255257        log_msg(LOG_DEFAULT, LVL_NOTE, "Mount to %s -> %d\n", mp, rc);
    256258
    257         free(mp);
     259        part->cur_mp = mp;
     260        part->cur_mp_auto = true;
     261
    258262        return rc;
    259263}
    … …  
    381385
    382386        return ENOENT;
     387}
     388
     389errno_t vol_part_eject_part(vol_part_t *part)
     390{
     391        int rc;
     392
     393        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_eject_part()");
     394
     395        if (part->cur_mp == NULL) {
     396                log_msg(LOG_DEFAULT, LVL_DEBUG, "Attempt to mount unmounted "
     397                    "partition.");
     398                return EINVAL;
     399        }
     400
     401        rc = vfs_unmount_path(part->cur_mp);
     402        if (rc != EOK) {
     403                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed unmounting partition "
     404                    "from %s", part->cur_mp);
     405                return rc;
     406        }
     407
     408        if (part->cur_mp_auto) {
     409                rc = vfs_unlink_path(part->cur_mp);
     410                if (rc != EOK) {
     411                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed deleting "
     412                            "mount directory %s.", part->cur_mp);
     413                }
     414        }
     415
     416        free(part->cur_mp);
     417        part->cur_mp = NULL;
     418        part->cur_mp_auto = false;
     419
     420        return EOK;
    383421}
    384422
    … …  
    443481        pinfo->fstype = part->fstype;
    444482        str_cpy(pinfo->label, sizeof(pinfo->label), part->label);
     483        str_cpy(pinfo->cur_mp, sizeof(pinfo->cur_mp), part->cur_mp);
     484        pinfo->cur_mp_auto = part->cur_mp_auto;
    445485        return EOK;
    446486}

  • uspace/srv/volsrv/part.h

    r5f36841 rdb9c889  
    4848extern errno_t vol_part_get_ids(service_id_t *, size_t, size_t *);
    4949extern errno_t vol_part_find_by_id(service_id_t, vol_part_t **);
     50extern errno_t vol_part_eject_part(vol_part_t *);
    5051extern errno_t vol_part_empty_part(vol_part_t *);
    5152extern errno_t vol_part_mkfs_part(vol_part_t *, vol_fstype_t, const char *);

  • uspace/srv/volsrv/types/part.h

    r5f36841 rdb9c889  
    3939
    4040#include <adt/list.h>
     41#include <stdbool.h>
    4142#include <types/label.h>
    4243
    … …  
    5556        /** Volume label */
    5657        char *label;
     58        /** Where volume is currently mounted */
     59        char *cur_mp;
     60        /** Mounted at automatic mount point */
     61        bool cur_mp_auto;
    5762} vol_part_t;
    5863
Note: See TracChangeset for help on using the changeset viewer.