WebSVN – HelenOS – Diff – /branches/network/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);
}
 
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 2690	Rev 2691
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 node structure where the result will be stored.	73	* @param result Empty structure where the lookup result will be stored.
74	* @param size Storage where the size of the node will be stored. Can	-
75	* be NULL.	-
76	* @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
77	* of the whole VFS tree.	75	* of the whole VFS tree.
78	*	76	*
79	* @return EOK on success or an error code from errno.h.	77	* @return EOK on success or an error code from errno.h.
80	*/	78	*/
81	int vfs_lookup_internal(char path, size_t len, vfs_triplet_t result,	79	int vfs_lookup_internal(char path, size_t len, vfs_lookup_res_t result,
82	size_t size, vfs_pair_t altroot)	80	vfs_pair_t *altroot)
83	{	81	{
84	vfs_pair_t *root;	82	vfs_pair_t *root;
85		83
86	if (!len)	84	if (!len)
87	return EINVAL;	85	return EINVAL;
88		86
89	if (altroot)	87	if (altroot)
90	root = altroot;	88	root = altroot;
91	else	89	else
92	root = (vfs_pair_t *) &rootfs;	90	root = (vfs_pair_t *) &rootfs;
93		91
94	if (!root->fs_handle)	92	if (!root->fs_handle)
95	return ENOENT;	93	return ENOENT;
96		94
97	futex_down(&plb_futex);	95	futex_down(&plb_futex);
98		96
99	plb_entry_t entry;	97	plb_entry_t entry;
100	link_initialize(&entry.plb_link);	98	link_initialize(&entry.plb_link);
101	entry.len = len;	99	entry.len = len;
102		100
103	off_t first; /* the first free index */	101	off_t first; /* the first free index */
104	off_t last; /* the last free index */	102	off_t last; /* the last free index */
105		103
106	if (list_empty(&plb_head)) {	104	if (list_empty(&plb_head)) {
107	first = 0;	105	first = 0;
108	last = PLB_SIZE - 1;	106	last = PLB_SIZE - 1;
109	} else {	107	} else {
110	plb_entry_t *oldest = list_get_instance(plb_head.next,	108	plb_entry_t *oldest = list_get_instance(plb_head.next,
111	plb_entry_t, plb_link);	109	plb_entry_t, plb_link);
112	plb_entry_t *newest = list_get_instance(plb_head.prev,	110	plb_entry_t *newest = list_get_instance(plb_head.prev,
113	plb_entry_t, plb_link);	111	plb_entry_t, plb_link);
114		112
115	first = (newest->index + newest->len) % PLB_SIZE;	113	first = (newest->index + newest->len) % PLB_SIZE;
116	last = (oldest->index - 1) % PLB_SIZE;	114	last = (oldest->index - 1) % PLB_SIZE;
117	}	115	}
118		116
119	if (first <= last) {	117	if (first <= last) {
120	if ((last - first) + 1 < len) {	118	if ((last - first) + 1 < len) {
121	/*	119	/*
122	* The buffer cannot absorb the path.	120	* The buffer cannot absorb the path.
123	*/	121	*/
124	futex_up(&plb_futex);	122	futex_up(&plb_futex);
125	return ELIMIT;	123	return ELIMIT;
126	}	124	}
127	} else {	125	} else {
128	if (PLB_SIZE - ((first - last) + 1) < len) {	126	if (PLB_SIZE - ((first - last) + 1) < len) {
129	/*	127	/*
130	* The buffer cannot absorb the path.	128	* The buffer cannot absorb the path.
131	*/	129	*/
132	futex_up(&plb_futex);	130	futex_up(&plb_futex);
133	return ELIMIT;	131	return ELIMIT;
134	}	132	}
135	}	133	}
136		134
137	/*	135	/*
138	* 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
139	* enough space in the buffer to hold our path.	137	* enough space in the buffer to hold our path.
140	*/	138	*/
141		139
142	entry.index = first;	140	entry.index = first;
143	entry.len = len;	141	entry.len = len;
144		142
145	/*	143	/*
146	* 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
147	* buffer.	145	* buffer.
148	*/	146	*/
149	list_append(&entry.plb_link, &plb_head);	147	list_append(&entry.plb_link, &plb_head);
150		148
151	futex_up(&plb_futex);	149	futex_up(&plb_futex);
152		150
153	/*	151	/*
154	* Copy the path into PLB.	152	* Copy the path into PLB.
155	*/	153	*/
156	size_t cnt1 = min(len, (PLB_SIZE - first) + 1);	154	size_t cnt1 = min(len, (PLB_SIZE - first) + 1);
157	size_t cnt2 = len - cnt1;	155	size_t cnt2 = len - cnt1;
158		156
159	memcpy(&plb[first], path, cnt1);	157	memcpy(&plb[first], path, cnt1);
160	memcpy(plb, &path[cnt1], cnt2);	158	memcpy(plb, &path[cnt1], cnt2);
161		159
162	ipc_call_t answer;	160	ipc_call_t answer;
163	int phone = vfs_grab_phone(root->fs_handle);	161	int phone = vfs_grab_phone(root->fs_handle);
164	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,
165	(ipcarg_t) (first + len - 1) % PLB_SIZE,	163	(ipcarg_t) (first + len - 1) % PLB_SIZE,
166	(ipcarg_t) root->dev_handle, &answer);	164	(ipcarg_t) root->dev_handle, &answer);
167	vfs_release_phone(phone);	165	vfs_release_phone(phone);
168		166
169	ipcarg_t rc;	167	ipcarg_t rc;
170	async_wait_for(req, &rc);	168	async_wait_for(req, &rc);
171		169
172	futex_down(&plb_futex);	170	futex_down(&plb_futex);
173	list_remove(&entry.plb_link);	171	list_remove(&entry.plb_link);
174	/*	172	/*
175	* Erasing the path from PLB will come handy for debugging purposes.	173	* Erasing the path from PLB will come handy for debugging purposes.
176	*/	174	*/
177	memset(&plb[first], 0, cnt1);	175	memset(&plb[first], 0, cnt1);
178	memset(plb, 0, cnt2);	176	memset(plb, 0, cnt2);
179	futex_up(&plb_futex);	177	futex_up(&plb_futex);
180		178
181	if (rc == EOK) {	179	if (rc == EOK) {
182	result->fs_handle = (int) IPC_GET_ARG1(answer);	180	result->triplet.fs_handle = (int) IPC_GET_ARG1(answer);
183	result->dev_handle = (int) IPC_GET_ARG2(answer);	181	result->triplet.dev_handle = (int) IPC_GET_ARG2(answer);
184	result->index = (int) IPC_GET_ARG3(answer);	182	result->triplet.index = (int) IPC_GET_ARG3(answer);
185	if (size)	-
186	*size = (size_t) IPC_GET_ARG4(answer);	183	result->size = (size_t) IPC_GET_ARG4(answer);
187	}	184	}
188		185
189	return rc;	186	return rc;
190	}	187	}
191		188
192	atomic_t rootfs_futex = FUTEX_INITIALIZER;	189	atomic_t rootfs_futex = FUTEX_INITIALIZER;
193	vfs_triplet_t rootfs = {	190	vfs_triplet_t rootfs = {
194	.fs_handle = 0,	191	.fs_handle = 0,
195	.dev_handle = 0,	192	.dev_handle = 0,
196	.index = 0,	193	.index = 0,
197	};	194	};
198		195
199	static int lookup_root(int fs_handle, int dev_handle, vfs_triplet_t *root,	196	static int lookup_root(int fs_handle, int dev_handle, vfs_lookup_res_t *result)
200	size_t *size)	-
201	{	197	{
202	vfs_pair_t altroot = {	198	vfs_pair_t altroot = {
203	.fs_handle = fs_handle,	199	.fs_handle = fs_handle,
204	.dev_handle = dev_handle,	200	.dev_handle = dev_handle,
205	};	201	};
206		202
207	return vfs_lookup_internal("/", strlen("/"), root, size, &altroot);	203	return vfs_lookup_internal("/", strlen("/"), result, &altroot);
208	}	204	}
209		205
210	void vfs_mount(ipc_callid_t rid, ipc_call_t *request)	206	void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
211	{	207	{
212	int dev_handle;	208	int dev_handle;
213	vfs_node_t *mp_node = NULL;	209	vfs_node_t *mp_node = NULL;
214		210
215	/*	211	/*
216	* 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
217	* translation for us, thus the device handle will arrive as ARG1	213	* translation for us, thus the device handle will arrive as ARG1
218	* in the request.	214	* in the request.
219	*/	215	*/
220	dev_handle = IPC_GET_ARG1(*request);	216	dev_handle = IPC_GET_ARG1(*request);
221		217
222	/*	218	/*
223	* 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
224	* carry mount options in the future.	220	* carry mount options in the future.
225	*/	221	*/
226		222
227	ipc_callid_t callid;	223	ipc_callid_t callid;
228	size_t size;	224	size_t size;
229		225
230	/*	226	/*
231	* 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
232	* system.	228	* system.
233	*/	229	*/
234	if (!ipc_data_write_receive(&callid, &size)) {	230	if (!ipc_data_write_receive(&callid, &size)) {
235	ipc_answer_0(callid, EINVAL);	231	ipc_answer_0(callid, EINVAL);
236	ipc_answer_0(rid, EINVAL);	232	ipc_answer_0(rid, EINVAL);
237	return;	233	return;
238	}	234	}
239		235
240	/*	236	/*
241	* 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
242	* name.	238	* name.
243	*/	239	*/
244	if (size < 1 \|\| size > FS_NAME_MAXLEN) {	240	if (size < 1 \|\| size > FS_NAME_MAXLEN) {
245	ipc_answer_0(callid, EINVAL);	241	ipc_answer_0(callid, EINVAL);
246	ipc_answer_0(rid, EINVAL);	242	ipc_answer_0(rid, EINVAL);
247	return;	243	return;
248	}	244	}
249		245
250	/*	246	/*
251	* Deliver the file system name.	247	* Deliver the file system name.
252	*/	248	*/
253	char fs_name[FS_NAME_MAXLEN + 1];	249	char fs_name[FS_NAME_MAXLEN + 1];
254	(void) ipc_data_write_finalize(callid, fs_name, size);	250	(void) ipc_data_write_finalize(callid, fs_name, size);
255	fs_name[size] = '\0';	251	fs_name[size] = '\0';
256		252
257	/*	253	/*
258	* 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.
259	* This will also give us its file system handle.	255	* This will also give us its file system handle.
260	*/	256	*/
261	int fs_handle = fs_name_to_handle(fs_name, true);	257	int fs_handle = fs_name_to_handle(fs_name, true);
262	if (!fs_handle) {	258	if (!fs_handle) {
263	ipc_answer_0(rid, ENOENT);	259	ipc_answer_0(rid, ENOENT);
264	return;	260	return;
265	}	261	}
266		262
267	/*	263	/*
268	* Now, we want the client to send us the mount point.	264	* Now, we want the client to send us the mount point.
269	*/	265	*/
270	if (!ipc_data_write_receive(&callid, &size)) {	266	if (!ipc_data_write_receive(&callid, &size)) {
271	ipc_answer_0(callid, EINVAL);	267	ipc_answer_0(callid, EINVAL);
272	ipc_answer_0(rid, EINVAL);	268	ipc_answer_0(rid, EINVAL);
273	return;	269	return;
274	}	270	}
275		271
276	/*	272	/*
277	* Check whether size is reasonable wrt. the mount point.	273	* Check whether size is reasonable wrt. the mount point.
278	*/	274	*/
279	if (size < 1 \|\| size > MAX_PATH_LEN) {	275	if (size < 1 \|\| size > MAX_PATH_LEN) {
280	ipc_answer_0(callid, EINVAL);	276	ipc_answer_0(callid, EINVAL);
281	ipc_answer_0(rid, EINVAL);	277	ipc_answer_0(rid, EINVAL);
282	return;	278	return;
283	}	279	}
284	/*	280	/*
285	* Allocate buffer for the mount point data being received.	281	* Allocate buffer for the mount point data being received.
286	*/	282	*/
287	uint8_t *buf;	283	uint8_t *buf;
288	buf = malloc(size);	284	buf = malloc(size);
289	if (!buf) {	285	if (!buf) {
290	ipc_answer_0(callid, ENOMEM);	286	ipc_answer_0(callid, ENOMEM);
291	ipc_answer_0(rid, ENOMEM);	287	ipc_answer_0(rid, ENOMEM);
292	return;	288	return;
293	}	289	}
294		290
295	/*	291	/*
296	* Deliver the mount point.	292	* Deliver the mount point.
297	*/	293	*/
298	(void) ipc_data_write_finalize(callid, buf, size);	294	(void) ipc_data_write_finalize(callid, buf, size);
299		295
300	/*	296	/*
301	* Lookup the root node of the filesystem being mounted.	297	* Lookup the root node of the filesystem being mounted.
302	* 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
303	* 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
304	* that we can track how many times it has been mounted.	300	* that we can track how many times it has been mounted.
305	*/	301	*/
306	int rc;	302	int rc;
307	vfs_triplet_t mounted_root;	303	vfs_lookup_res_t mr_res;
308	size_t mrsz;	-
309	rc = lookup_root(fs_handle, dev_handle, &mounted_root, &mrsz);	304	rc = lookup_root(fs_handle, dev_handle, &mr_res);
310	if (rc != EOK) {	305	if (rc != EOK) {
311	free(buf);	306	free(buf);
312	ipc_answer_0(rid, rc);	307	ipc_answer_0(rid, rc);
313	return;	308	return;
314	}	309	}
315	vfs_node_t *mr_node = vfs_node_get(&mounted_root, mrsz);	310	vfs_node_t *mr_node = vfs_node_get(&mr_res);
316	if (!mr_node) {	311	if (!mr_node) {
317	free(buf);	312	free(buf);
318	ipc_answer_0(rid, ENOMEM);	313	ipc_answer_0(rid, ENOMEM);
319	return;	314	return;
320	}	315	}
321		316
322	/*	317	/*
323	* Finally, we need to resolve the path to the mountpoint.	318	* Finally, we need to resolve the path to the mountpoint.
324	*/	319	*/
325	vfs_triplet_t mp;	320	vfs_lookup_res_t mp_res;
326	size_t mpsz;	-
327	futex_down(&rootfs_futex);	321	futex_down(&rootfs_futex);
328	if (rootfs.fs_handle) {	322	if (rootfs.fs_handle) {
329	/*	323	/*
330	* We already have the root FS.	324	* We already have the root FS.
331	*/	325	*/
332	rwlock_write_lock(&namespace_rwlock);	326	rwlock_write_lock(&namespace_rwlock);
333	rc = vfs_lookup_internal(buf, size, &mp, &mpsz, NULL);	327	rc = vfs_lookup_internal(buf, size, &mp_res, NULL);
334	if (rc != EOK) {	328	if (rc != EOK) {
335	/*	329	/*
336	* The lookup failed for some reason.	330	* The lookup failed for some reason.
337	*/	331	*/
338	rwlock_write_unlock(&namespace_rwlock);	332	rwlock_write_unlock(&namespace_rwlock);
339	futex_up(&rootfs_futex);	333	futex_up(&rootfs_futex);
340	vfs_node_put(mr_node); /* failed -> drop reference */	334	vfs_node_put(mr_node); /* failed -> drop reference */
341	free(buf);	335	free(buf);
342	ipc_answer_0(rid, rc);	336	ipc_answer_0(rid, rc);
343	return;	337	return;
344	}	338	}
345	mp_node = vfs_node_get(&mp, mpsz);	339	mp_node = vfs_node_get(&mp_res);
346	if (!mp_node) {	340	if (!mp_node) {
347	rwlock_write_unlock(&namespace_rwlock);	341	rwlock_write_unlock(&namespace_rwlock);
348	futex_up(&rootfs_futex);	342	futex_up(&rootfs_futex);
349	vfs_node_put(mr_node); /* failed -> drop reference */	343	vfs_node_put(mr_node); /* failed -> drop reference */
350	free(buf);	344	free(buf);
351	ipc_answer_0(rid, ENOMEM);	345	ipc_answer_0(rid, ENOMEM);
352	return;	346	return;
353	}	347	}
354	/*	348	/*
355	* Now we hold a reference to mp_node.	349	* Now we hold a reference to mp_node.
356	* It will be dropped upon the corresponding VFS_UNMOUNT.	350	* It will be dropped upon the corresponding VFS_UNMOUNT.
357	* This prevents the mount point from being deleted.	351	* This prevents the mount point from being deleted.
358	*/	352	*/
359	rwlock_write_unlock(&namespace_rwlock);	353	rwlock_write_unlock(&namespace_rwlock);
360	} else {	354	} else {
361	/*	355	/*
362	* We still don't have the root file system mounted.	356	* We still don't have the root file system mounted.
363	*/	357	*/
364	if ((size == 1) && (buf[0] == '/')) {	358	if ((size == 1) && (buf[0] == '/')) {
365	/*	359	/*
366	* For this simple, but important case, we are done.	360	* For this simple, but important case, we are done.
367	*/	361	*/
368	rootfs = mounted_root;	362	rootfs = mr_res.triplet;
369	futex_up(&rootfs_futex);	363	futex_up(&rootfs_futex);
370	free(buf);	364	free(buf);
371	ipc_answer_0(rid, EOK);	365	ipc_answer_0(rid, EOK);
372	return;	366	return;
373	} else {	367	} else {
374	/*	368	/*
375	* We can't resolve this without the root filesystem	369	* We can't resolve this without the root filesystem
376	* being mounted first.	370	* being mounted first.
377	*/	371	*/
378	futex_up(&rootfs_futex);	372	futex_up(&rootfs_futex);
379	free(buf);	373	free(buf);
380	vfs_node_put(mr_node); /* failed -> drop reference */	374	vfs_node_put(mr_node); /* failed -> drop reference */
381	ipc_answer_0(rid, ENOENT);	375	ipc_answer_0(rid, ENOENT);
382	return;	376	return;
383	}	377	}
384	}	378	}
385	futex_up(&rootfs_futex);	379	futex_up(&rootfs_futex);
386		380
387	free(buf); /* The buffer is not needed anymore. */	381	free(buf); /* The buffer is not needed anymore. */
388		382
389	/*	383	/*
390	* 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
391	* 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
392	* of the file system being mounted.	386	* of the file system being mounted.
393	*/	387	*/
394		388
395	int phone = vfs_grab_phone(mp.fs_handle);	389	int phone = vfs_grab_phone(mp_res.triplet.fs_handle);
396	/* Later we can use ARG3 to pass mode/flags. */	390	/* Later we can use ARG3 to pass mode/flags. */
397	aid_t req1 = async_send_3(phone, VFS_MOUNT, (ipcarg_t) mp.dev_handle,	391	aid_t req1 = async_send_3(phone, VFS_MOUNT,
-		392	(ipcarg_t) mp_res.triplet.dev_handle,
398	(ipcarg_t) mp.index, 0, NULL);	393	(ipcarg_t) mp_res.triplet.index, 0, NULL);
399	/* The second call uses the same method. */	394	/* The second call uses the same method. */
400	aid_t req2 = async_send_3(phone, VFS_MOUNT,	395	aid_t req2 = async_send_3(phone, VFS_MOUNT,
401	(ipcarg_t) mounted_root.fs_handle,	396	(ipcarg_t) mr_res.triplet.fs_handle,
402	(ipcarg_t) mounted_root.dev_handle, (ipcarg_t) mounted_root.index,	397	(ipcarg_t) mr_res.triplet.dev_handle,
403	NULL);	398	(ipcarg_t) mr_res.triplet.index, NULL);
404	vfs_release_phone(phone);	399	vfs_release_phone(phone);
405		400
406	ipcarg_t rc1;	401	ipcarg_t rc1;
407	ipcarg_t rc2;	402	ipcarg_t rc2;
408	async_wait_for(req1, &rc1);	403	async_wait_for(req1, &rc1);
409	async_wait_for(req2, &rc2);	404	async_wait_for(req2, &rc2);
410		405
411	if ((rc1 != EOK) \|\| (rc2 != EOK)) {	406	if ((rc1 != EOK) \|\| (rc2 != EOK)) {
412	/* Mount failed, drop references to mr_node and mp_node. */	407	/* Mount failed, drop references to mr_node and mp_node. */
413	vfs_node_put(mr_node);	408	vfs_node_put(mr_node);
414	if (mp_node)	409	if (mp_node)
415	vfs_node_put(mp_node);	410	vfs_node_put(mp_node);
416	}	411	}
417		412
418	if (rc2 == EOK)	413	if (rc2 == EOK)
419	ipc_answer_0(rid, rc1);	414	ipc_answer_0(rid, rc1);
420	else if (rc1 == EOK)	415	else if (rc1 == EOK)
421	ipc_answer_0(rid, rc2);	416	ipc_answer_0(rid, rc2);
422	else	417	else
423	ipc_answer_0(rid, rc1);	418	ipc_answer_0(rid, rc1);
424	}	419	}
425		420
426	void vfs_open(ipc_callid_t rid, ipc_call_t *request)	421	void vfs_open(ipc_callid_t rid, ipc_call_t *request)
427	{	422	{
428	if (!vfs_files_init()) {	423	if (!vfs_files_init()) {
429	ipc_answer_0(rid, ENOMEM);	424	ipc_answer_0(rid, ENOMEM);
430	return;	425	return;
431	}	426	}
432		427
433	/*	428	/*
434	* The POSIX interface is open(path, flags, mode).	429	* The POSIX interface is open(path, flags, mode).
435	* 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
436	* will need to arrive in another call.	431	* will need to arrive in another call.
437	*/	432	*/
438	int flags = IPC_GET_ARG1(*request);	433	int flags = IPC_GET_ARG1(*request);
439	int mode = IPC_GET_ARG2(*request);	434	int mode = IPC_GET_ARG2(*request);
440	size_t len;	435	size_t len;
441		436
442	ipc_callid_t callid;	437	ipc_callid_t callid;
443		438
444	if (!ipc_data_write_receive(&callid, &len)) {	439	if (!ipc_data_write_receive(&callid, &len)) {
445	ipc_answer_0(callid, EINVAL);	440	ipc_answer_0(callid, EINVAL);
446	ipc_answer_0(rid, EINVAL);	441	ipc_answer_0(rid, EINVAL);
447	return;	442	return;
448	}	443	}
449		444
450	/*	445	/*
451	* Now we are on the verge of accepting the path.	446	* Now we are on the verge of accepting the path.
452	*	447	*
453	* 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
454	* directly into the PLB using some kind of a callback.	449	* directly into the PLB using some kind of a callback.
455	*/	450	*/
456	char *path = malloc(len);	451	char *path = malloc(len);
457		452
458	if (!path) {	453	if (!path) {
459	ipc_answer_0(callid, ENOMEM);	454	ipc_answer_0(callid, ENOMEM);
460	ipc_answer_0(rid, ENOMEM);	455	ipc_answer_0(rid, ENOMEM);
461	return;	456	return;
462	}	457	}
463		458
464	int rc;	459	int rc;
465	if ((rc = ipc_data_write_finalize(callid, path, len))) {	460	if ((rc = ipc_data_write_finalize(callid, path, len))) {
466	ipc_answer_0(rid, rc);	461	ipc_answer_0(rid, rc);
467	free(path);	462	free(path);
468	return;	463	return;
469	}	464	}
470		465
471	/*	466	/*
472	* 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
473	* 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
474	* triplet.	469	* triplet.
475	*/	470	*/
476	rwlock_read_lock(&namespace_rwlock);	471	rwlock_read_lock(&namespace_rwlock);
477		472
478	/*	473	/*
479	* 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().
480	*/	475	*/
481	vfs_triplet_t triplet;	476	vfs_lookup_res_t lr;
482	size_t size;	-
483	rc = vfs_lookup_internal(path, len, &triplet, &size, NULL);	477	rc = vfs_lookup_internal(path, len, &lr, NULL);
484	if (rc) {	478	if (rc) {
485	rwlock_read_unlock(&namespace_rwlock);	479	rwlock_read_unlock(&namespace_rwlock);
486	ipc_answer_0(rid, rc);	480	ipc_answer_0(rid, rc);
487	free(path);	481	free(path);
488	return;	482	return;
489	}	483	}
490		484
491	/*	485	/*
492	* Path is no longer needed.	486	* Path is no longer needed.
493	*/	487	*/
494	free(path);	488	free(path);
495		489
496	vfs_node_t *node = vfs_node_get(&triplet, size);	490	vfs_node_t *node = vfs_node_get(&lr);
497	rwlock_read_unlock(&namespace_rwlock);	491	rwlock_read_unlock(&namespace_rwlock);
498		492
499	/*	493	/*

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/vfs/vfs_ops.c @ 4718 – Rev 2690 → 2691