source: mainline/uspace/srv/volsrv/volume.c

/*
 * Copyright (c) 2024 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup volsrv
 * @{
 */
/**
 * @file Volume handling
 * @brief
 *
 * Volumes are the file systems (or similar) contained in partitions.
 * Each vol_volume_t can be considered the configuration entry
 * for a volume. Each partition has an associated vol_volume_t.
 *
 * If there is any non-default configuration to be remembered for a
 * volume, the vol_volume_t structure is kept around even after the partition
 * is disassociated from it. Otherwise it is deleted once no longer
 * referenced.
 */

#include <adt/list.h>
#include <errno.h>
#include <fibril_synch.h>
#include <io/log.h>
#include <sif.h>
#include <stdbool.h>
#include <stdlib.h>
#include <str.h>

#include "volume.h"
#include "types/volume.h"

static void vol_volume_delete(vol_volume_t *);
static void vol_volume_add_locked(vol_volumes_t *, vol_volume_t *);
static errno_t vol_volume_lookup_ref_locked(vol_volumes_t *, const char *,
    vol_volume_t **);
static errno_t vol_volumes_load(sif_node_t *, vol_volumes_t *);
static errno_t vol_volumes_save(vol_volumes_t *, sif_node_t *);

/** Allocate new volume structure.
 *
 * @return Pointer to new volume structure
 */
static vol_volume_t *vol_volume_new(void)
{
        vol_volume_t *volume = calloc(1, sizeof(vol_volume_t));

        if (volume == NULL) {
                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating volume "
                    "structure. Out of memory.");
                return NULL;
        }

        volume->label = str_dup("");
        volume->mountp = str_dup("");

        if (volume->label == NULL || volume->mountp == NULL) {
                vol_volume_delete(volume);
                return NULL;
        }

        refcount_init(&volume->refcnt);
        link_initialize(&volume->lvolumes);
        volume->volumes = NULL;

        return volume;
}

/** Delete volume structure.
 *
 * @param volume Volume structure
 */
static void vol_volume_delete(vol_volume_t *volume)
{
        log_msg(LOG_DEFAULT, LVL_DEBUG, "Freeing volume %p", volume);

        free(volume->label);
        free(volume->mountp);
        free(volume);
}

/** Create list of volumes.
 *
 * @param cfg_path Path to file containing configuration repository in SIF
 * @param rvolumes Place to store pointer to list of volumes.
 * @return EOK on success, ENOMEM if out of memory
 */
errno_t vol_volumes_create(const char *cfg_path,
    vol_volumes_t **rvolumes)
{
        vol_volumes_t *volumes;
        sif_doc_t *doc = NULL;
        sif_node_t *node;
        sif_node_t *nvolumes;
        const char *ntype;
        errno_t rc;

        volumes = calloc(1, sizeof(vol_volumes_t));
        if (volumes == NULL)
                return ENOMEM;

        volumes->cfg_path = str_dup(cfg_path);
        if (volumes->cfg_path == NULL) {
                rc = ENOMEM;
                goto error;
        }

        fibril_mutex_initialize(&volumes->lock);
        list_initialize(&volumes->volumes);
        volumes->next_id = 1;

        /* Try opening existing repository */
        rc = sif_load(cfg_path, &doc);
        if (rc != EOK) {
                /* Failed to open existing, create new repository */
                rc = sif_new(&doc);
                if (rc != EOK)
                        goto error;

                /* Create 'volumes' node. */
                rc = sif_node_append_child(sif_get_root(doc), "volumes",
                    &nvolumes);
                if (rc != EOK)
                        goto error;

                rc = sif_save(doc, cfg_path);
                if (rc != EOK)
                        goto error;

                sif_delete(doc);
        } else {
                /*
                 * Loaded existing configuration. Find 'volumes' node, should
                 * be the first child of the root node.
                 */
                node = sif_node_first_child(sif_get_root(doc));

                /* Verify it's the correct node type */
                ntype = sif_node_get_type(node);
                if (str_cmp(ntype, "volumes") != 0) {
                        rc = EIO;
                        goto error;
                }

                rc = vol_volumes_load(node, volumes);
                if (rc != EOK)
                        goto error;

                sif_delete(doc);
        }

        *rvolumes = volumes;
        return EOK;
error:
        if (doc != NULL)
                (void) sif_delete(doc);
        if (volumes != NULL && volumes->cfg_path != NULL)
                free(volumes->cfg_path);
        if (volumes != NULL)
                free(volumes);

        return rc;
}

/** Merge list of volumes into new file.
 *
 * @param volumes List of volumes
 * @param cfg_path Path to file containing configuration repository in SIF
 * @return EOK on success, ENOMEM if out of memory
 */
errno_t vol_volumes_merge_to(vol_volumes_t *volumes, const char *cfg_path)
{
        sif_doc_t *doc = NULL;
        sif_node_t *node;
        const char *ntype;
        char *dcfg_path;
        errno_t rc;

        dcfg_path = str_dup(cfg_path);
        if (dcfg_path == NULL) {
                rc = ENOMEM;
                goto error;
        }

        free(volumes->cfg_path);
        volumes->cfg_path = dcfg_path;

        /* Try opening existing repository */
        rc = sif_load(cfg_path, &doc);
        if (rc != EOK) {
                /* Failed to open existing, create new repository */
                rc = vol_volumes_sync(volumes);
                if (rc != EOK)
                        goto error;
        } else {
                /*
                 * Loaded existing configuration. Find 'volumes' node, should
                 * be the first child of the root node.
                 */
                node = sif_node_first_child(sif_get_root(doc));

                /* Verify it's the correct node type */
                ntype = sif_node_get_type(node);
                if (str_cmp(ntype, "volumes") != 0) {
                        rc = EIO;
                        goto error;
                }

                rc = vol_volumes_load(node, volumes);
                if (rc != EOK)
                        goto error;

                sif_delete(doc);
        }

        return EOK;
error:
        if (doc != NULL)
                (void) sif_delete(doc);
        return rc;
}

/** Sync volume configuration to config file.
 *
 * @param volumes List of volumes
 * @return EOK on success, ENOMEM if out of memory
 */
errno_t vol_volumes_sync(vol_volumes_t *volumes)
{
        sif_doc_t *doc = NULL;
        errno_t rc;

        rc = sif_new(&doc);
        if (rc != EOK)
                goto error;

        rc = vol_volumes_save(volumes, sif_get_root(doc));
        if (rc != EOK)
                goto error;

        rc = sif_save(doc, volumes->cfg_path);
        if (rc != EOK)
                goto error;

        sif_delete(doc);
        return EOK;
error:
        if (doc != NULL)
                (void) sif_delete(doc);
        return rc;
}

/** Destroy list of volumes.
 *
 * @param volumes List of volumes or @c NULL
 */
void vol_volumes_destroy(vol_volumes_t *volumes)
{
        link_t *link;
        vol_volume_t *volume;

        if (volumes == NULL)
                return;

        link = list_first(&volumes->volumes);
        while (link != NULL) {
                volume = list_get_instance(link, vol_volume_t, lvolumes);

                list_remove(&volume->lvolumes);
                vol_volume_delete(volume);

                link = list_first(&volumes->volumes);
        }

        free(volumes->cfg_path);
        free(volumes);
}

/** Add new volume structure to list of volumes.
 *
 * @param volumes List of volumes
 * @param volume Volume structure
 */
static void vol_volume_add_locked(vol_volumes_t *volumes,
    vol_volume_t *volume)
{
        assert(fibril_mutex_is_locked(&volumes->lock));
        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_volume_add_locked(%p)", volume);

        volume->volumes = volumes;
        list_append(&volume->lvolumes, &volumes->volumes);
        volume->id.id = volumes->next_id;
        ++volumes->next_id;
}

/** Look up volume structure with locked volumes lock.
 *
 * If a matching existing volume is found, it is returned. Otherwise
 * a new volume structure is created.
 *
 * @param volumes List of volumes
 * @param label Volume label
 * @param rvolume Place to store pointer to volume structure (existing or new)
 *
 * @return EOK on success, ENOMEM if out of memory
 */
static errno_t vol_volume_lookup_ref_locked(vol_volumes_t *volumes,
    const char *label, vol_volume_t **rvolume)
{
        vol_volume_t *volume;

        assert(fibril_mutex_is_locked(&volumes->lock));

        list_foreach(volumes->volumes, lvolumes, vol_volume_t, volume) {
                if (str_cmp(volume->label, label) == 0 &&
                    str_size(label) > 0) {
                        /* Add reference */
                        refcount_up(&volume->refcnt);
                        *rvolume = volume;
                        return EOK;
                }
        }

        /* No existing volume found. Create a new one. */
        volume = vol_volume_new();
        if (volume == NULL)
                return ENOMEM;

        free(volume->label);
        volume->label = str_dup(label);

        if (volume->label == NULL) {
                vol_volume_delete(volume);
                return ENOMEM;
        }

        vol_volume_add_locked(volumes, volume);

        *rvolume = volume;
        return EOK;
}

/** Look up volume structure.
 *
 * If a matching existing volume is found, it is returned. Otherwise
 * a new volume structure is created.
 *
 * @param volumes List of volumes
 * @param label Volume label
 * @param rvolume Place to store pointer to volume structure (existing or new)
 *
 * @return EOK on success, ENOMEM if out of memory
 */
errno_t vol_volume_lookup_ref(vol_volumes_t *volumes, const char *label,
    vol_volume_t **rvolume)
{
        errno_t rc;

        fibril_mutex_lock(&volumes->lock);
        rc = vol_volume_lookup_ref_locked(volumes, label, rvolume);
        fibril_mutex_unlock(&volumes->lock);

        return rc;
}

/** Find volume structure by ID with locked volumes lock.
 * *
 * @param volumes List of volumes
 * @param vid Volume ID
 * @param rvolume Place to store pointer to volume structure (existing or new)
 *
 * @return EOK on success, ENOENT if not found
 */
static errno_t vol_volume_find_by_id_ref_locked(vol_volumes_t *volumes,
    volume_id_t vid, vol_volume_t **rvolume)
{
        assert(fibril_mutex_is_locked(&volumes->lock));

        list_foreach(volumes->volumes, lvolumes, vol_volume_t, volume) {
                log_msg(LOG_DEFAULT, LVL_DEBUG2,
                    "vol_volume_find_by_id_ref_locked(%zu==%zu)?",
                    volume->id.id, vid.id);
                if (volume->id.id == vid.id) {
                        log_msg(LOG_DEFAULT, LVL_DEBUG2,
                            "vol_volume_find_by_id_ref_locked: found");
                        /* Add reference */
                        refcount_up(&volume->refcnt);
                        *rvolume = volume;
                        return EOK;
                }
        }

        log_msg(LOG_DEFAULT, LVL_DEBUG2,
            "vol_volume_find_by_id_ref_locked: not found");
        return ENOENT;
}

/** Find volume by ID.
 *
 * @param volumes Volumes
 * @param vid Volume ID
 * @param rvolume Place to store pointer to volume, with reference count
 *                increased.
 * @return EOK on success or an error code
 */
errno_t vol_volume_find_by_id_ref(vol_volumes_t *volumes, volume_id_t vid,
    vol_volume_t **rvolume)
{
        errno_t rc;

        fibril_mutex_lock(&volumes->lock);
        rc = vol_volume_find_by_id_ref_locked(volumes, vid, rvolume);
        fibril_mutex_unlock(&volumes->lock);

        return rc;
}

/** Determine if volume has non-default settings that need to persist.
 *
 * @param volume Volume
 * @return @c true iff volume has settings that need to persist
 */
static bool vol_volume_is_persist(vol_volume_t *volume)
{
        return str_size(volume->mountp) > 0;
}

/** Delete reference to volume.
 *
 * @param volume Volume
 */
void vol_volume_del_ref(vol_volume_t *volume)
{
        if (refcount_down(&volume->refcnt)) {
                /* No more references. Check if volume is persistent. */
                list_remove(&volume->lvolumes);
                vol_volume_delete(volume);
        }
}

/** Set volume mount point.
 *
 * @param volume Volume
 * @param mountp Mount point
 *
 * @return EOK on success or error code
 */
errno_t vol_volume_set_mountp(vol_volume_t *volume, const char *mountp)
{
        char *mp;
        char *old_mp;
        bool was_persist;

        mp = str_dup(mountp);
        if (mp == NULL)
                return ENOMEM;

        was_persist = vol_volume_is_persist(volume);

        old_mp = volume->mountp;
        volume->mountp = mp;

        if (vol_volume_is_persist(volume)) {
                if (!was_persist) {
                        /*
                         * Volume is now persistent. Prevent it from being
                         * freed.
                         */
                        refcount_up(&volume->refcnt);
                }
        } else {
                if (was_persist) {
                        /*
                         * Volume is now non-persistent
                         * Allow volume to be freed.
                         */
                        vol_volume_del_ref(volume);
                }
        }

        vol_volumes_sync(volume->volumes);
        free(old_mp);
        return EOK;
}

/** Get list of volume IDs.
 *
 * Get the list of IDs of all persistent volumes (volume configuration
 * entries).
 *
 * @param volumes Volumes
 * @param id_buf Buffer to hold the IDs
 * @param buf_size Buffer size in bytes
 * @param act_size Place to store actual number bytes needed
 * @return EOK on success or an error code
 */
errno_t vol_get_ids(vol_volumes_t *volumes, volume_id_t *id_buf,
    size_t buf_size, size_t *act_size)
{
        size_t act_cnt;
        size_t buf_cnt;

        fibril_mutex_lock(&volumes->lock);

        buf_cnt = buf_size / sizeof(volume_id_t);

        act_cnt = 0;
        list_foreach(volumes->volumes, lvolumes, vol_volume_t, volume) {
                if (vol_volume_is_persist(volume))
                        ++act_cnt;
        }
        *act_size = act_cnt * sizeof(volume_id_t);

        if (buf_size % sizeof(volume_id_t) != 0) {
                fibril_mutex_unlock(&volumes->lock);
                return EINVAL;
        }

        size_t pos = 0;
        list_foreach(volumes->volumes, lvolumes, vol_volume_t, volume) {
                if (vol_volume_is_persist(volume)) {
                        if (pos < buf_cnt)
                                id_buf[pos].id = volume->id.id;
                        pos++;
                }
        }

        fibril_mutex_unlock(&volumes->lock);
        return EOK;
}

/** Load volumes from SIF document.
 *
 * @param nvolumes Volumes node
 * @param volumes Volumes object
 *
 * @return EOK on success or error code
 */
static errno_t vol_volumes_load(sif_node_t *nvolumes, vol_volumes_t *volumes)
{
        sif_node_t *nvolume;
        vol_volume_t *volume = NULL;
        const char *label;
        const char *mountp;
        errno_t rc;

        nvolume = sif_node_first_child(nvolumes);
        while (nvolume != NULL) {
                if (str_cmp(sif_node_get_type(nvolume), "volume") != 0) {
                        rc = EIO;
                        goto error;
                }

                volume = vol_volume_new();
                if (volume == NULL) {
                        rc = ENOMEM;
                        goto error;
                }

                label = sif_node_get_attr(nvolume, "label");
                mountp = sif_node_get_attr(nvolume, "mountp");

                if (label == NULL || mountp == NULL) {
                        rc = EIO;
                        goto error;
                }

                free(volume->label);
                free(volume->mountp);

                volume->label = str_dup(label);
                volume->mountp = str_dup(mountp);

                fibril_mutex_lock(&volumes->lock);
                vol_volume_add_locked(volumes, volume);
                fibril_mutex_unlock(&volumes->lock);
                nvolume = sif_node_next_child(nvolume);
        }

        return EOK;
error:
        if (volume != NULL)
                vol_volume_delete(volume);
        return rc;
}

/** Save volumes to SIF document.
 *
 * @param volumes List of volumes
 * @param rnode Configuration root node
 * @return EOK on success, ENOMEM if out of memory
 */
errno_t vol_volumes_save(vol_volumes_t *volumes, sif_node_t *rnode)
{
        sif_node_t *nvolumes;
        sif_node_t *node;
        link_t *link;
        vol_volume_t *volume;
        errno_t rc;

        /* Create 'volumes' node. */
        rc = sif_node_append_child(rnode, "volumes", &nvolumes);
        if (rc != EOK)
                goto error;

        link = list_first(&volumes->volumes);
        while (link != NULL) {
                volume = list_get_instance(link, vol_volume_t, lvolumes);

                if (vol_volume_is_persist(volume)) {
                        /* Create 'volume' node. */
                        rc = sif_node_append_child(nvolumes, "volume", &node);
                        if (rc != EOK)
                                goto error;

                        rc = sif_node_set_attr(node, "label", volume->label);
                        if (rc != EOK)
                                goto error;

                        rc = sif_node_set_attr(node, "mountp", volume->mountp);
                        if (rc != EOK)
                                goto error;
                }

                link = list_next(&volume->lvolumes, &volumes->volumes);
        }

        return EOK;
error:
        return rc;
}

/** Get volume information.
 *
 * @param volume Volume
 * @param vinfo Volume information structure to safe info to
 * @return EOK on success or an error code
 */
errno_t vol_volume_get_info(vol_volume_t *volume, vol_info_t *vinfo)
{
        vinfo->id = volume->id;
        str_cpy(vinfo->label, sizeof(vinfo->label), volume->label);
        str_cpy(vinfo->path, sizeof(vinfo->path), volume->mountp);
        return EOK;
}

/** @}
 */