WebSVN – HelenOS – Diff – /trunk/uspace/srv/vfs/vfs_ops.c


/*
 * Copyright (c) 2008 Jakub Jermar
 * 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 fs
 * @{
 */
 
/**
 * @file    vfs_ops.c
 * @brief   Operations that VFS offers to its clients.
 */
 
#include <ipc/ipc.h>
#include <ipc/services.h>
#include <async.h>
#include <fibril.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <bool.h>
#include <futex.h>
#include <rwlock.h>
#include <libadt/list.h>
#include <unistd.h>
#include <ctype.h>
#include <as.h>
#include <assert.h>
#include <atomic.h>
#include "vfs.h"
 
#define min(a, b)   ((a) < (b) ? (a) : (b))
 
/**
 * This rwlock prevents the race between a triplet-to-VFS-node resolution and a
 * concurrent VFS operation which modifies the file system namespace.
 */
RWLOCK_INITIALIZE(namespace_rwlock);
 
atomic_t plb_futex = FUTEX_INITIALIZER;
link_t plb_head;    /**< PLB entry ring buffer. */
uint8_t *plb = NULL;
 
/** Perform a path lookup.
 *
 * @param path      Path to be resolved; it needn't be an ASCIIZ string.
 * @param len       Number of path characters pointed by path.
 * @param result    Empty structure where the lookup result will be stored.
 * @param altroot   If non-empty, will be used instead of rootfs as the root
 *          of the whole VFS tree.
 *
 * @return      EOK on success or an error code from errno.h.
 */
int vfs_lookup_internal(char *path, size_t len, vfs_lookup_res_t *result,
    vfs_pair_t *altroot)
{
    vfs_pair_t *root;
 
    if (!len)
        return EINVAL;
 
    if (altroot)
        root = altroot;
    else
        root = (vfs_pair_t *) &rootfs;
 
    if (!root->fs_handle)
        return ENOENT;
   
    futex_down(&plb_futex);
 
    plb_entry_t entry;
    link_initialize(&entry.plb_link);
    entry.len = len;
 
    off_t first;    /* the first free index */
    off_t last; /* the last free index */
 
    if (list_empty(&plb_head)) {
        first = 0;
        last = PLB_SIZE - 1;
    } else {
        plb_entry_t *oldest = list_get_instance(plb_head.next,
            plb_entry_t, plb_link);
        plb_entry_t *newest = list_get_instance(plb_head.prev,
            plb_entry_t, plb_link);
 
        first = (newest->index + newest->len) % PLB_SIZE;
        last = (oldest->index - 1) % PLB_SIZE;
    }
 
    if (first <= last) {
        if ((last - first) + 1 < len) {
            /*
             * The buffer cannot absorb the path.
             */
            futex_up(&plb_futex);
            return ELIMIT;
        }
    } else {
        if (PLB_SIZE - ((first - last) + 1) < len) {
            /*
             * The buffer cannot absorb the path.
             */
            futex_up(&plb_futex);
            return ELIMIT;
        }
    }
 
    /*
     * We know the first free index in PLB and we also know that there is
     * enough space in the buffer to hold our path.
     */
 
    entry.index = first;
    entry.len = len;
 
    /*
     * Claim PLB space by inserting the entry into the PLB entry ring
     * buffer.
     */
    list_append(&entry.plb_link, &plb_head);
   
    futex_up(&plb_futex);
 
    /*
     * Copy the path into PLB.
     */
    size_t cnt1 = min(len, (PLB_SIZE - first) + 1);
    size_t cnt2 = len - cnt1;
   
    memcpy(&plb[first], path, cnt1);
    memcpy(plb, &path[cnt1], cnt2);
 
    ipc_call_t answer;
    int phone = vfs_grab_phone(root->fs_handle);
    aid_t req = async_send_3(phone, VFS_LOOKUP, (ipcarg_t) first,
        (ipcarg_t) (first + len - 1) % PLB_SIZE,
        (ipcarg_t) root->dev_handle, &answer);
    vfs_release_phone(phone);
 
    ipcarg_t rc;
    async_wait_for(req, &rc);
 
    futex_down(&plb_futex);
    list_remove(&entry.plb_link);
    /*
     * Erasing the path from PLB will come handy for debugging purposes.
     */
    memset(&plb[first], 0, cnt1);
    memset(plb, 0, cnt2);
    futex_up(&plb_futex);
 
    if (rc == EOK) {
        result->triplet.fs_handle = (int) IPC_GET_ARG1(answer);
        result->triplet.dev_handle = (int) IPC_GET_ARG2(answer);
        result->triplet.index = (int) IPC_GET_ARG3(answer);
        result->size = (size_t) IPC_GET_ARG4(answer);
    }
 
    return rc;
}
 
atomic_t rootfs_futex = FUTEX_INITIALIZER;
vfs_triplet_t rootfs = {
    .fs_handle = 0,
    .dev_handle = 0,
    .index = 0,
};
 
static int lookup_root(int fs_handle, int dev_handle, vfs_lookup_res_t *result)
{
    vfs_pair_t altroot = {
        .fs_handle = fs_handle,
        .dev_handle = dev_handle,
    };
 
    return vfs_lookup_internal("/", strlen("/"), result, &altroot);
}
 
void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
{
    int dev_handle;
    vfs_node_t *mp_node = NULL;
 
    /*
     * We expect the library to do the device-name to device-handle
     * translation for us, thus the device handle will arrive as ARG1
     * in the request.
     */
    dev_handle = IPC_GET_ARG1(*request);
 
    /*
     * For now, don't make use of ARG2 and ARG3, but they can be used to
     * carry mount options in the future.
     */
 
    ipc_callid_t callid;
    size_t size;
 
    /*
     * Now, we expect the client to send us data with the name of the file
     * system.
     */
    if (!ipc_data_write_receive(&callid, &size)) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Don't receive more than is necessary for storing a full file system
     * name.
     */
    if (size < 1 || size > FS_NAME_MAXLEN) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Deliver the file system name.
     */
    char fs_name[FS_NAME_MAXLEN + 1];
    (void) ipc_data_write_finalize(callid, fs_name, size);
    fs_name[size] = '\0';
   
    /*
     * Check if we know a file system with the same name as is in fs_name.
     * This will also give us its file system handle.
     */
    int fs_handle = fs_name_to_handle(fs_name, true);
    if (!fs_handle) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
 
    /*
     * Now, we want the client to send us the mount point.
     */
    if (!ipc_data_write_receive(&callid, &size)) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Check whether size is reasonable wrt. the mount point.
     */
    if (size < 1 || size > MAX_PATH_LEN) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
    /*
     * Allocate buffer for the mount point data being received.
     */
    uint8_t *buf;
    buf = malloc(size);
    if (!buf) {
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    /*
     * Deliver the mount point.
     */
    (void) ipc_data_write_finalize(callid, buf, size);
 
    /*
     * Lookup the root node of the filesystem being mounted.
     * In this case, we don't need to take the namespace_futex as the root
     * node cannot be removed. However, we do take a reference to it so
     * that we can track how many times it has been mounted.
     */
    int rc;
    vfs_lookup_res_t mr_res;
    rc = lookup_root(fs_handle, dev_handle, &mr_res);
    if (rc != EOK) {
        free(buf);
        ipc_answer_0(rid, rc);
        return;
    }
    vfs_node_t *mr_node = vfs_node_get(&mr_res);
    if (!mr_node) {
        free(buf);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    /*
     * Finally, we need to resolve the path to the mountpoint.
     */
    vfs_lookup_res_t mp_res;
    futex_down(&rootfs_futex);
    if (rootfs.fs_handle) {
        /*
         * We already have the root FS.
         */
        rwlock_write_lock(&namespace_rwlock);
        rc = vfs_lookup_internal(buf, size, &mp_res, NULL);
        if (rc != EOK) {
            /*
             * The lookup failed for some reason.
             */
            rwlock_write_unlock(&namespace_rwlock);
            futex_up(&rootfs_futex);
            vfs_node_put(mr_node);  /* failed -> drop reference */
            free(buf);
            ipc_answer_0(rid, rc);
            return;
        }
        mp_node = vfs_node_get(&mp_res);
        if (!mp_node) {
            rwlock_write_unlock(&namespace_rwlock);
            futex_up(&rootfs_futex);
            vfs_node_put(mr_node);  /* failed -> drop reference */
            free(buf);
            ipc_answer_0(rid, ENOMEM);
            return;
        }
        /*
         * Now we hold a reference to mp_node.
         * It will be dropped upon the corresponding VFS_UNMOUNT.
         * This prevents the mount point from being deleted.
         */
        rwlock_write_unlock(&namespace_rwlock);
    } else {
        /*
         * We still don't have the root file system mounted.
         */
        if ((size == 1) && (buf[0] == '/')) {
            /*
             * For this simple, but important case, we are done.
             */
            rootfs = mr_res.triplet;
            futex_up(&rootfs_futex);
            free(buf);
            ipc_answer_0(rid, EOK);
            return;
        } else {
            /*
             * We can't resolve this without the root filesystem
             * being mounted first.
             */
            futex_up(&rootfs_futex);
            free(buf);
            vfs_node_put(mr_node);  /* failed -> drop reference */
            ipc_answer_0(rid, ENOENT);
            return;
        }
    }
    futex_up(&rootfs_futex);
   
    free(buf);  /* The buffer is not needed anymore. */
   
    /*
     * At this point, we have all necessary pieces: file system and device
     * handles, and we know the mount point VFS node and also the root node
     * of the file system being mounted.
     */
 
    int phone = vfs_grab_phone(mp_res.triplet.fs_handle);
    /* Later we can use ARG3 to pass mode/flags. */
    aid_t req1 = async_send_3(phone, VFS_MOUNT,
        (ipcarg_t) mp_res.triplet.dev_handle,
        (ipcarg_t) mp_res.triplet.index, 0, NULL);
    /* The second call uses the same method. */
    aid_t req2 = async_send_3(phone, VFS_MOUNT,
        (ipcarg_t) mr_res.triplet.fs_handle,
        (ipcarg_t) mr_res.triplet.dev_handle,
        (ipcarg_t) mr_res.triplet.index, NULL);
    vfs_release_phone(phone);
 
    ipcarg_t rc1;
    ipcarg_t rc2;
    async_wait_for(req1, &rc1);
    async_wait_for(req2, &rc2);
 
    if ((rc1 != EOK) || (rc2 != EOK)) {
        /* Mount failed, drop references to mr_node and mp_node. */
        vfs_node_put(mr_node);
        if (mp_node)
            vfs_node_put(mp_node);
    }
   
    if (rc2 == EOK)
        ipc_answer_0(rid, rc1);
    else if (rc1 == EOK)
        ipc_answer_0(rid, rc2);
    else
        ipc_answer_0(rid, rc1);
}
 
void vfs_open(ipc_callid_t rid, ipc_call_t *request)
{
    if (!vfs_files_init()) {
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    /*
     * The POSIX interface is open(path, flags, mode).
     * We can receive flags and mode along with the VFS_OPEN call; the path
     * will need to arrive in another call.
     */
    int flags = IPC_GET_ARG1(*request);
    int mode = IPC_GET_ARG2(*request);
    size_t len;
 
    ipc_callid_t callid;
 
    if (!ipc_data_write_receive(&callid, &len)) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Now we are on the verge of accepting the path.
     *
     * There is one optimization we could do in the future: copy the path
     * directly into the PLB using some kind of a callback.
     */
    char *path = malloc(len);
   
    if (!path) {
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    int rc;
    if ((rc = ipc_data_write_finalize(callid, path, len))) {
        ipc_answer_0(rid, rc);
        free(path);
        return;
    }
   
    /*
     * Avoid the race condition in which the file can be deleted before we
     * find/create-and-lock the VFS node corresponding to the looked-up
     * triplet.
     */
    rwlock_read_lock(&namespace_rwlock);
 
    /*
     * The path is now populated and we can call vfs_lookup_internal().
     */
    vfs_lookup_res_t lr;
    rc = vfs_lookup_internal(path, len, &lr, NULL);
    if (rc) {
        rwlock_read_unlock(&namespace_rwlock);
        ipc_answer_0(rid, rc);
        free(path);
        return;
    }
 
    /*
     * Path is no longer needed.
     */
    free(path);
 
    vfs_node_t *node = vfs_node_get(&lr);
    rwlock_read_unlock(&namespace_rwlock);
 
    /*
     * Get ourselves a file descriptor and the corresponding vfs_file_t
     * structure.
     */
    int fd = vfs_fd_alloc();
    if (fd < 0) {
        vfs_node_put(node);
        ipc_answer_0(rid, fd);
        return;
    }
    vfs_file_t *file = vfs_file_get(fd);
    file->node = node;
 
    /*
     * The following increase in reference count is for the fact that the
     * file is being opened and that a file structure is pointing to it.
     * It is necessary so that the file will not disappear when
     * vfs_node_put() is called. The reference will be dropped by the
     * respective VFS_CLOSE.
     */
    vfs_node_addref(node);
    vfs_node_put(node);
 
    /*
     * Success! Return the new file descriptor to the client.
     */
    ipc_answer_1(rid, EOK, fd);
}
 
static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
{
 
    /*
     * The following code strongly depends on the fact that the files data
     * structure can be only accessed by a single fibril and all file
     * operations are serialized (i.e. the reads and writes cannot
     * interleave and a file cannot be closed while it is being read).
     *
     * Additional synchronization needs to be added once the table of
     * open files supports parallel access!
     */
 
    int fd = IPC_GET_ARG1(*request);
 
    /*
     * Lookup the file structure corresponding to the file descriptor.
     */
    vfs_file_t *file = vfs_file_get(fd);
    if (!file) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
 
    /*
     * Now we need to receive a call with client's
     * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
     */
    ipc_callid_t callid;
    int res;
    if (read)
        res = ipc_data_read_receive(&callid, NULL);
    else
        res = ipc_data_write_receive(&callid, NULL);
    if (!res) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Lock the open file structure so that no other thread can manipulate
     * the same open file at a time.
     */
    futex_down(&file->lock);
 
    /*
     * Lock the file's node so that no other client can read/write to it at
     * the same time.
     */
    if (read)
        rwlock_read_lock(&file->node->contents_rwlock);
    else
        rwlock_write_lock(&file->node->contents_rwlock);
 
    int fs_phone = vfs_grab_phone(file->node->fs_handle);  
   
    /*
     * Make a VFS_READ/VFS_WRITE request at the destination FS server.
     */
    aid_t msg;
    ipc_call_t answer;
    msg = async_send_3(fs_phone, IPC_GET_METHOD(*request),
        file->node->dev_handle, file->node->index, file->pos, &answer);
   
    /*
     * Forward the IPC_M_DATA_READ/IPC_M_DATA_WRITE request to the
     * destination FS server. The call will be routed as if sent by
     * ourselves. Note that call arguments are immutable in this case so we
     * don't have to bother.
     */
    ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
 
    vfs_release_phone(fs_phone);
 
    /*
     * Wait for reply from the FS server.
     */
    ipcarg_t rc;
    async_wait_for(msg, &rc);
    size_t bytes = IPC_GET_ARG1(answer);
 
    /*
     * Unlock the VFS node.
     */
    if (read)
        rwlock_read_unlock(&file->node->contents_rwlock);
    else {
        /* Update the cached version of node's size. */
        file->node->size = IPC_GET_ARG2(answer);
        rwlock_write_unlock(&file->node->contents_rwlock);
    }
 
    /*
     * Update the position pointer and unlock the open file.
     */
    file->pos += bytes;
    futex_up(&file->lock);
 
    /*
     * FS server's reply is the final result of the whole operation we
     * return to the client.
     */
    ipc_answer_1(rid, rc, bytes);
}
 
void vfs_read(ipc_callid_t rid, ipc_call_t *request)
{
    vfs_rdwr(rid, request, true);
}
 
void vfs_write(ipc_callid_t rid, ipc_call_t *request)
{
    vfs_rdwr(rid, request, false);
}
 
void vfs_seek(ipc_callid_t rid, ipc_call_t *request)
{
    int fd = (int) IPC_GET_ARG1(*request);
    off_t off = (off_t) IPC_GET_ARG2(*request);
    int whence = (int) IPC_GET_ARG3(*request);
 
 
    /*
     * Lookup the file structure corresponding to the file descriptor.
     */
    vfs_file_t *file = vfs_file_get(fd);
    if (!file) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
 
    off_t newpos;
    futex_down(&file->lock);
    if (whence == SEEK_SET) {
        file->pos = off;
        futex_up(&file->lock);
        ipc_answer_1(rid, EOK, off);
        return;
    }
    if (whence == SEEK_CUR) {
        if (file->pos + off < file->pos) {
            futex_up(&file->lock);
            ipc_answer_0(rid, EOVERFLOW);
            return;
        }
        file->pos += off;
        newpos = file->pos;
        futex_up(&file->lock);
        ipc_answer_1(rid, EOK, newpos);
        return;
    }
    if (whence == SEEK_END) {
        rwlock_read_lock(&file->node->contents_rwlock);
        size_t size = file->node->size;
        rwlock_read_unlock(&file->node->contents_rwlock);
        if (size + off < size) {
            futex_up(&file->lock);
            ipc_answer_0(rid, EOVERFLOW);
            return;
        }
        newpos = size + off;
        futex_up(&file->lock);
        ipc_answer_1(rid, EOK, newpos);
        return;
    }
    futex_up(&file->lock);
    ipc_answer_0(rid, EINVAL);
}
 
void vfs_truncate(ipc_callid_t rid, ipc_call_t *request)
{
    int fd = IPC_GET_ARG1(*request);
    size_t size = IPC_GET_ARG2(*request);
    ipcarg_t rc;
 
    vfs_file_t *file = vfs_file_get(fd);
    if (!file) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
    futex_down(&file->lock);
 
    rwlock_write_lock(&file->node->contents_rwlock);
    int fs_phone = vfs_grab_phone(file->node->fs_handle);
    rc = async_req_3_0(fs_phone, VFS_TRUNCATE, (ipcarg_t)file->node->dev_handle,
        (ipcarg_t)file->node->index, (ipcarg_t)size);
    vfs_release_phone(fs_phone);
    if (rc == EOK)
        file->node->size = size;
    rwlock_write_unlock(&file->node->contents_rwlock);
 
    futex_up(&file->lock);
 
    return rc; 
}
 
atomic_t fs_head_futex = FUTEX_INITIALIZER;
link_t fs_head;
 
atomic_t fs_handle_next = {
    .count = 1
};
 
/** Verify the VFS info structure.
 *
 * @param info      Info structure to be verified.
 *
 * @return      Non-zero if the info structure is sane, zero otherwise.
 */
static bool vfs_info_sane(vfs_info_t *info)
{
    int i;
 
    /*
     * Check if the name is non-empty and is composed solely of ASCII
     * characters [a-z]+[a-z0-9_-]*.
     */
    if (!islower(info->name[0])) {
        dprintf("The name doesn't start with a lowercase character.\n");
        return false;
    }
    for (i = 1; i < FS_NAME_MAXLEN; i++) {
        if (!(islower(info->name[i]) || isdigit(info->name[i])) &&
            (info->name[i] != '-') && (info->name[i] != '_')) {
            if (info->name[i] == '\0') {
                break;
            } else {
                dprintf("The name contains illegal "
                    "characters.\n");
                return false;
            }
        }
    }
    /*
     * This check is not redundant. It ensures that the name is
     * NULL-terminated, even if FS_NAME_MAXLEN characters are used.
     */
    if (info->name[i] != '\0') {
        dprintf("The name is not properly NULL-terminated.\n");
        return false;
    }
   
 
    /*
     * Check if the FS implements mandatory VFS operations.
     */
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_LOOKUP not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_OPEN)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_OPEN not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_CLOSE not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_READ)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_READ not defined by the client.\n");
        return false;
    }
   
    /*
     * Check if each operation is either not defined, defined or default.
     */
    for (i = VFS_FIRST; i < VFS_LAST_CLNT; i++) {
        if ((info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_NULL) &&
            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFAULT) &&
            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFINED)) {
            dprintf("Operation info not understood.\n");
            return false;
        }
    }
    return true;
}
 
/** VFS_REGISTER protocol function.
 *
 * @param rid       Hash of the call with the request.
 * @param request   Call structure with the request.
 */
void vfs_register(ipc_callid_t rid, ipc_call_t *request)
{
    ipc_callid_t callid;
    ipc_call_t call;
    int rc;
    size_t size;
 
    dprintf("Processing VFS_REGISTER request received from %p.\n",
        request->in_phone_hash);
 
    /*
     * The first call has to be IPC_M_DATA_SEND in which we receive the
     * VFS info structure from the client FS.
     */
    if (!ipc_data_write_receive(&callid, &size)) {
        /*
         * The client doesn't obey the same protocol as we do.
         */
        dprintf("Receiving of VFS info failed.\n");
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
   
    dprintf("VFS info received, size = %d\n", size);
   
    /*
     * We know the size of the VFS info structure. See if the client
     * understands this easy concept too.
     */
    if (size != sizeof(vfs_info_t)) {
        /*
         * The client is sending us something, which cannot be
         * the info structure.
         */
        dprintf("Received VFS info has bad size.\n");
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Allocate and initialize a buffer for the fs_info structure.
     */
    fs_info_t *fs_info;
    fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
    if (!fs_info) {
        dprintf("Could not allocate memory for FS info.\n");
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
    link_initialize(&fs_info->fs_link);
    futex_initialize(&fs_info->phone_futex, 1);
       
    rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);
    if (rc != EOK) {
        dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
            rc);
        free(fs_info);
        ipc_answer_0(callid, rc);
        ipc_answer_0(rid, rc);
        return;
    }
 
    dprintf("VFS info delivered.\n");
       
    if (!vfs_info_sane(&fs_info->vfs_info)) {
        free(fs_info);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
       
    futex_down(&fs_head_futex);
 
    /*
     * Check for duplicit registrations.
     */
    if (fs_name_to_handle(fs_info->vfs_info.name, false)) {
        /*
         * We already register a fs like this.
         */
        dprintf("FS is already registered.\n");
        futex_up(&fs_head_futex);
        free(fs_info);
        ipc_answer_0(callid, EEXISTS);
        ipc_answer_0(rid, EEXISTS);
        return;
    }
 
    /*
     * Add fs_info to the list of registered FS's.
     */
    dprintf("Inserting FS into the list of registered file systems.\n");
    list_append(&fs_info->fs_link, &fs_head);
 
    /*
     * Now we want the client to send us the IPC_M_CONNECT_TO_ME call so
     * that a callback connection is created and we have a phone through
     * which to forward VFS requests to it.
     */
    callid = async_get_call(&call);
    if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
        dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
        list_remove(&fs_info->fs_link);
        futex_up(&fs_head_futex);
        free(fs_info);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
    fs_info->phone = IPC_GET_ARG5(call);
    ipc_answer_0(callid, EOK);
 
    dprintf("Callback connection to FS created.\n");
 
    /*
     * The client will want us to send him the address space area with PLB.
     */
 
    if (!ipc_share_in_receive(&callid, &size)) {
        dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
        list_remove(&fs_info->fs_link);
        futex_up(&fs_head_futex);
        ipc_hangup(fs_info->phone);
        free(fs_info);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
   
    /*
     * We can only send the client address space area PLB_SIZE bytes long.
     */
    if (size != PLB_SIZE) {
        dprintf("Client suggests wrong size of PFB, size = %d\n", size);
        list_remove(&fs_info->fs_link);
        futex_up(&fs_head_futex);
        ipc_hangup(fs_info->phone);
        free(fs_info);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Commit to read-only sharing the PLB with the client.
     */
    (void) ipc_share_in_finalize(callid, plb,
        AS_AREA_READ | AS_AREA_CACHEABLE);
 
    dprintf("Sharing PLB.\n");
 
    /*
     * That was it. The FS has been registered.
     * In reply to the VFS_REGISTER request, we assign the client file
     * system a global file system handle.
     */
    fs_info->fs_handle = (int) atomic_postinc(&fs_handle_next);
    ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
   
    futex_up(&fs_head_futex);
   
    dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
        FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);
}
 
/** For a given file system handle, implement policy for allocating a phone.
 *
 * @param handle    File system handle.
 *
 * @return      Phone over which a multi-call request can be safely
 *          sent. Return 0 if no phone was found.
 */
int vfs_grab_phone(int handle)
{
    /*
     * For now, we don't try to be very clever and very fast.
     * We simply lookup the phone in the fs_head list. We currently don't
     * open any additional phones (even though that itself would be pretty
     * straightforward; housekeeping multiple open phones to a FS task would
     * be more demanding). Instead, we simply take the respective
     * phone_futex and keep it until vfs_release_phone().
     */
    futex_down(&fs_head_futex);
    link_t *cur;
    fs_info_t *fs;
    for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
        fs = list_get_instance(cur, fs_info_t, fs_link);
        if (fs->fs_handle == handle) {
            futex_up(&fs_head_futex);
            /*
             * For now, take the futex unconditionally.
             * Oh yeah, serialization rocks.
             * It will be up'ed in vfs_release_phone().
             */
            futex_down(&fs->phone_futex);
            /*
             * Avoid deadlock with other fibrils in the same thread
             * by disabling fibril preemption.
             */
            fibril_inc_sercount();
            return fs->phone;
        }
    }
    futex_up(&fs_head_futex);
    return 0;
}
 
/** Tell VFS that the phone is in use for any request.
 *
 * @param phone     Phone to FS task.
 */
void vfs_release_phone(int phone)
{
    bool found = false;
 
    /*
     * Undo the fibril_inc_sercount() done in vfs_grab_phone().
     */
    fibril_dec_sercount();
   
    futex_down(&fs_head_futex);
    link_t *cur;
    for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
        fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
        if (fs->phone == phone) {
            found = true;
            futex_up(&fs_head_futex);
            futex_up(&fs->phone_futex);
            return;
        }
    }
    futex_up(&fs_head_futex);
 
    /*
     * Not good to get here.
     */
    assert(found == true);
}
 
/** Convert file system name to its handle.
 *
 * @param name      File system name.
 * @param lock      If true, the function will down and up the
 *          fs_head_futex.
 *
 * @return      File system handle or zero if file system not found.
 */
int fs_name_to_handle(char *name, bool lock)
{
    int handle = 0;
   
    if (lock)
        futex_down(&fs_head_futex);
    link_t *cur;
    for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
        fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
        if (strncmp(fs->vfs_info.name, name,
            sizeof(fs->vfs_info.name)) == 0) {
            handle = fs->fs_handle;
            break;
        }
    }
    if (lock)
        futex_up(&fs_head_futex);
    return handle;
}
 
/**
 * @}
 */
 

Rev 2691	Rev 2693
1	/*	1	/*
2	* Copyright (c) 2008 Jakub Jermar	2	* Copyright (c) 2008 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup fs	29	/** @addtogroup fs
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file vfs_ops.c	34	* @file vfs_ops.c
35	* @brief Operations that VFS offers to its clients.	35	* @brief Operations that VFS offers to its clients.
36	*/	36	*/
37		37
38	#include <ipc/ipc.h>	38	#include <ipc/ipc.h>
39	#include <ipc/services.h>	39	#include <ipc/services.h>
40	#include <async.h>	40	#include <async.h>
41	#include <fibril.h>	41	#include <fibril.h>
42	#include <errno.h>	42	#include <errno.h>
43	#include <stdio.h>	43	#include <stdio.h>
44	#include <stdlib.h>	44	#include <stdlib.h>
45	#include <string.h>	45	#include <string.h>
46	#include <bool.h>	46	#include <bool.h>
47	#include <futex.h>	47	#include <futex.h>
48	#include <rwlock.h>	48	#include <rwlock.h>
49	#include <libadt/list.h>	49	#include <libadt/list.h>
50	#include <unistd.h>	50	#include <unistd.h>
51	#include <ctype.h>	51	#include <ctype.h>
52	#include <as.h>	52	#include <as.h>
53	#include <assert.h>	53	#include <assert.h>
54	#include <atomic.h>	54	#include <atomic.h>
55	#include "vfs.h"	55	#include "vfs.h"
56		56
57	#define min(a, b) ((a) < (b) ? (a) : (b))	57	#define min(a, b) ((a) < (b) ? (a) : (b))
58		58
59	/**	59	/**
60	* This rwlock prevents the race between a triplet-to-VFS-node resolution and a	60	* This rwlock prevents the race between a triplet-to-VFS-node resolution and a
61	* concurrent VFS operation which modifies the file system namespace.	61	* concurrent VFS operation which modifies the file system namespace.
62	*/	62	*/
63	RWLOCK_INITIALIZE(namespace_rwlock);	63	RWLOCK_INITIALIZE(namespace_rwlock);
64		64
65	atomic_t plb_futex = FUTEX_INITIALIZER;	65	atomic_t plb_futex = FUTEX_INITIALIZER;
66	link_t plb_head; /*< PLB entry ring buffer. /	66	link_t plb_head; /*< PLB entry ring buffer. /
67	uint8_t *plb = NULL;	67	uint8_t *plb = NULL;
68		68
69	/** Perform a path lookup.	69	/** Perform a path lookup.
70	*	70	*
71	* @param path Path to be resolved; it needn't be an ASCIIZ string.	71	* @param path Path to be resolved; it needn't be an ASCIIZ string.
72	* @param len Number of path characters pointed by path.	72	* @param len Number of path characters pointed by path.
73	* @param result Empty structure where the lookup result will be stored.	73	* @param result Empty structure where the lookup result will be stored.
74	* @param altroot If non-empty, will be used instead of rootfs as the root	74	* @param altroot If non-empty, will be used instead of rootfs as the root
75	* of the whole VFS tree.	75	* of the whole VFS tree.
76	*	76	*
77	* @return EOK on success or an error code from errno.h.	77	* @return EOK on success or an error code from errno.h.
78	*/	78	*/
79	int vfs_lookup_internal(char path, size_t len, vfs_lookup_res_t result,	79	int vfs_lookup_internal(char path, size_t len, vfs_lookup_res_t result,
80	vfs_pair_t *altroot)	80	vfs_pair_t *altroot)
81	{	81	{
82	vfs_pair_t *root;	82	vfs_pair_t *root;
83		83
84	if (!len)	84	if (!len)
85	return EINVAL;	85	return EINVAL;
86		86
87	if (altroot)	87	if (altroot)
88	root = altroot;	88	root = altroot;
89	else	89	else
90	root = (vfs_pair_t *) &rootfs;	90	root = (vfs_pair_t *) &rootfs;
91		91
92	if (!root->fs_handle)	92	if (!root->fs_handle)
93	return ENOENT;	93	return ENOENT;
94		94
95	futex_down(&plb_futex);	95	futex_down(&plb_futex);
96		96
97	plb_entry_t entry;	97	plb_entry_t entry;
98	link_initialize(&entry.plb_link);	98	link_initialize(&entry.plb_link);
99	entry.len = len;	99	entry.len = len;
100		100
101	off_t first; /* the first free index */	101	off_t first; /* the first free index */
102	off_t last; /* the last free index */	102	off_t last; /* the last free index */
103		103
104	if (list_empty(&plb_head)) {	104	if (list_empty(&plb_head)) {
105	first = 0;	105	first = 0;
106	last = PLB_SIZE - 1;	106	last = PLB_SIZE - 1;
107	} else {	107	} else {
108	plb_entry_t *oldest = list_get_instance(plb_head.next,	108	plb_entry_t *oldest = list_get_instance(plb_head.next,
109	plb_entry_t, plb_link);	109	plb_entry_t, plb_link);
110	plb_entry_t *newest = list_get_instance(plb_head.prev,	110	plb_entry_t *newest = list_get_instance(plb_head.prev,
111	plb_entry_t, plb_link);	111	plb_entry_t, plb_link);
112		112
113	first = (newest->index + newest->len) % PLB_SIZE;	113	first = (newest->index + newest->len) % PLB_SIZE;
114	last = (oldest->index - 1) % PLB_SIZE;	114	last = (oldest->index - 1) % PLB_SIZE;
115	}	115	}
116		116
117	if (first <= last) {	117	if (first <= last) {
118	if ((last - first) + 1 < len) {	118	if ((last - first) + 1 < len) {
119	/*	119	/*
120	* The buffer cannot absorb the path.	120	* The buffer cannot absorb the path.
121	*/	121	*/
122	futex_up(&plb_futex);	122	futex_up(&plb_futex);
123	return ELIMIT;	123	return ELIMIT;
124	}	124	}
125	} else {	125	} else {
126	if (PLB_SIZE - ((first - last) + 1) < len) {	126	if (PLB_SIZE - ((first - last) + 1) < len) {
127	/*	127	/*
128	* The buffer cannot absorb the path.	128	* The buffer cannot absorb the path.
129	*/	129	*/
130	futex_up(&plb_futex);	130	futex_up(&plb_futex);
131	return ELIMIT;	131	return ELIMIT;
132	}	132	}
133	}	133	}
134		134
135	/*	135	/*
136	* We know the first free index in PLB and we also know that there is	136	* We know the first free index in PLB and we also know that there is
137	* enough space in the buffer to hold our path.	137	* enough space in the buffer to hold our path.
138	*/	138	*/
139		139
140	entry.index = first;	140	entry.index = first;
141	entry.len = len;	141	entry.len = len;
142		142
143	/*	143	/*
144	* Claim PLB space by inserting the entry into the PLB entry ring	144	* Claim PLB space by inserting the entry into the PLB entry ring
145	* buffer.	145	* buffer.
146	*/	146	*/
147	list_append(&entry.plb_link, &plb_head);	147	list_append(&entry.plb_link, &plb_head);
148		148
149	futex_up(&plb_futex);	149	futex_up(&plb_futex);
150		150
151	/*	151	/*
152	* Copy the path into PLB.	152	* Copy the path into PLB.
153	*/	153	*/
154	size_t cnt1 = min(len, (PLB_SIZE - first) + 1);	154	size_t cnt1 = min(len, (PLB_SIZE - first) + 1);
155	size_t cnt2 = len - cnt1;	155	size_t cnt2 = len - cnt1;
156		156
157	memcpy(&plb[first], path, cnt1);	157	memcpy(&plb[first], path, cnt1);
158	memcpy(plb, &path[cnt1], cnt2);	158	memcpy(plb, &path[cnt1], cnt2);
159		159
160	ipc_call_t answer;	160	ipc_call_t answer;
161	int phone = vfs_grab_phone(root->fs_handle);	161	int phone = vfs_grab_phone(root->fs_handle);
162	aid_t req = async_send_3(phone, VFS_LOOKUP, (ipcarg_t) first,	162	aid_t req = async_send_3(phone, VFS_LOOKUP, (ipcarg_t) first,
163	(ipcarg_t) (first + len - 1) % PLB_SIZE,	163	(ipcarg_t) (first + len - 1) % PLB_SIZE,
164	(ipcarg_t) root->dev_handle, &answer);	164	(ipcarg_t) root->dev_handle, &answer);
165	vfs_release_phone(phone);	165	vfs_release_phone(phone);
166		166
167	ipcarg_t rc;	167	ipcarg_t rc;
168	async_wait_for(req, &rc);	168	async_wait_for(req, &rc);
169		169
170	futex_down(&plb_futex);	170	futex_down(&plb_futex);
171	list_remove(&entry.plb_link);	171	list_remove(&entry.plb_link);
172	/*	172	/*
173	* Erasing the path from PLB will come handy for debugging purposes.	173	* Erasing the path from PLB will come handy for debugging purposes.
174	*/	174	*/
175	memset(&plb[first], 0, cnt1);	175	memset(&plb[first], 0, cnt1);
176	memset(plb, 0, cnt2);	176	memset(plb, 0, cnt2);
177	futex_up(&plb_futex);	177	futex_up(&plb_futex);
178		178
179	if (rc == EOK) {	179	if (rc == EOK) {
180	result->triplet.fs_handle = (int) IPC_GET_ARG1(answer);	180	result->triplet.fs_handle = (int) IPC_GET_ARG1(answer);
181	result->triplet.dev_handle = (int) IPC_GET_ARG2(answer);	181	result->triplet.dev_handle = (int) IPC_GET_ARG2(answer);
182	result->triplet.index = (int) IPC_GET_ARG3(answer);	182	result->triplet.index = (int) IPC_GET_ARG3(answer);
183	result->size = (size_t) IPC_GET_ARG4(answer);	183	result->size = (size_t) IPC_GET_ARG4(answer);
184	}	184	}
185		185
186	return rc;	186	return rc;
187	}	187	}
188		188
189	atomic_t rootfs_futex = FUTEX_INITIALIZER;	189	atomic_t rootfs_futex = FUTEX_INITIALIZER;
190	vfs_triplet_t rootfs = {	190	vfs_triplet_t rootfs = {
191	.fs_handle = 0,	191	.fs_handle = 0,
192	.dev_handle = 0,	192	.dev_handle = 0,
193	.index = 0,	193	.index = 0,
194	};	194	};
195		195
196	static int lookup_root(int fs_handle, int dev_handle, vfs_lookup_res_t *result)	196	static int lookup_root(int fs_handle, int dev_handle, vfs_lookup_res_t *result)
197	{	197	{
198	vfs_pair_t altroot = {	198	vfs_pair_t altroot = {
199	.fs_handle = fs_handle,	199	.fs_handle = fs_handle,
200	.dev_handle = dev_handle,	200	.dev_handle = dev_handle,
201	};	201	};
202		202
203	return vfs_lookup_internal("/", strlen("/"), result, &altroot);	203	return vfs_lookup_internal("/", strlen("/"), result, &altroot);
204	}	204	}
205		205
206	void vfs_mount(ipc_callid_t rid, ipc_call_t *request)	206	void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
207	{	207	{
208	int dev_handle;	208	int dev_handle;
209	vfs_node_t *mp_node = NULL;	209	vfs_node_t *mp_node = NULL;
210		210
211	/*	211	/*
212	* We expect the library to do the device-name to device-handle	212	* We expect the library to do the device-name to device-handle
213	* translation for us, thus the device handle will arrive as ARG1	213	* translation for us, thus the device handle will arrive as ARG1
214	* in the request.	214	* in the request.
215	*/	215	*/
216	dev_handle = IPC_GET_ARG1(*request);	216	dev_handle = IPC_GET_ARG1(*request);
217		217
218	/*	218	/*
219	* For now, don't make use of ARG2 and ARG3, but they can be used to	219	* For now, don't make use of ARG2 and ARG3, but they can be used to
220	* carry mount options in the future.	220	* carry mount options in the future.
221	*/	221	*/
222		222
223	ipc_callid_t callid;	223	ipc_callid_t callid;
224	size_t size;	224	size_t size;
225		225
226	/*	226	/*
227	* Now, we expect the client to send us data with the name of the file	227	* Now, we expect the client to send us data with the name of the file
228	* system.	228	* system.
229	*/	229	*/
230	if (!ipc_data_write_receive(&callid, &size)) {	230	if (!ipc_data_write_receive(&callid, &size)) {
231	ipc_answer_0(callid, EINVAL);	231	ipc_answer_0(callid, EINVAL);
232	ipc_answer_0(rid, EINVAL);	232	ipc_answer_0(rid, EINVAL);
233	return;	233	return;
234	}	234	}
235		235
236	/*	236	/*
237	* Don't receive more than is necessary for storing a full file system	237	* Don't receive more than is necessary for storing a full file system
238	* name.	238	* name.
239	*/	239	*/
240	if (size < 1 \|\| size > FS_NAME_MAXLEN) {	240	if (size < 1 \|\| size > FS_NAME_MAXLEN) {
241	ipc_answer_0(callid, EINVAL);	241	ipc_answer_0(callid, EINVAL);
242	ipc_answer_0(rid, EINVAL);	242	ipc_answer_0(rid, EINVAL);
243	return;	243	return;
244	}	244	}
245		245
246	/*	246	/*
247	* Deliver the file system name.	247	* Deliver the file system name.
248	*/	248	*/
249	char fs_name[FS_NAME_MAXLEN + 1];	249	char fs_name[FS_NAME_MAXLEN + 1];
250	(void) ipc_data_write_finalize(callid, fs_name, size);	250	(void) ipc_data_write_finalize(callid, fs_name, size);
251	fs_name[size] = '\0';	251	fs_name[size] = '\0';
252		252
253	/*	253	/*
254	* Check if we know a file system with the same name as is in fs_name.	254	* Check if we know a file system with the same name as is in fs_name.
255	* This will also give us its file system handle.	255	* This will also give us its file system handle.
256	*/	256	*/
257	int fs_handle = fs_name_to_handle(fs_name, true);	257	int fs_handle = fs_name_to_handle(fs_name, true);
258	if (!fs_handle) {	258	if (!fs_handle) {
259	ipc_answer_0(rid, ENOENT);	259	ipc_answer_0(rid, ENOENT);
260	return;	260	return;
261	}	261	}
262		262
263	/*	263	/*
264	* Now, we want the client to send us the mount point.	264	* Now, we want the client to send us the mount point.
265	*/	265	*/
266	if (!ipc_data_write_receive(&callid, &size)) {	266	if (!ipc_data_write_receive(&callid, &size)) {
267	ipc_answer_0(callid, EINVAL);	267	ipc_answer_0(callid, EINVAL);
268	ipc_answer_0(rid, EINVAL);	268	ipc_answer_0(rid, EINVAL);
269	return;	269	return;
270	}	270	}
271		271
272	/*	272	/*
273	* Check whether size is reasonable wrt. the mount point.	273	* Check whether size is reasonable wrt. the mount point.
274	*/	274	*/
275	if (size < 1 \|\| size > MAX_PATH_LEN) {	275	if (size < 1 \|\| size > MAX_PATH_LEN) {
276	ipc_answer_0(callid, EINVAL);	276	ipc_answer_0(callid, EINVAL);
277	ipc_answer_0(rid, EINVAL);	277	ipc_answer_0(rid, EINVAL);
278	return;	278	return;
279	}	279	}
280	/*	280	/*
281	* Allocate buffer for the mount point data being received.	281	* Allocate buffer for the mount point data being received.
282	*/	282	*/
283	uint8_t *buf;	283	uint8_t *buf;
284	buf = malloc(size);	284	buf = malloc(size);
285	if (!buf) {	285	if (!buf) {
286	ipc_answer_0(callid, ENOMEM);	286	ipc_answer_0(callid, ENOMEM);
287	ipc_answer_0(rid, ENOMEM);	287	ipc_answer_0(rid, ENOMEM);
288	return;	288	return;
289	}	289	}
290		290
291	/*	291	/*
292	* Deliver the mount point.	292	* Deliver the mount point.
293	*/	293	*/
294	(void) ipc_data_write_finalize(callid, buf, size);	294	(void) ipc_data_write_finalize(callid, buf, size);
295		295
296	/*	296	/*
297	* Lookup the root node of the filesystem being mounted.	297	* Lookup the root node of the filesystem being mounted.
298	* In this case, we don't need to take the namespace_futex as the root	298	* In this case, we don't need to take the namespace_futex as the root
299	* node cannot be removed. However, we do take a reference to it so	299	* node cannot be removed. However, we do take a reference to it so
300	* that we can track how many times it has been mounted.	300	* that we can track how many times it has been mounted.
301	*/	301	*/
302	int rc;	302	int rc;
303	vfs_lookup_res_t mr_res;	303	vfs_lookup_res_t mr_res;
304	rc = lookup_root(fs_handle, dev_handle, &mr_res);	304	rc = lookup_root(fs_handle, dev_handle, &mr_res);
305	if (rc != EOK) {	305	if (rc != EOK) {
306	free(buf);	306	free(buf);
307	ipc_answer_0(rid, rc);	307	ipc_answer_0(rid, rc);
308	return;	308	return;
309	}	309	}
310	vfs_node_t *mr_node = vfs_node_get(&mr_res);	310	vfs_node_t *mr_node = vfs_node_get(&mr_res);
311	if (!mr_node) {	311	if (!mr_node) {
312	free(buf);	312	free(buf);
313	ipc_answer_0(rid, ENOMEM);	313	ipc_answer_0(rid, ENOMEM);
314	return;	314	return;
315	}	315	}
316		316
317	/*	317	/*
318	* Finally, we need to resolve the path to the mountpoint.	318	* Finally, we need to resolve the path to the mountpoint.
319	*/	319	*/
320	vfs_lookup_res_t mp_res;	320	vfs_lookup_res_t mp_res;
321	futex_down(&rootfs_futex);	321	futex_down(&rootfs_futex);
322	if (rootfs.fs_handle) {	322	if (rootfs.fs_handle) {
323	/*	323	/*
324	* We already have the root FS.	324	* We already have the root FS.
325	*/	325	*/
326	rwlock_write_lock(&namespace_rwlock);	326	rwlock_write_lock(&namespace_rwlock);
327	rc = vfs_lookup_internal(buf, size, &mp_res, NULL);	327	rc = vfs_lookup_internal(buf, size, &mp_res, NULL);
328	if (rc != EOK) {	328	if (rc != EOK) {
329	/*	329	/*
330	* The lookup failed for some reason.	330	* The lookup failed for some reason.
331	*/	331	*/
332	rwlock_write_unlock(&namespace_rwlock);	332	rwlock_write_unlock(&namespace_rwlock);
333	futex_up(&rootfs_futex);	333	futex_up(&rootfs_futex);
334	vfs_node_put(mr_node); /* failed -> drop reference */	334	vfs_node_put(mr_node); /* failed -> drop reference */
335	free(buf);	335	free(buf);
336	ipc_answer_0(rid, rc);	336	ipc_answer_0(rid, rc);
337	return;	337	return;
338	}	338	}
339	mp_node = vfs_node_get(&mp_res);	339	mp_node = vfs_node_get(&mp_res);
340	if (!mp_node) {	340	if (!mp_node) {
341	rwlock_write_unlock(&namespace_rwlock);	341	rwlock_write_unlock(&namespace_rwlock);
342	futex_up(&rootfs_futex);	342	futex_up(&rootfs_futex);
343	vfs_node_put(mr_node); /* failed -> drop reference */	343	vfs_node_put(mr_node); /* failed -> drop reference */
344	free(buf);	344	free(buf);
345	ipc_answer_0(rid, ENOMEM);	345	ipc_answer_0(rid, ENOMEM);
346	return;	346	return;
347	}	347	}
348	/*	348	/*
349	* Now we hold a reference to mp_node.	349	* Now we hold a reference to mp_node.
350	* It will be dropped upon the corresponding VFS_UNMOUNT.	350	* It will be dropped upon the corresponding VFS_UNMOUNT.
351	* This prevents the mount point from being deleted.	351	* This prevents the mount point from being deleted.
352	*/	352	*/
353	rwlock_write_unlock(&namespace_rwlock);	353	rwlock_write_unlock(&namespace_rwlock);
354	} else {	354	} else {
355	/*	355	/*
356	* We still don't have the root file system mounted.	356	* We still don't have the root file system mounted.
357	*/	357	*/
358	if ((size == 1) && (buf[0] == '/')) {	358	if ((size == 1) && (buf[0] == '/')) {
359	/*	359	/*
360	* For this simple, but important case, we are done.	360	* For this simple, but important case, we are done.
361	*/	361	*/
362	rootfs = mr_res.triplet;	362	rootfs = mr_res.triplet;
363	futex_up(&rootfs_futex);	363	futex_up(&rootfs_futex);
364	free(buf);	364	free(buf);
365	ipc_answer_0(rid, EOK);	365	ipc_answer_0(rid, EOK);
366	return;	366	return;
367	} else {	367	} else {
368	/*	368	/*
369	* We can't resolve this without the root filesystem	369	* We can't resolve this without the root filesystem
370	* being mounted first.	370	* being mounted first.
371	*/	371	*/
372	futex_up(&rootfs_futex);	372	futex_up(&rootfs_futex);
373	free(buf);	373	free(buf);
374	vfs_node_put(mr_node); /* failed -> drop reference */	374	vfs_node_put(mr_node); /* failed -> drop reference */
375	ipc_answer_0(rid, ENOENT);	375	ipc_answer_0(rid, ENOENT);
376	return;	376	return;
377	}	377	}
378	}	378	}
379	futex_up(&rootfs_futex);	379	futex_up(&rootfs_futex);
380		380
381	free(buf); /* The buffer is not needed anymore. */	381	free(buf); /* The buffer is not needed anymore. */
382		382
383	/*	383	/*
384	* At this point, we have all necessary pieces: file system and device	384	* At this point, we have all necessary pieces: file system and device
385	* handles, and we know the mount point VFS node and also the root node	385	* handles, and we know the mount point VFS node and also the root node
386	* of the file system being mounted.	386	* of the file system being mounted.
387	*/	387	*/
388		388
389	int phone = vfs_grab_phone(mp_res.triplet.fs_handle);	389	int phone = vfs_grab_phone(mp_res.triplet.fs_handle);
390	/* Later we can use ARG3 to pass mode/flags. */	390	/* Later we can use ARG3 to pass mode/flags. */
391	aid_t req1 = async_send_3(phone, VFS_MOUNT,	391	aid_t req1 = async_send_3(phone, VFS_MOUNT,
392	(ipcarg_t) mp_res.triplet.dev_handle,	392	(ipcarg_t) mp_res.triplet.dev_handle,
393	(ipcarg_t) mp_res.triplet.index, 0, NULL);	393	(ipcarg_t) mp_res.triplet.index, 0, NULL);
394	/* The second call uses the same method. */	394	/* The second call uses the same method. */
395	aid_t req2 = async_send_3(phone, VFS_MOUNT,	395	aid_t req2 = async_send_3(phone, VFS_MOUNT,
396	(ipcarg_t) mr_res.triplet.fs_handle,	396	(ipcarg_t) mr_res.triplet.fs_handle,
397	(ipcarg_t) mr_res.triplet.dev_handle,	397	(ipcarg_t) mr_res.triplet.dev_handle,
398	(ipcarg_t) mr_res.triplet.index, NULL);	398	(ipcarg_t) mr_res.triplet.index, NULL);
399	vfs_release_phone(phone);	399	vfs_release_phone(phone);
400		400
401	ipcarg_t rc1;	401	ipcarg_t rc1;
402	ipcarg_t rc2;	402	ipcarg_t rc2;
403	async_wait_for(req1, &rc1);	403	async_wait_for(req1, &rc1);
404	async_wait_for(req2, &rc2);	404	async_wait_for(req2, &rc2);
405		405
406	if ((rc1 != EOK) \|\| (rc2 != EOK)) {	406	if ((rc1 != EOK) \|\| (rc2 != EOK)) {
407	/* Mount failed, drop references to mr_node and mp_node. */	407	/* Mount failed, drop references to mr_node and mp_node. */
408	vfs_node_put(mr_node);	408	vfs_node_put(mr_node);
409	if (mp_node)	409	if (mp_node)
410	vfs_node_put(mp_node);	410	vfs_node_put(mp_node);
411	}	411	}
412		412
413	if (rc2 == EOK)	413	if (rc2 == EOK)
414	ipc_answer_0(rid, rc1);	414	ipc_answer_0(rid, rc1);
415	else if (rc1 == EOK)	415	else if (rc1 == EOK)
416	ipc_answer_0(rid, rc2);	416	ipc_answer_0(rid, rc2);
417	else	417	else
418	ipc_answer_0(rid, rc1);	418	ipc_answer_0(rid, rc1);
419	}	419	}
420		420
421	void vfs_open(ipc_callid_t rid, ipc_call_t *request)	421	void vfs_open(ipc_callid_t rid, ipc_call_t *request)
422	{	422	{
423	if (!vfs_files_init()) {	423	if (!vfs_files_init()) {
424	ipc_answer_0(rid, ENOMEM);	424	ipc_answer_0(rid, ENOMEM);
425	return;	425	return;
426	}	426	}
427		427
428	/*	428	/*
429	* The POSIX interface is open(path, flags, mode).	429	* The POSIX interface is open(path, flags, mode).
430	* We can receive flags and mode along with the VFS_OPEN call; the path	430	* We can receive flags and mode along with the VFS_OPEN call; the path
431	* will need to arrive in another call.	431	* will need to arrive in another call.
432	*/	432	*/
433	int flags = IPC_GET_ARG1(*request);	433	int flags = IPC_GET_ARG1(*request);
434	int mode = IPC_GET_ARG2(*request);	434	int mode = IPC_GET_ARG2(*request);
435	size_t len;	435	size_t len;
436		436
437	ipc_callid_t callid;	437	ipc_callid_t callid;
438		438
439	if (!ipc_data_write_receive(&callid, &len)) {	439	if (!ipc_data_write_receive(&callid, &len)) {
440	ipc_answer_0(callid, EINVAL);	440	ipc_answer_0(callid, EINVAL);
441	ipc_answer_0(rid, EINVAL);	441	ipc_answer_0(rid, EINVAL);
442	return;	442	return;
443	}	443	}
444		444
445	/*	445	/*
446	* Now we are on the verge of accepting the path.	446	* Now we are on the verge of accepting the path.
447	*	447	*
448	* There is one optimization we could do in the future: copy the path	448	* There is one optimization we could do in the future: copy the path
449	* directly into the PLB using some kind of a callback.	449	* directly into the PLB using some kind of a callback.
450	*/	450	*/
451	char *path = malloc(len);	451	char *path = malloc(len);
452		452
453	if (!path) {	453	if (!path) {
454	ipc_answer_0(callid, ENOMEM);	454	ipc_answer_0(callid, ENOMEM);
455	ipc_answer_0(rid, ENOMEM);	455	ipc_answer_0(rid, ENOMEM);
456	return;	456	return;
457	}	457	}
458		458
459	int rc;	459	int rc;
460	if ((rc = ipc_data_write_finalize(callid, path, len))) {	460	if ((rc = ipc_data_write_finalize(callid, path, len))) {
461	ipc_answer_0(rid, rc);	461	ipc_answer_0(rid, rc);
462	free(path);	462	free(path);
463	return;	463	return;
464	}	464	}
465		465
466	/*	466	/*
467	* Avoid the race condition in which the file can be deleted before we	467	* Avoid the race condition in which the file can be deleted before we
468	* find/create-and-lock the VFS node corresponding to the looked-up	468	* find/create-and-lock the VFS node corresponding to the looked-up
469	* triplet.	469	* triplet.
470	*/	470	*/
471	rwlock_read_lock(&namespace_rwlock);	471	rwlock_read_lock(&namespace_rwlock);
472		472
473	/*	473	/*
474	* The path is now populated and we can call vfs_lookup_internal().	474	* The path is now populated and we can call vfs_lookup_internal().
475	*/	475	*/
476	vfs_lookup_res_t lr;	476	vfs_lookup_res_t lr;
477	rc = vfs_lookup_internal(path, len, &lr, NULL);	477	rc = vfs_lookup_internal(path, len, &lr, NULL);
478	if (rc) {	478	if (rc) {
479	rwlock_read_unlock(&namespace_rwlock);	479	rwlock_read_unlock(&namespace_rwlock);
480	ipc_answer_0(rid, rc);	480	ipc_answer_0(rid, rc);
481	free(path);	481	free(path);
482	return;	482	return;
483	}	483	}
484		484
485	/*	485	/*
486	* Path is no longer needed.	486	* Path is no longer needed.
487	*/	487	*/
488	free(path);	488	free(path);
489		489
490	vfs_node_t *node = vfs_node_get(&lr);	490	vfs_node_t *node = vfs_node_get(&lr);
491	rwlock_read_unlock(&namespace_rwlock);	491	rwlock_read_unlock(&namespace_rwlock);
492		492
493	/*	493	/*
494	* Get ourselves a file descriptor and the corresponding vfs_file_t	494	* Get ourselves a file descriptor and the corresponding vfs_file_t
495	* structure.	495	* structure.
496	*/	496	*/
497	int fd = vfs_fd_alloc();	497	int fd = vfs_fd_alloc();
498	if (fd < 0) {	498	if (fd < 0) {
499	vfs_node_put(node);	499	vfs_node_put(node);
500	ipc_answer_0(rid, fd);	500	ipc_answer_0(rid, fd);

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/vfs/vfs_ops.c – Rev 2691 → 2693