Changeset d3b2ffa in mainline


Ignore:
Timestamp:
2018-06-29T15:40:10Z (7 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5e904dd
Parents:
1e472ee (diff), 1a9174e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge volume management improvements (still WIP).

Files:
5 added
16 edited

Legend:

Unmodified
Added
Removed

  • .gitignore

    r1e472ee rd3b2ffa  
     1*.a
     2*.check.c
     3*.d
     4*.deflate
    15*.disasm
    2 *.deflate
    3 *.a
    4 *.o
    56*.la
    67*.lo
    78*.map
     9*.o
    810*.prev
     11*.pyc
    912*.so.*
    10 *.d
    11 *.pyc
    12 *.check.c
    13 tag
    14 tags
    15 common.h.new
    16 deps.mk
     13/Makefile.common
    1714/Makefile.config
    18 /Makefile.common
    19 autotool/
    20 boot/distroot/
    21 boot/initrd.img
    2215/common.h
    2316/config.h
    2417/cscope.out
    25 doxygen/doxygen.cfg
    26 doxygen/doxygen.cfg.gen
    27 doxygen/html/
    28 doxygen/latex/
    2918/hdisk.img
     19/image.boot
    3020/image.iso
    3121/uImage.bin
    32 /image.boot
     22autotool/
    3323boot/arch/arm32/_link.ld
    3424boot/arch/ia64/_link.ld
    … …  
    4030boot/components.zip
    4131boot/components_desc.c
     32boot/distroot/
    4233boot/image.bin
    4334boot/image.boot
    4435boot/image.raw
     36boot/initrd.img
     37common.h.new
     38deps.mk
     39doxygen/doxygen.cfg
     40doxygen/doxygen.cfg.gen
     41doxygen/html/
     42doxygen/latex/
     43kernel/arch/abs32le/_link.ld
    4544kernel/arch/amd64/_link.ld
    4645kernel/arch/arm32/_link.ld
    … …  
    5049kernel/arch/ppc32/_link.ld
    5150kernel/arch/sparc64/_link.ld
    52 kernel/arch/abs32le/_link.ld
    5351kernel/generic/src/debug/real_map.bin
    5452kernel/kernel.bin
    5553kernel/kernel.dump
    5654kernel/kernel.raw
     55tag
     56tags
     57tools/amd64-unknown-elf
     58tools/arm-linux-gnueabi
     59tools/binutils-*.tar.bz2
     60tools/downloads/
     61tools/gcc-*.tar.bz2
     62tools/gdb-*.tar.gz
     63tools/i686-pc-linux-gnu
     64tools/ia64-pc-linux-gnu
     65tools/mips-linux-gnu
     66tools/mips64el-linux-gnu
     67tools/mipsel-linux-gnu
     68tools/ppc-linux-gnu
     69tools/ppc64-linux-gnu
     70tools/riscv64-unknown-linux-gnu
     71tools/sparc64-linux-gnu
     72tools/sycek/
    5773uspace/app/barber/barber
    5874uspace/app/barber/images.c
    … …  
    130146uspace/app/vlaunch/images_desc.c
    131147uspace/app/vlaunch/vlaunch
     148uspace/app/vol/vol
    132149uspace/app/vterm/vterm
    133150uspace/app/vuhid/vuh
    … …  
    135152uspace/app/websrv/websrv
    136153uspace/app/wifi_supplicant/wifi_supplicant
     154uspace/dist/app/
    137155uspace/dist/app/barber
    138156uspace/dist/app/bdsh
    … …  
    206224uspace/dist/demo.wav
    207225uspace/dist/demo.xm
     226uspace/dist/drv/
    208227uspace/dist/drv/ahci/
    209228uspace/dist/drv/apic/
    … …  
    217236uspace/dist/drv/i8042/
    218237uspace/dist/drv/i8259/
     238uspace/dist/drv/icp-ic/
    219239uspace/dist/drv/icp/
    220 uspace/dist/drv/icp-ic/
    221240uspace/dist/drv/isa/
    222241uspace/dist/drv/kfb/
    … …  
    248267uspace/dist/drv/vhc/
    249268uspace/dist/drv/virt/
     269uspace/dist/drv/xhci/
    250270uspace/dist/drv/xtkbd/
    251 uspace/dist/drv/xhci/
     271uspace/dist/inc/
    252272uspace/dist/inc/_link.ld
    253273uspace/dist/inc/c/
    254274uspace/dist/logo.tga
    255 uspace/dist/app/
    256 uspace/dist/drv/
    257 uspace/dist/inc/
    258275uspace/dist/srv/
    259276uspace/dist/test/
    … …  
    275292uspace/drv/bus/usb/usbmid/usbmid
    276293uspace/drv/bus/usb/vhc/vhc
     294uspace/drv/bus/usb/xhci/test-xhci
    277295uspace/drv/bus/usb/xhci/xhci
    278 uspace/drv/bus/usb/xhci/test-xhci
    279296uspace/drv/char/i8042/i8042
    280297uspace/drv/char/msim-con/msim-con
    … …  
    289306uspace/drv/hid/adb-mouse/adb-mouse
    290307uspace/drv/hid/atkbd/atkbd
    291 uspace/drv/hid/xtkbd/xtkbd
    292308uspace/drv/hid/ps2mouse/ps2mouse
    293309uspace/drv/hid/usbhid/usbhid
     310uspace/drv/hid/xtkbd/xtkbd
    294311uspace/drv/intctl/apic/apic
    295312uspace/drv/intctl/i8259/i8259
    … …  
    317334uspace/drv/test/test3/test3
    318335uspace/drv/time/cmos-rtc/cmos-rtc
     336uspace/lib/c/arch/abs32le/_link-dlexe.ld
     337uspace/lib/c/arch/abs32le/_link-loader.ld
     338uspace/lib/c/arch/abs32le/_link-shlib.ld
     339uspace/lib/c/arch/abs32le/_link.ld
    319340uspace/lib/c/arch/amd64/_link-dlexe.ld
    320341uspace/lib/c/arch/amd64/_link-loader.ld
    … …  
    349370uspace/lib/c/arch/sparc64/_link-shlib.ld
    350371uspace/lib/c/arch/sparc64/_link.ld
    351 uspace/lib/c/arch/abs32le/_link-dlexe.ld
    352 uspace/lib/c/arch/abs32le/_link-loader.ld
    353 uspace/lib/c/arch/abs32le/_link-shlib.ld
    354 uspace/lib/c/arch/abs32le/_link.ld
    355372uspace/lib/c/test-libc
    356373uspace/lib/label/test-liblabel
    … …  
    409426uspace/srv/vfs/vfs
    410427uspace/srv/volsrv/volsrv
    411 tools/amd64-unknown-elf
    412 tools/arm-linux-gnueabi
    413 tools/i686-pc-linux-gnu
    414 tools/ia64-pc-linux-gnu
    415 tools/mips-linux-gnu
    416 tools/mips64el-linux-gnu
    417 tools/mipsel-linux-gnu
    418 tools/ppc-linux-gnu
    419 tools/ppc64-linux-gnu
    420 tools/riscv64-unknown-linux-gnu
    421 tools/sparc64-linux-gnu
    422 tools/binutils-*.tar.bz2
    423 tools/gcc-*.tar.bz2
    424 tools/gdb-*.tar.gz
    425 tools/sycek/
    426 tools/downloads/

  • boot/Makefile.common

    r1e472ee rd3b2ffa  
    217217        $(USPACE_PATH)/app/untar/untar \
    218218        $(USPACE_PATH)/app/usbinfo/usbinfo \
     219        $(USPACE_PATH)/app/vol/vol \
    219220        $(USPACE_PATH)/app/vuhid/vuh \
    220221        $(USPACE_PATH)/app/mkbd/mkbd \

  • uspace/Makefile

    r1e472ee rd3b2ffa  
    7979        app/untar \
    8080        app/usbinfo \
     81        app/vol \
    8182        app/vuhid \
    8283        app/nic \

  • uspace/app/fdisk/fdisk.c

    r1e472ee rd3b2ffa  
    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/app/sysinst/sysinst.c

    r1e472ee rd3b2ffa  
    6969#define MOUNT_POINT "/inst"
    7070
    71 /** Device containing HelenOS live CD */
    72 #define CD_DEV "devices/\\hw\\pci0\\00:01.0\\ata-c2\\d0"
    73 
    74 #define CD_FS_TYPE "cdfs"
    75 #define CD_FS_SRV "/srv/cdfs"
    76 #define CD_MOUNT_POINT "/cdrom"
    77 
    78 #define BOOT_FILES_SRC "/cdrom"
     71/** HelenOS live CD volume label */
     72#define CD_VOL_LABEL "HelenOS-CD"
     73#define CD_MOUNT_POINT "/vol/" CD_VOL_LABEL
     74
     75#define BOOT_FILES_SRC CD_MOUNT_POINT
    7976#define BOOT_BLOCK_IDX 0 /* MBR */
    8077
    … …  
    196193static errno_t sysinst_copy_boot_files(void)
    197194{
    198         task_wait_t twait;
    199         task_exit_t texit;
    200         errno_t rc;
    201         int trc;
    202 
    203         printf("sysinst_copy_boot_files(): start filesystem server\n");
    204         rc = task_spawnl(NULL, &twait, CD_FS_SRV, CD_FS_SRV, NULL);
    205         if (rc != EOK)
    206                 return rc;
    207 
    208         printf("sysinst_copy_boot_files(): wait for filesystem server\n");
    209         rc = task_wait(&twait, &texit, &trc);
    210         if (rc != EOK)
    211                 return rc;
    212 
    213         printf("sysinst_copy_boot_files(): verify filesystem server result\n");
    214         if (texit != TASK_EXIT_NORMAL || trc != 0) {
    215                 printf("sysinst_fs_mount(): not successful, but could be already loaded.\n");
    216         }
    217 
    218         printf("sysinst_copy_boot_files(): create CD mount point\n");
    219         rc = vfs_link_path(CD_MOUNT_POINT, KIND_DIRECTORY, NULL);
    220         if (rc != EOK)
    221                 return rc;
    222 
    223         printf("sysinst_copy_boot_files(): mount CD filesystem\n");
    224         rc = vfs_mount_path(CD_MOUNT_POINT, CD_FS_TYPE, CD_DEV, "", 0, 0);
    225         if (rc != EOK)
    226                 return rc;
     195        errno_t rc;
    227196
    228197        printf("sysinst_copy_boot_files(): copy bootloader files\n");

  • uspace/lib/c/Makefile

    r1e472ee rd3b2ffa  
    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

    r1e472ee rd3b2ffa  
    235235}
    236236
     237/** Unmount partition (and possibly eject the media). */
     238errno_t vol_part_eject(vol_t *vol, service_id_t sid)
     239{
     240        async_exch_t *exch;
     241        errno_t retval;
     242
     243        exch = async_exchange_begin(vol->sess);
     244        retval = async_req_1_0(exch, VOL_PART_EJECT, sid);
     245        async_exchange_end(exch);
     246
     247        if (retval != EOK)
     248                return retval;
     249
     250        return EOK;
     251}
     252
    237253/** Erase partition (to the extent where we will consider it not containing
    238254 * a file system.
    … …  
    304320}
    305321
     322/** Format file system type as string.
     323 *
     324 * @param fstype File system type
     325 * @param rstr Place to store pointer to newly allocated string
     326 * @return EOK on success, ENOMEM if out of memory
     327 */
     328errno_t vol_fstype_format(vol_fstype_t fstype, char **rstr)
     329{
     330        const char *sfstype;
     331        char *s;
     332
     333        sfstype = NULL;
     334        switch (fstype) {
     335        case fs_exfat:
     336                sfstype = "ExFAT";
     337                break;
     338        case fs_fat:
     339                sfstype = "FAT";
     340                break;
     341        case fs_minix:
     342                sfstype = "MINIX";
     343                break;
     344        case fs_ext4:
     345                sfstype = "Ext4";
     346                break;
     347        case fs_cdfs:
     348                sfstype = "ISO 9660";
     349                break;
     350        }
     351
     352        s = str_dup(sfstype);
     353        if (s == NULL)
     354                return ENOMEM;
     355
     356        *rstr = s;
     357        return EOK;
     358}
     359
     360/** Format partition content / file system type as string.
     361 *
     362 * @param pcnt Partition content
     363 * @param fstype File system type
     364 * @param rstr Place to store pointer to newly allocated string
     365 * @return EOK on success, ENOMEM if out of memory
     366 */
     367errno_t vol_pcnt_fs_format(vol_part_cnt_t pcnt, vol_fstype_t fstype,
     368    char **rstr)
     369{
     370        int rc;
     371        char *s = NULL;
     372
     373        switch (pcnt) {
     374        case vpc_empty:
     375                s = str_dup("Empty");
     376                if (s == NULL)
     377                        return ENOMEM;
     378                break;
     379        case vpc_fs:
     380                rc = vol_fstype_format(fstype, &s);
     381                if (rc != EOK)
     382                        return ENOMEM;
     383                break;
     384        case vpc_unknown:
     385                s = str_dup("Unknown");
     386                if (s == NULL)
     387                        return ENOMEM;
     388                break;
     389        }
     390
     391        assert(s != NULL);
     392        *rstr = s;
     393        return EOK;
     394}
     395
    306396/** @}
    307397 */

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

    r1e472ee rd3b2ffa  
    4242        VOL_PART_ADD,
    4343        VOL_PART_INFO,
     44        VOL_PART_EJECT,
    4445        VOL_PART_EMPTY,
    4546        VOL_PART_LSUPP,
    46         VOL_PART_MKFS,
     47        VOL_PART_MKFS
    4748} vol_request_t;
    4849

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

    r1e472ee rd3b2ffa  
    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

    r1e472ee rd3b2ffa  
    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

    r1e472ee rd3b2ffa  
    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

    r1e472ee rd3b2ffa  
    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

    r1e472ee rd3b2ffa  
    5151
    5252static errno_t vol_part_add_locked(service_id_t);
     53static void vol_part_remove_locked(vol_part_t *);
     54static errno_t vol_part_find_by_id_ref_locked(service_id_t, vol_part_t **);
     55
    5356static LIST_INITIALIZE(vol_parts); /* of vol_part_t */
    5457static FIBRIL_MUTEX_INITIALIZE(vol_parts_lock);
    … …  
    6871};
    6972
    70 /** Check for new partitions */
     73static const char *fstype_str(vol_fstype_t fstype)
     74{
     75        struct fsname_type *fst;
     76
     77        fst = &fstab[0];
     78        while (fst->name != NULL) {
     79                if (fst->fstype == fstype)
     80                        return fst->name;
     81                ++fst;
     82        }
     83
     84        assert(false);
     85        return NULL;
     86}
     87
     88/** Check for new and removed partitions */
    7189static errno_t vol_part_check_new(void)
    7290{
    7391        bool already_known;
     92        bool still_exists;
    7493        category_id_t part_cat;
    7594        service_id_t *svcs;
    7695        size_t count, i;
     96        link_t *cur, *next;
     97        vol_part_t *part;
    7798        errno_t rc;
    7899
    … …  
    94115        }
    95116
     117        /* Check for new partitions */
    96118        for (i = 0; i < count; i++) {
    97119                already_known = false;
    98120
     121                // XXX Make this faster
    99122                list_foreach(vol_parts, lparts, vol_part_t, part) {
    100123                        if (part->svc_id == svcs[i]) {
    … …  
    115138        }
    116139
     140        /* Check for removed partitions */
     141        cur = list_first(&vol_parts);
     142        while (cur != NULL) {
     143                next = list_next(cur, &vol_parts);
     144                part = list_get_instance(cur, vol_part_t, lparts);
     145
     146                still_exists = false;
     147                // XXX Make this faster
     148                for (i = 0; i < count; i++) {
     149                        if (part->svc_id == svcs[i]) {
     150                                still_exists = true;
     151                                break;
     152                        }
     153                }
     154
     155                if (!still_exists) {
     156                        log_msg(LOG_DEFAULT, LVL_NOTE, "Partition '%zu' is gone",
     157                            part->svc_id);
     158                        vol_part_remove_locked(part);
     159                }
     160
     161                cur = next;
     162        }
     163
     164        free(svcs);
     165
    117166        fibril_mutex_unlock(&vol_parts_lock);
    118167        return EOK;
    … …  
    129178        }
    130179
     180        atomic_set(&part->refcnt, 1);
    131181        link_initialize(&part->lparts);
    132182        part->pcnt = vpc_empty;
    … …  
    137187static void vol_part_delete(vol_part_t *part)
    138188{
     189        log_msg(LOG_DEFAULT, LVL_ERROR, "Freeing partition %p", part);
    139190        if (part == NULL)
    140191                return;
    141192
     193        free(part->cur_mp);
    142194        free(part->svc_name);
    143195        free(part);
    … …  
    204256}
    205257
     258static errno_t vol_part_mount(vol_part_t *part)
     259{
     260        char *mp;
     261        int err;
     262        errno_t rc;
     263
     264        if (str_size(part->label) < 1) {
     265                /* Don't mount nameless volumes */
     266                log_msg(LOG_DEFAULT, LVL_NOTE, "Not mounting nameless partition.");
     267                return EOK;
     268        }
     269
     270        log_msg(LOG_DEFAULT, LVL_NOTE, "Determine MP label='%s'", part->label);
     271        err = asprintf(&mp, "/vol/%s", part->label);
     272        if (err < 0) {
     273                log_msg(LOG_DEFAULT, LVL_ERROR, "Out of memory");
     274                return ENOMEM;
     275        }
     276
     277        log_msg(LOG_DEFAULT, LVL_NOTE, "Create mount point '%s'", mp);
     278        rc = vfs_link_path(mp, KIND_DIRECTORY, NULL);
     279        if (rc != EOK) {
     280                log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating mount point '%s'",
     281                    mp);
     282                free(mp);
     283                return EIO;
     284        }
     285
     286        log_msg(LOG_DEFAULT, LVL_NOTE, "Call vfs_mount_path mp='%s' fstype='%s' svc_name='%s'",
     287            mp, fstype_str(part->fstype), part->svc_name);
     288        rc = vfs_mount_path(mp, fstype_str(part->fstype),
     289            part->svc_name, "", 0, 0);
     290        if (rc != EOK) {
     291                log_msg(LOG_DEFAULT, LVL_NOTE, "Failed mounting to %s", mp);
     292        }
     293        log_msg(LOG_DEFAULT, LVL_NOTE, "Mount to %s -> %d\n", mp, rc);
     294
     295        part->cur_mp = mp;
     296        part->cur_mp_auto = true;
     297
     298        return rc;
     299}
     300
    206301static errno_t vol_part_add_locked(service_id_t sid)
    207302{
    … …  
    210305
    211306        assert(fibril_mutex_is_locked(&vol_parts_lock));
     307        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_add_locked(%zu)", sid);
    212308
    213309        /* Check for duplicates */
    214         rc = vol_part_find_by_id(sid, &part);
    215         if (rc == EOK)
     310        rc = vol_part_find_by_id_ref_locked(sid, &part);
     311        if (rc == EOK) {
     312                vol_part_del_ref(part);
    216313                return EEXIST;
    217 
    218         log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_add_locked()");
     314        }
     315
     316        log_msg(LOG_DEFAULT, LVL_NOTE, "partition %zu is new", sid);
     317
    219318        part = vol_part_new();
    220319        if (part == NULL)
    … …  
    233332                goto error;
    234333
     334        rc = vol_part_mount(part);
     335        if (rc != EOK)
     336                goto error;
     337
    235338        list_append(&part->lparts, &vol_parts);
    236339
    … …  
    242345        vol_part_delete(part);
    243346        return rc;
     347}
     348
     349static void vol_part_remove_locked(vol_part_t *part)
     350{
     351        assert(fibril_mutex_is_locked(&vol_parts_lock));
     352        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_remove_locked(%zu)", part->svc_id);
     353
     354        list_remove(&part->lparts);
     355
     356        log_msg(LOG_DEFAULT, LVL_NOTE, "Removed partition.");
     357        vol_part_del_ref(part);
    244358}
    245359
    … …  
    308422}
    309423
    310 errno_t vol_part_find_by_id(service_id_t sid, vol_part_t **rpart)
    311 {
     424static errno_t vol_part_find_by_id_ref_locked(service_id_t sid,
     425    vol_part_t **rpart)
     426{
     427        assert(fibril_mutex_is_locked(&vol_parts_lock));
     428
    312429        list_foreach(vol_parts, lparts, vol_part_t, part) {
    313430                if (part->svc_id == sid) {
     431                        /* Add reference */
     432                        atomic_inc(&part->refcnt);
    314433                        *rpart = part;
    315                         /* XXX Add reference */
    316434                        return EOK;
    317435                }
    … …  
    319437
    320438        return ENOENT;
     439}
     440
     441errno_t vol_part_find_by_id_ref(service_id_t sid, vol_part_t **rpart)
     442{
     443        errno_t rc;
     444
     445        fibril_mutex_lock(&vol_parts_lock);
     446        rc = vol_part_find_by_id_ref_locked(sid, rpart);
     447        fibril_mutex_unlock(&vol_parts_lock);
     448
     449        return rc;
     450}
     451
     452void vol_part_del_ref(vol_part_t *part)
     453{
     454        if (atomic_predec(&part->refcnt) == 0)
     455                vol_part_delete(part);
     456}
     457
     458errno_t vol_part_eject_part(vol_part_t *part)
     459{
     460        int rc;
     461
     462        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_eject_part()");
     463
     464        if (part->cur_mp == NULL) {
     465                log_msg(LOG_DEFAULT, LVL_DEBUG, "Attempt to mount unmounted "
     466                    "partition.");
     467                return EINVAL;
     468        }
     469
     470        rc = vfs_unmount_path(part->cur_mp);
     471        if (rc != EOK) {
     472                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed unmounting partition "
     473                    "from %s", part->cur_mp);
     474                return rc;
     475        }
     476
     477        if (part->cur_mp_auto) {
     478                rc = vfs_unlink_path(part->cur_mp);
     479                if (rc != EOK) {
     480                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed deleting "
     481                            "mount directory %s.", part->cur_mp);
     482                }
     483        }
     484
     485        free(part->cur_mp);
     486        part->cur_mp = NULL;
     487        part->cur_mp_auto = false;
     488
     489        return EOK;
    321490}
    322491
    … …  
    366535        }
    367536
     537        rc = vol_part_mount(part);
     538        if (rc != EOK) {
     539                fibril_mutex_unlock(&vol_parts_lock);
     540                return rc;
     541        }
     542
    368543        fibril_mutex_unlock(&vol_parts_lock);
    369544        return EOK;
    … …  
    372547errno_t vol_part_get_info(vol_part_t *part, vol_part_info_t *pinfo)
    373548{
     549        memset(pinfo, 0, sizeof(*pinfo));
     550
    374551        pinfo->pcnt = part->pcnt;
    375552        pinfo->fstype = part->fstype;
    376553        str_cpy(pinfo->label, sizeof(pinfo->label), part->label);
     554        if (part->cur_mp != NULL)
     555                str_cpy(pinfo->cur_mp, sizeof(pinfo->cur_mp), part->cur_mp);
     556        pinfo->cur_mp_auto = part->cur_mp_auto;
    377557        return EOK;
    378558}

  • uspace/srv/volsrv/part.h

    r1e472ee rd3b2ffa  
    4747extern errno_t vol_part_add(service_id_t);
    4848extern errno_t vol_part_get_ids(service_id_t *, size_t, size_t *);
    49 extern errno_t vol_part_find_by_id(service_id_t, vol_part_t **);
     49extern errno_t vol_part_find_by_id_ref(service_id_t, vol_part_t **);
     50extern void vol_part_del_ref(vol_part_t *);
     51extern errno_t vol_part_eject_part(vol_part_t *);
    5052extern errno_t vol_part_empty_part(vol_part_t *);
    5153extern errno_t vol_part_mkfs_part(vol_part_t *, vol_fstype_t, const char *);

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

    r1e472ee rd3b2ffa  
    3939
    4040#include <adt/list.h>
     41#include <atomic.h>
     42#include <stdbool.h>
    4143#include <types/label.h>
    4244
    … …  
    4547        /** Link to vol_parts */
    4648        link_t lparts;
     49        /** Reference count */
     50        atomic_t refcnt;
    4751        /** Service ID */
    4852        service_id_t svc_id;
    … …  
    5559        /** Volume label */
    5660        char *label;
     61        /** Where volume is currently mounted */
     62        char *cur_mp;
     63        /** Mounted at automatic mount point */
     64        bool cur_mp_auto;
    5765} vol_part_t;
    5866

  • uspace/srv/volsrv/volsrv.c

    r1e472ee rd3b2ffa  
    144144        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_info_srv(%zu)",
    145145            sid);
    146         rc = vol_part_find_by_id(sid, &part);
     146        rc = vol_part_find_by_id_ref(sid, &part);
    147147        if (rc != EOK) {
    148148                async_answer_0(icall_handle, ENOENT);
    … …  
    153153        if (rc != EOK) {
    154154                async_answer_0(icall_handle, EIO);
    155                 return;
     155                goto error;
    156156        }
    157157
    … …  
    161161                async_answer_0(chandle, EREFUSED);
    162162                async_answer_0(icall_handle, EREFUSED);
    163                 return;
     163                goto error;
    164164        }
    165165
    … …  
    167167                async_answer_0(chandle, EINVAL);
    168168                async_answer_0(icall_handle, EINVAL);
    169                 return;
     169                goto error;
    170170        }
    171171
    … …  
    175175                async_answer_0(chandle, rc);
    176176                async_answer_0(icall_handle, rc);
    177                 return;
    178         }
    179 
    180         async_answer_0(icall_handle, EOK);
     177                goto error;
     178        }
     179
     180        async_answer_0(icall_handle, EOK);
     181error:
     182        vol_part_del_ref(part);
     183}
     184
     185static void vol_part_eject_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     186{
     187        service_id_t sid;
     188        vol_part_t *part;
     189        errno_t rc;
     190
     191        sid = IPC_GET_ARG1(*icall);
     192        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_eject_srv(%zu)", sid);
     193
     194        rc = vol_part_find_by_id_ref(sid, &part);
     195        if (rc != EOK) {
     196                async_answer_0(icall_handle, ENOENT);
     197                goto error;
     198        }
     199
     200        rc = vol_part_eject_part(part);
     201        if (rc != EOK) {
     202                async_answer_0(icall_handle, EIO);
     203                goto error;
     204        }
     205
     206        async_answer_0(icall_handle, EOK);
     207error:
     208        vol_part_del_ref(part);
    181209}
    182210
    … …  
    190218        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_empty_srv(%zu)", sid);
    191219
    192         rc = vol_part_find_by_id(sid, &part);
     220        rc = vol_part_find_by_id_ref(sid, &part);
    193221        if (rc != EOK) {
    194222                async_answer_0(icall_handle, ENOENT);
    … …  
    199227        if (rc != EOK) {
    200228                async_answer_0(icall_handle, EIO);
    201                 return;
    202         }
    203 
    204         async_answer_0(icall_handle, EOK);
     229                goto error;
     230        }
     231
     232        async_answer_0(icall_handle, EOK);
     233error:
     234        vol_part_del_ref(part);
    205235}
    206236
    … …  
    251281        errno_t rc;
    252282
     283        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_mkfs_srv()");
     284
    253285        sid = IPC_GET_ARG1(*icall);
    254286        fstype = IPC_GET_ARG2(*icall);
    … …  
    261293        }
    262294
    263         printf("vol_part_mkfs_srv: label=%p\n", label);
    264         if (label != NULL)
    265                 printf("vol_part_mkfs_srv: label='%s'\n", label);
    266 
    267         rc = vol_part_find_by_id(sid, &part);
     295        if (label != NULL) {
     296                log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_mkfs_srv: label='%s'",
     297                    label);
     298        }
     299
     300        rc = vol_part_find_by_id_ref(sid, &part);
    268301        if (rc != EOK) {
    269302                free(label);
    … …  
    276309                free(label);
    277310                async_answer_0(icall_handle, rc);
     311                vol_part_del_ref(part);
    278312                return;
    279313        }
    … …  
    311345                        vol_part_info_srv(chandle, &call);
    312346                        break;
     347                case VOL_PART_EJECT:
     348                        vol_part_eject_srv(chandle, &call);
     349                        break;
    313350                case VOL_PART_EMPTY:
    314351                        vol_part_empty_srv(chandle, &call);
Note: See TracChangeset for help on using the changeset viewer.