WebSVN – HelenOS – Diff – /trunk/uspace/lib/libfs/libfs.c


/*
 * Copyright (c) 2009 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 libfs
 * @{
 */
/**
 * @file
 * Glue code which is commonod to all FS implementations.
 */
 
#include "libfs.h" 
#include "../../srv/vfs/vfs.h"
#include <errno.h>
#include <async.h>
#include <ipc/ipc.h>
#include <as.h>
#include <assert.h>
#include <dirent.h>
#include <mem.h>
#include <sys/stat.h>
 
/** Register file system server.
 *
 * This function abstracts away the tedious registration protocol from
 * file system implementations and lets them to reuse this registration glue
 * code.
 *
 * @param vfs_phone Open phone for communication with VFS.
 * @param reg       File system registration structure. It will be
 *          initialized by this function.
 * @param info      VFS info structure supplied by the file system
 *          implementation.
 * @param conn      Connection fibril for handling all calls originating in
 *          VFS.
 *
 * @return      EOK on success or a non-zero error code on errror.
 */
int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info,
    async_client_conn_t conn)
{
    /*
     * Tell VFS that we are here and want to get registered.
     * We use the async framework because VFS will answer the request
     * out-of-order, when it knows that the operation succeeded or failed.
     */
    ipc_call_t answer;
    aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer);
 
    /*
     * Send our VFS info structure to VFS.
     */
    int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
    if (rc != EOK) {
        async_wait_for(req, NULL);
        return rc;
    }
 
    /*
     * Ask VFS for callback connection.
     */
    ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);
 
    /*
     * Allocate piece of address space for PLB.
     */
    reg->plb_ro = as_get_mappable_page(PLB_SIZE);
    if (!reg->plb_ro) {
        async_wait_for(req, NULL);
        return ENOMEM;
    }
 
    /*
     * Request sharing the Path Lookup Buffer with VFS.
     */
    rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
    if (rc) {
        async_wait_for(req, NULL);
        return rc;
    }
     
    /*
     * Pick up the answer for the request to the VFS_IN_REQUEST call.
     */
    async_wait_for(req, NULL);
    reg->fs_handle = (int) IPC_GET_ARG1(answer);
   
    /*
     * Create a connection fibril to handle the callback connection.
     */
    async_new_connection(reg->vfs_phonehash, 0, NULL, conn);
   
    /*
     * Tell the async framework that other connections are to be handled by
     * the same connection fibril as well.
     */
    async_set_client_connection(conn);
 
    return IPC_GET_RETVAL(answer);
}
 
void fs_node_initialize(fs_node_t *fn)
{
    memset(fn, 0, sizeof(fs_node_t));
}
 
void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    ipc_call_t *request)
{
    dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request);
    fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);
    dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);
    int res;
    ipcarg_t rc;
 
    ipc_call_t call;
    ipc_callid_t callid;
 
    /* accept the phone */
    callid = async_get_call(&call);
    int mountee_phone = (int)IPC_GET_ARG1(call);
    if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) ||
        mountee_phone < 0) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
    ipc_answer_0(callid, EOK);  /* acknowledge the mountee_phone */
   
    res = ipc_data_write_receive(&callid, NULL);
    if (!res) {
        ipc_hangup(mountee_phone);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    fs_node_t *fn = ops->node_get(mp_dev_handle, mp_fs_index);
    if (!fn) {
        ipc_hangup(mountee_phone);
        ipc_answer_0(callid, ENOENT);
        ipc_answer_0(rid, ENOENT);
        return;
    }
 
    if (fn->mp_data.mp_active) {
        ipc_hangup(mountee_phone);
        ops->node_put(fn);
        ipc_answer_0(callid, EBUSY);
        ipc_answer_0(rid, EBUSY);
        return;
    }
 
    rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);
    if (rc != 0) {
        ipc_hangup(mountee_phone);
        ops->node_put(fn);
        ipc_answer_0(callid, rc);
        ipc_answer_0(rid, rc);
        return;
    }
   
    ipc_call_t answer;
    aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle,
        &answer);
    ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    async_wait_for(msg, &rc);
   
    if (rc == EOK) {
        fn->mp_data.mp_active = true;
        fn->mp_data.fs_handle = mr_fs_handle;
        fn->mp_data.dev_handle = mr_dev_handle;
        fn->mp_data.phone = mountee_phone;
    }
    /*
     * Do not release the FS node so that it stays in memory.
     */
    ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
        IPC_GET_ARG3(answer));
}
 
/** Lookup VFS triplet by name in the file system name space.
 *
 * The path passed in the PLB must be in the canonical file system path format
 * as returned by the canonify() function.
 *
 * @param ops       libfs operations structure with function pointers to
 *                  file system implementation
 * @param fs_handle File system handle of the file system where to perform
 *                  the lookup.
 * @param rid       Request ID of the VFS_OUT_LOOKUP request.
 * @param request   VFS_OUT_LOOKUP request data itself.
 *
 */
void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    ipc_call_t *request)
{
    unsigned first = IPC_GET_ARG1(*request);
    unsigned last = IPC_GET_ARG2(*request);
    unsigned next = first;
    dev_handle_t dev_handle = IPC_GET_ARG3(*request);
    int lflag = IPC_GET_ARG4(*request);
    fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
    char component[NAME_MAX + 1];
    int len;
 
    if (last < next)
        last += PLB_SIZE;
 
    fs_node_t *par = NULL;
    fs_node_t *cur = ops->root_get(dev_handle);
    fs_node_t *tmp = NULL;
 
    if (cur->mp_data.mp_active) {
        ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
            next, last, cur->mp_data.dev_handle, lflag, index,
            IPC_FF_ROUTE_FROM_ME);
        ops->node_put(cur);
        return;
    }
 
    if (ops->plb_get_char(next) == '/')
        next++;     /* eat slash */
   
    while (next <= last && ops->has_children(cur)) {
        /* collect the component */
        len = 0;
        while ((next <= last) &&  (ops->plb_get_char(next) != '/')) {
            if (len + 1 == NAME_MAX) {
                /* component length overflow */
                ipc_answer_0(rid, ENAMETOOLONG);
                goto out;
            }
            component[len++] = ops->plb_get_char(next);
            next++; /* process next character */
        }
 
        assert(len);
        component[len] = '\0';
        next++;     /* eat slash */
 
        /* match the component */
        tmp = ops->match(cur, component);
        if (tmp && tmp->mp_data.mp_active) {
            if (next > last)
                next = last = first;
            else
                next--;
               
            ipc_forward_slow(rid, tmp->mp_data.phone,
                VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle,
                lflag, index, IPC_FF_ROUTE_FROM_ME);
            ops->node_put(cur);
            ops->node_put(tmp);
            if (par)
                ops->node_put(par);
            return;
        }
 
        /* handle miss: match amongst siblings */
        if (!tmp) {
            if (next <= last) {
                /* there are unprocessed components */
                ipc_answer_0(rid, ENOENT);
                goto out;
            }
            /* miss in the last component */
            if (lflag & (L_CREATE | L_LINK)) {
                /* request to create a new link */
                if (!ops->is_directory(cur)) {
                    ipc_answer_0(rid, ENOTDIR);
                    goto out;
                }
                fs_node_t *fn;
                if (lflag & L_CREATE)
                    fn = ops->create(dev_handle, lflag);
                else
                    fn = ops->node_get(dev_handle,
                        index);
                if (fn) {
                    int rc;
 
                    rc = ops->link(cur, fn, component);
                    if (rc != EOK) {
                        if (lflag & L_CREATE) {
                            (void)ops->destroy(fn);
                        }
                        ipc_answer_0(rid, rc);
                    } else {
                        ipc_answer_5(rid, EOK,
                            fs_handle, dev_handle,
                            ops->index_get(fn),
                            ops->size_get(fn),
                            ops->lnkcnt_get(fn));
                        ops->node_put(fn);
                    }
                } else {
                    ipc_answer_0(rid, ENOSPC);
                }
                goto out;
            }
            ipc_answer_0(rid, ENOENT);
            goto out;
        }
 
        if (par)
            ops->node_put(par);
 
        /* descend one level */
        par = cur;
        cur = tmp;
        tmp = NULL;
    }
 
    /* handle miss: excessive components */
    if (next <= last && !ops->has_children(cur)) {
        if (lflag & (L_CREATE | L_LINK)) {
            if (!ops->is_directory(cur)) {
                ipc_answer_0(rid, ENOTDIR);
                goto out;
            }
 
            /* collect next component */
            len = 0;
            while (next <= last) {
                if (ops->plb_get_char(next) == '/') {
                    /* more than one component */
                    ipc_answer_0(rid, ENOENT);
                    goto out;
                }
                if (len + 1 == NAME_MAX) {
                    /* component length overflow */
                    ipc_answer_0(rid, ENAMETOOLONG);
                    goto out;
                }
                component[len++] = ops->plb_get_char(next);
                next++; /* process next character */
            }
            assert(len);
            component[len] = '\0';
               
            fs_node_t *fn;
            if (lflag & L_CREATE)
                fn = ops->create(dev_handle, lflag);
            else
                fn = ops->node_get(dev_handle, index);
            if (fn) {
                int rc;
 
                rc = ops->link(cur, fn, component);
                if (rc != EOK) {
                    if (lflag & L_CREATE)
                        (void)ops->destroy(fn);
                    ipc_answer_0(rid, rc);
                } else {
                    ipc_answer_5(rid, EOK,
                        fs_handle, dev_handle,
                        ops->index_get(fn),
                        ops->size_get(fn),
                        ops->lnkcnt_get(fn));
                    ops->node_put(fn);
                }
            } else {
                ipc_answer_0(rid, ENOSPC);
            }
            goto out;
        }
        ipc_answer_0(rid, ENOENT);
        goto out;
    }
 
    /* handle hit */
    if (lflag & L_UNLINK) {
        unsigned old_lnkcnt = ops->lnkcnt_get(cur);
        int res = ops->unlink(par, cur, component);
        ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
            ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
        goto out;
    }
    if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
        (lflag & L_LINK)) {
        ipc_answer_0(rid, EEXIST);
        goto out;
    }
    if ((lflag & L_FILE) && (ops->is_directory(cur))) {
        ipc_answer_0(rid, EISDIR);
        goto out;
    }
    if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
        ipc_answer_0(rid, ENOTDIR);
        goto out;
    }
 
    ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
        ops->size_get(cur), ops->lnkcnt_get(cur));
 
out:
    if (par)
        ops->node_put(par);
    if (cur)
        ops->node_put(cur);
    if (tmp)
        ops->node_put(tmp);
}
 
void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    fs_node_t *fn = ops->node_get(dev_handle, index);
 
    ipc_callid_t callid;
    size_t size;
    if (!ipc_data_read_receive(&callid, &size) ||
        size != sizeof(struct stat)) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
 
    struct stat stat;
 
 
 
 
    memset(&stat, 0, sizeof(struct stat));
   
    stat.fs_handle = fs_handle;
    stat.dev_handle = dev_handle;
    stat.index = index;
    stat.lnkcnt = ops->lnkcnt_get(fn);
    stat.is_file = ops->is_file(fn);
    stat.size = ops->size_get(fn);
 
    ipc_data_read_finalize(callid, &stat, sizeof(struct stat));
    ipc_answer_0(rid, EOK);
 
 
}
 
/** Open VFS triplet.
 *
 * @param ops       libfs operations structure with function pointers to
 *                  file system implementation
 * @param rid       Request ID of the VFS_OUT_OPEN_NODE request.
 * @param request   VFS_OUT_OPEN_NODE request data itself.
 *
 */
void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    ipc_call_t *request)
{
    dev_handle_t dev_handle = IPC_GET_ARG1(*request);
    fs_index_t index = IPC_GET_ARG2(*request);
   
    fs_node_t *node = ops->node_get(dev_handle, index);
   
    if (node == NULL) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
   
    ipc_answer_5(rid, EOK, fs_handle, dev_handle, index,
        ops->size_get(node), ops->lnkcnt_get(node));
   
    ops->node_put(node);
}
 
/** @}
 */
 

Rev 4586	Rev 4608
1	/*	1	/*
2	* Copyright (c) 2009 Jakub Jermar	2	* Copyright (c) 2009 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 libfs	29	/** @addtogroup libfs
30	* @{	30	* @{
31	*/	31	*/
32	/**	32	/**
33	* @file	33	* @file
34	* Glue code which is commonod to all FS implementations.	34	* Glue code which is commonod to all FS implementations.
35	*/	35	*/
36		36
37	#include "libfs.h"	37	#include "libfs.h"
38	#include "../../srv/vfs/vfs.h"	38	#include "../../srv/vfs/vfs.h"
39	#include <errno.h>	39	#include <errno.h>
40	#include <async.h>	40	#include <async.h>
41	#include <ipc/ipc.h>	41	#include <ipc/ipc.h>
42	#include <as.h>	42	#include <as.h>
43	#include <assert.h>	43	#include <assert.h>
44	#include <dirent.h>	44	#include <dirent.h>
45	#include <mem.h>	45	#include <mem.h>
46	#include <sys/stat.h>	46	#include <sys/stat.h>
47		47
48	/** Register file system server.	48	/** Register file system server.
49	*	49	*
50	* This function abstracts away the tedious registration protocol from	50	* This function abstracts away the tedious registration protocol from
51	* file system implementations and lets them to reuse this registration glue	51	* file system implementations and lets them to reuse this registration glue
52	* code.	52	* code.
53	*	53	*
54	* @param vfs_phone Open phone for communication with VFS.	54	* @param vfs_phone Open phone for communication with VFS.
55	* @param reg File system registration structure. It will be	55	* @param reg File system registration structure. It will be
56	* initialized by this function.	56	* initialized by this function.
57	* @param info VFS info structure supplied by the file system	57	* @param info VFS info structure supplied by the file system
58	* implementation.	58	* implementation.
59	* @param conn Connection fibril for handling all calls originating in	59	* @param conn Connection fibril for handling all calls originating in
60	* VFS.	60	* VFS.
61	*	61	*
62	* @return EOK on success or a non-zero error code on errror.	62	* @return EOK on success or a non-zero error code on errror.
63	*/	63	*/
64	int fs_register(int vfs_phone, fs_reg_t reg, vfs_info_t info,	64	int fs_register(int vfs_phone, fs_reg_t reg, vfs_info_t info,
65	async_client_conn_t conn)	65	async_client_conn_t conn)
66	{	66	{
67	/*	67	/*
68	* Tell VFS that we are here and want to get registered.	68	* Tell VFS that we are here and want to get registered.
69	* We use the async framework because VFS will answer the request	69	* We use the async framework because VFS will answer the request
70	* out-of-order, when it knows that the operation succeeded or failed.	70	* out-of-order, when it knows that the operation succeeded or failed.
71	*/	71	*/
72	ipc_call_t answer;	72	ipc_call_t answer;
73	aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer);	73	aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer);
74		74
75	/*	75	/*
76	* Send our VFS info structure to VFS.	76	* Send our VFS info structure to VFS.
77	*/	77	*/
78	int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));	78	int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
79	if (rc != EOK) {	79	if (rc != EOK) {
80	async_wait_for(req, NULL);	80	async_wait_for(req, NULL);
81	return rc;	81	return rc;
82	}	82	}
83		83
84	/*	84	/*
85	* Ask VFS for callback connection.	85	* Ask VFS for callback connection.
86	*/	86	*/
87	ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);	87	ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);
88		88
89	/*	89	/*
90	* Allocate piece of address space for PLB.	90	* Allocate piece of address space for PLB.
91	*/	91	*/
92	reg->plb_ro = as_get_mappable_page(PLB_SIZE);	92	reg->plb_ro = as_get_mappable_page(PLB_SIZE);
93	if (!reg->plb_ro) {	93	if (!reg->plb_ro) {
94	async_wait_for(req, NULL);	94	async_wait_for(req, NULL);
95	return ENOMEM;	95	return ENOMEM;
96	}	96	}
97		97
98	/*	98	/*
99	* Request sharing the Path Lookup Buffer with VFS.	99	* Request sharing the Path Lookup Buffer with VFS.
100	*/	100	*/
101	rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);	101	rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
102	if (rc) {	102	if (rc) {
103	async_wait_for(req, NULL);	103	async_wait_for(req, NULL);
104	return rc;	104	return rc;
105	}	105	}
106		106
107	/*	107	/*
108	* Pick up the answer for the request to the VFS_IN_REQUEST call.	108	* Pick up the answer for the request to the VFS_IN_REQUEST call.
109	*/	109	*/
110	async_wait_for(req, NULL);	110	async_wait_for(req, NULL);
111	reg->fs_handle = (int) IPC_GET_ARG1(answer);	111	reg->fs_handle = (int) IPC_GET_ARG1(answer);
112		112
113	/*	113	/*
114	* Create a connection fibril to handle the callback connection.	114	* Create a connection fibril to handle the callback connection.
115	*/	115	*/
116	async_new_connection(reg->vfs_phonehash, 0, NULL, conn);	116	async_new_connection(reg->vfs_phonehash, 0, NULL, conn);
117		117
118	/*	118	/*
119	* Tell the async framework that other connections are to be handled by	119	* Tell the async framework that other connections are to be handled by
120	* the same connection fibril as well.	120	* the same connection fibril as well.
121	*/	121	*/
122	async_set_client_connection(conn);	122	async_set_client_connection(conn);
123		123
124	return IPC_GET_RETVAL(answer);	124	return IPC_GET_RETVAL(answer);
125	}	125	}
126		126
127	void fs_node_initialize(fs_node_t *fn)	127	void fs_node_initialize(fs_node_t *fn)
128	{	128	{
129	memset(fn, 0, sizeof(fs_node_t));	129	memset(fn, 0, sizeof(fs_node_t));
130	}	130	}
131		131
132	void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,	132	void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
133	ipc_call_t *request)	133	ipc_call_t *request)
134	{	134	{
135	dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);	135	dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
136	fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request);	136	fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request);
137	fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);	137	fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);
138	dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);	138	dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);
139	int res;	139	int res;
140	ipcarg_t rc;	140	ipcarg_t rc;
141		141
142	ipc_call_t call;	142	ipc_call_t call;
143	ipc_callid_t callid;	143	ipc_callid_t callid;
144		144
145	/* accept the phone */	145	/* accept the phone */
146	callid = async_get_call(&call);	146	callid = async_get_call(&call);
147	int mountee_phone = (int)IPC_GET_ARG1(call);	147	int mountee_phone = (int)IPC_GET_ARG1(call);
148	if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) \|\|	148	if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) \|\|
149	mountee_phone < 0) {	149	mountee_phone < 0) {
150	ipc_answer_0(callid, EINVAL);	150	ipc_answer_0(callid, EINVAL);
151	ipc_answer_0(rid, EINVAL);	151	ipc_answer_0(rid, EINVAL);
152	return;	152	return;
153	}	153	}
154	ipc_answer_0(callid, EOK); /* acknowledge the mountee_phone */	154	ipc_answer_0(callid, EOK); /* acknowledge the mountee_phone */
155		155
156	res = ipc_data_write_receive(&callid, NULL);	156	res = ipc_data_write_receive(&callid, NULL);
157	if (!res) {	157	if (!res) {
158	ipc_hangup(mountee_phone);	158	ipc_hangup(mountee_phone);
159	ipc_answer_0(callid, EINVAL);	159	ipc_answer_0(callid, EINVAL);
160	ipc_answer_0(rid, EINVAL);	160	ipc_answer_0(rid, EINVAL);
161	return;	161	return;
162	}	162	}
163		163
164	fs_node_t *fn = ops->node_get(mp_dev_handle, mp_fs_index);	164	fs_node_t *fn = ops->node_get(mp_dev_handle, mp_fs_index);
165	if (!fn) {	165	if (!fn) {
166	ipc_hangup(mountee_phone);	166	ipc_hangup(mountee_phone);
167	ipc_answer_0(callid, ENOENT);	167	ipc_answer_0(callid, ENOENT);
168	ipc_answer_0(rid, ENOENT);	168	ipc_answer_0(rid, ENOENT);
169	return;	169	return;
170	}	170	}
171		171
172	if (fn->mp_data.mp_active) {	172	if (fn->mp_data.mp_active) {
173	ipc_hangup(mountee_phone);	173	ipc_hangup(mountee_phone);
174	ops->node_put(fn);	174	ops->node_put(fn);
175	ipc_answer_0(callid, EBUSY);	175	ipc_answer_0(callid, EBUSY);
176	ipc_answer_0(rid, EBUSY);	176	ipc_answer_0(rid, EBUSY);
177	return;	177	return;
178	}	178	}
179		179
180	rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);	180	rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);
181	if (rc != 0) {	181	if (rc != 0) {
182	ipc_hangup(mountee_phone);	182	ipc_hangup(mountee_phone);
183	ops->node_put(fn);	183	ops->node_put(fn);
184	ipc_answer_0(callid, rc);	184	ipc_answer_0(callid, rc);
185	ipc_answer_0(rid, rc);	185	ipc_answer_0(rid, rc);
186	return;	186	return;
187	}	187	}
188		188
189	ipc_call_t answer;	189	ipc_call_t answer;
190	aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle,	190	aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle,
191	&answer);	191	&answer);
192	ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);	192	ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
193	async_wait_for(msg, &rc);	193	async_wait_for(msg, &rc);
194		194
195	if (rc == EOK) {	195	if (rc == EOK) {
196	fn->mp_data.mp_active = true;	196	fn->mp_data.mp_active = true;
197	fn->mp_data.fs_handle = mr_fs_handle;	197	fn->mp_data.fs_handle = mr_fs_handle;
198	fn->mp_data.dev_handle = mr_dev_handle;	198	fn->mp_data.dev_handle = mr_dev_handle;
199	fn->mp_data.phone = mountee_phone;	199	fn->mp_data.phone = mountee_phone;
200	}	200	}
201	/*	201	/*
202	* Do not release the FS node so that it stays in memory.	202	* Do not release the FS node so that it stays in memory.
203	*/	203	*/
204	ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),	204	ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
205	IPC_GET_ARG3(answer));	205	IPC_GET_ARG3(answer));
206	}	206	}
207		207
208	/** Lookup VFS triplet by name in the file system name space.	208	/** Lookup VFS triplet by name in the file system name space.
209	*	209	*
210	* The path passed in the PLB must be in the canonical file system path format	210	* The path passed in the PLB must be in the canonical file system path format
211	* as returned by the canonify() function.	211	* as returned by the canonify() function.
212	*	212	*
213	* @param ops libfs operations structure with function pointers to	213	* @param ops libfs operations structure with function pointers to
214	* file system implementation	214	* file system implementation
215	* @param fs_handle File system handle of the file system where to perform	215	* @param fs_handle File system handle of the file system where to perform
216	* the lookup.	216	* the lookup.
217	* @param rid Request ID of the VFS_OUT_LOOKUP request.	217	* @param rid Request ID of the VFS_OUT_LOOKUP request.
218	* @param request VFS_OUT_LOOKUP request data itself.	218	* @param request VFS_OUT_LOOKUP request data itself.
219	*	219	*
220	*/	220	*/
221	void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,	221	void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
222	ipc_call_t *request)	222	ipc_call_t *request)
223	{	223	{
224	unsigned first = IPC_GET_ARG1(*request);	224	unsigned first = IPC_GET_ARG1(*request);
225	unsigned last = IPC_GET_ARG2(*request);	225	unsigned last = IPC_GET_ARG2(*request);
226	unsigned next = first;	226	unsigned next = first;
227	dev_handle_t dev_handle = IPC_GET_ARG3(*request);	227	dev_handle_t dev_handle = IPC_GET_ARG3(*request);
228	int lflag = IPC_GET_ARG4(*request);	228	int lflag = IPC_GET_ARG4(*request);
229	fs_index_t index = IPC_GET_ARG5(request); / when L_LINK specified */	229	fs_index_t index = IPC_GET_ARG5(request); / when L_LINK specified */
230	char component[NAME_MAX + 1];	230	char component[NAME_MAX + 1];
231	int len;	231	int len;
232		232
233	if (last < next)	233	if (last < next)
234	last += PLB_SIZE;	234	last += PLB_SIZE;
235		235
236	fs_node_t *par = NULL;	236	fs_node_t *par = NULL;
237	fs_node_t *cur = ops->root_get(dev_handle);	237	fs_node_t *cur = ops->root_get(dev_handle);
238	fs_node_t *tmp = NULL;	238	fs_node_t *tmp = NULL;
239		239
240	if (cur->mp_data.mp_active) {	240	if (cur->mp_data.mp_active) {
241	ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,	241	ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
242	next, last, cur->mp_data.dev_handle, lflag, index,	242	next, last, cur->mp_data.dev_handle, lflag, index,
243	IPC_FF_ROUTE_FROM_ME);	243	IPC_FF_ROUTE_FROM_ME);
244	ops->node_put(cur);	244	ops->node_put(cur);
245	return;	245	return;
246	}	246	}
247		247
248	if (ops->plb_get_char(next) == '/')	248	if (ops->plb_get_char(next) == '/')
249	next++; /* eat slash */	249	next++; /* eat slash */
250		250
251	while (next <= last && ops->has_children(cur)) {	251	while (next <= last && ops->has_children(cur)) {
252	/* collect the component */	252	/* collect the component */
253	len = 0;	253	len = 0;
254	while ((next <= last) && (ops->plb_get_char(next) != '/')) {	254	while ((next <= last) && (ops->plb_get_char(next) != '/')) {
255	if (len + 1 == NAME_MAX) {	255	if (len + 1 == NAME_MAX) {
256	/* component length overflow */	256	/* component length overflow */
257	ipc_answer_0(rid, ENAMETOOLONG);	257	ipc_answer_0(rid, ENAMETOOLONG);
258	goto out;	258	goto out;
259	}	259	}
260	component[len++] = ops->plb_get_char(next);	260	component[len++] = ops->plb_get_char(next);
261	next++; /* process next character */	261	next++; /* process next character */
262	}	262	}
263		263
264	assert(len);	264	assert(len);
265	component[len] = '\0';	265	component[len] = '\0';
266	next++; /* eat slash */	266	next++; /* eat slash */
267		267
268	/* match the component */	268	/* match the component */
269	tmp = ops->match(cur, component);	269	tmp = ops->match(cur, component);
270	if (tmp && tmp->mp_data.mp_active) {	270	if (tmp && tmp->mp_data.mp_active) {
271	if (next > last)	271	if (next > last)
272	next = last = first;	272	next = last = first;
273	else	273	else
274	next--;	274	next--;
275		275
276	ipc_forward_slow(rid, tmp->mp_data.phone,	276	ipc_forward_slow(rid, tmp->mp_data.phone,
277	VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle,	277	VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle,
278	lflag, index, IPC_FF_ROUTE_FROM_ME);	278	lflag, index, IPC_FF_ROUTE_FROM_ME);
279	ops->node_put(cur);	279	ops->node_put(cur);
280	ops->node_put(tmp);	280	ops->node_put(tmp);
281	if (par)	281	if (par)
282	ops->node_put(par);	282	ops->node_put(par);
283	return;	283	return;
284	}	284	}
285		285
286	/* handle miss: match amongst siblings */	286	/* handle miss: match amongst siblings */
287	if (!tmp) {	287	if (!tmp) {
288	if (next <= last) {	288	if (next <= last) {
289	/* there are unprocessed components */	289	/* there are unprocessed components */
290	ipc_answer_0(rid, ENOENT);	290	ipc_answer_0(rid, ENOENT);
291	goto out;	291	goto out;
292	}	292	}
293	/* miss in the last component */	293	/* miss in the last component */
294	if (lflag & (L_CREATE \| L_LINK)) {	294	if (lflag & (L_CREATE \| L_LINK)) {
295	/* request to create a new link */	295	/* request to create a new link */
296	if (!ops->is_directory(cur)) {	296	if (!ops->is_directory(cur)) {
297	ipc_answer_0(rid, ENOTDIR);	297	ipc_answer_0(rid, ENOTDIR);
298	goto out;	298	goto out;
299	}	299	}
300	fs_node_t *fn;	300	fs_node_t *fn;
301	if (lflag & L_CREATE)	301	if (lflag & L_CREATE)
302	fn = ops->create(dev_handle, lflag);	302	fn = ops->create(dev_handle, lflag);
303	else	303	else
304	fn = ops->node_get(dev_handle,	304	fn = ops->node_get(dev_handle,
305	index);	305	index);
306	if (fn) {	306	if (fn) {
307	int rc;	307	int rc;
308		308
309	rc = ops->link(cur, fn, component);	309	rc = ops->link(cur, fn, component);
310	if (rc != EOK) {	310	if (rc != EOK) {
311	if (lflag & L_CREATE) {	311	if (lflag & L_CREATE) {
312	(void)ops->destroy(fn);	312	(void)ops->destroy(fn);
313	}	313	}
314	ipc_answer_0(rid, rc);	314	ipc_answer_0(rid, rc);
315	} else {	315	} else {
316	ipc_answer_5(rid, EOK,	316	ipc_answer_5(rid, EOK,
317	fs_handle, dev_handle,	317	fs_handle, dev_handle,
318	ops->index_get(fn),	318	ops->index_get(fn),
319	ops->size_get(fn),	319	ops->size_get(fn),
320	ops->lnkcnt_get(fn));	320	ops->lnkcnt_get(fn));
321	ops->node_put(fn);	321	ops->node_put(fn);
322	}	322	}
323	} else {	323	} else {
324	ipc_answer_0(rid, ENOSPC);	324	ipc_answer_0(rid, ENOSPC);
325	}	325	}
326	goto out;	326	goto out;
327	}	327	}
328	ipc_answer_0(rid, ENOENT);	328	ipc_answer_0(rid, ENOENT);
329	goto out;	329	goto out;
330	}	330	}
331		331
332	if (par)	332	if (par)
333	ops->node_put(par);	333	ops->node_put(par);
334		334
335	/* descend one level */	335	/* descend one level */
336	par = cur;	336	par = cur;
337	cur = tmp;	337	cur = tmp;
338	tmp = NULL;	338	tmp = NULL;
339	}	339	}
340		340
341	/* handle miss: excessive components */	341	/* handle miss: excessive components */
342	if (next <= last && !ops->has_children(cur)) {	342	if (next <= last && !ops->has_children(cur)) {
343	if (lflag & (L_CREATE \| L_LINK)) {	343	if (lflag & (L_CREATE \| L_LINK)) {
344	if (!ops->is_directory(cur)) {	344	if (!ops->is_directory(cur)) {
345	ipc_answer_0(rid, ENOTDIR);	345	ipc_answer_0(rid, ENOTDIR);
346	goto out;	346	goto out;
347	}	347	}
348		348
349	/* collect next component */	349	/* collect next component */
350	len = 0;	350	len = 0;
351	while (next <= last) {	351	while (next <= last) {
352	if (ops->plb_get_char(next) == '/') {	352	if (ops->plb_get_char(next) == '/') {
353	/* more than one component */	353	/* more than one component */
354	ipc_answer_0(rid, ENOENT);	354	ipc_answer_0(rid, ENOENT);
355	goto out;	355	goto out;
356	}	356	}
357	if (len + 1 == NAME_MAX) {	357	if (len + 1 == NAME_MAX) {
358	/* component length overflow */	358	/* component length overflow */
359	ipc_answer_0(rid, ENAMETOOLONG);	359	ipc_answer_0(rid, ENAMETOOLONG);
360	goto out;	360	goto out;
361	}	361	}
362	component[len++] = ops->plb_get_char(next);	362	component[len++] = ops->plb_get_char(next);
363	next++; /* process next character */	363	next++; /* process next character */
364	}	364	}
365	assert(len);	365	assert(len);
366	component[len] = '\0';	366	component[len] = '\0';
367		367
368	fs_node_t *fn;	368	fs_node_t *fn;
369	if (lflag & L_CREATE)	369	if (lflag & L_CREATE)
370	fn = ops->create(dev_handle, lflag);	370	fn = ops->create(dev_handle, lflag);
371	else	371	else
372	fn = ops->node_get(dev_handle, index);	372	fn = ops->node_get(dev_handle, index);
373	if (fn) {	373	if (fn) {
374	int rc;	374	int rc;
375		375
376	rc = ops->link(cur, fn, component);	376	rc = ops->link(cur, fn, component);
377	if (rc != EOK) {	377	if (rc != EOK) {
378	if (lflag & L_CREATE)	378	if (lflag & L_CREATE)
379	(void)ops->destroy(fn);	379	(void)ops->destroy(fn);
380	ipc_answer_0(rid, rc);	380	ipc_answer_0(rid, rc);
381	} else {	381	} else {
382	ipc_answer_5(rid, EOK,	382	ipc_answer_5(rid, EOK,
383	fs_handle, dev_handle,	383	fs_handle, dev_handle,
384	ops->index_get(fn),	384	ops->index_get(fn),
385	ops->size_get(fn),	385	ops->size_get(fn),
386	ops->lnkcnt_get(fn));	386	ops->lnkcnt_get(fn));
387	ops->node_put(fn);	387	ops->node_put(fn);
388	}	388	}
389	} else {	389	} else {
390	ipc_answer_0(rid, ENOSPC);	390	ipc_answer_0(rid, ENOSPC);
391	}	391	}
392	goto out;	392	goto out;
393	}	393	}
394	ipc_answer_0(rid, ENOENT);	394	ipc_answer_0(rid, ENOENT);
395	goto out;	395	goto out;
396	}	396	}
397		397
398	/* handle hit */	398	/* handle hit */
399	if (lflag & L_UNLINK) {	399	if (lflag & L_UNLINK) {
400	unsigned old_lnkcnt = ops->lnkcnt_get(cur);	400	unsigned old_lnkcnt = ops->lnkcnt_get(cur);
401	int res = ops->unlink(par, cur, component);	401	int res = ops->unlink(par, cur, component);
402	ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,	402	ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
403	ops->index_get(cur), ops->size_get(cur), old_lnkcnt);	403	ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
404	goto out;	404	goto out;
405	}	405	}
406	if (((lflag & (L_CREATE \| L_EXCLUSIVE)) == (L_CREATE \| L_EXCLUSIVE)) \|\|	406	if (((lflag & (L_CREATE \| L_EXCLUSIVE)) == (L_CREATE \| L_EXCLUSIVE)) \|\|
407	(lflag & L_LINK)) {	407	(lflag & L_LINK)) {
408	ipc_answer_0(rid, EEXIST);	408	ipc_answer_0(rid, EEXIST);
409	goto out;	409	goto out;
410	}	410	}
411	if ((lflag & L_FILE) && (ops->is_directory(cur))) {	411	if ((lflag & L_FILE) && (ops->is_directory(cur))) {
412	ipc_answer_0(rid, EISDIR);	412	ipc_answer_0(rid, EISDIR);
413	goto out;	413	goto out;
414	}	414	}
415	if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {	415	if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
416	ipc_answer_0(rid, ENOTDIR);	416	ipc_answer_0(rid, ENOTDIR);
417	goto out;	417	goto out;
418	}	418	}
419		419
420	ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),	420	ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
421	ops->size_get(cur), ops->lnkcnt_get(cur));	421	ops->size_get(cur), ops->lnkcnt_get(cur));
422		422
423	out:	423	out:
424	if (par)	424	if (par)
425	ops->node_put(par);	425	ops->node_put(par);
426	if (cur)	426	if (cur)
427	ops->node_put(cur);	427	ops->node_put(cur);
428	if (tmp)	428	if (tmp)
429	ops->node_put(tmp);	429	ops->node_put(tmp);
430	}	430	}
431		431
432	void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,	432	void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
433	ipc_call_t *request)	433	ipc_call_t *request)
434	{	434	{
435	dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);	435	dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
436	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);	436	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
437	fs_node_t *fn = ops->node_get(dev_handle, index);	437	fs_node_t *fn = ops->node_get(dev_handle, index);
438		438
439	ipc_callid_t callid;	439	ipc_callid_t callid;
440	size_t size;	440	size_t size;
441	if (!ipc_data_read_receive(&callid, &size) \|\|	441	if (!ipc_data_read_receive(&callid, &size) \|\|
442	size < sizeof(struct stat)) {	442	size != sizeof(struct stat)) {
443	ipc_answer_0(callid, EINVAL);	443	ipc_answer_0(callid, EINVAL);
444	ipc_answer_0(rid, EINVAL);	444	ipc_answer_0(rid, EINVAL);
445	return;	445	return;
446	}	446	}
447		447
448	struct stat *stat = malloc(sizeof(struct stat));	-
449	if (!stat) {	448	struct stat stat;
450	ipc_answer_0(callid, ENOMEM);	-
451	ipc_answer_0(rid, ENOMEM);	-
452	return;	-
453	}	-
454	memset(stat, 0, sizeof(struct stat));	449	memset(&stat, 0, sizeof(struct stat));
455		450
456	stat->fs_handle = fs_handle;	451	stat.fs_handle = fs_handle;
457	stat->dev_handle = dev_handle;	452	stat.dev_handle = dev_handle;
458	stat->index = index;	453	stat.index = index;
459	stat->lnkcnt = ops->lnkcnt_get(fn);	454	stat.lnkcnt = ops->lnkcnt_get(fn);
460	stat->is_file = ops->is_file(fn);	455	stat.is_file = ops->is_file(fn);
461	stat->size = ops->size_get(fn);	456	stat.size = ops->size_get(fn);
462		457
463	ipc_data_read_finalize(callid, stat, sizeof(struct stat));	458	ipc_data_read_finalize(callid, &stat, sizeof(struct stat));
464	ipc_answer_0(rid, EOK);	459	ipc_answer_0(rid, EOK);
465		-
466	free(stat);	-
467	}	460	}
468		461
469	/** Open VFS triplet.	462	/** Open VFS triplet.
470	*	463	*
471	* @param ops libfs operations structure with function pointers to	464	* @param ops libfs operations structure with function pointers to
472	* file system implementation	465	* file system implementation
473	* @param rid Request ID of the VFS_OUT_OPEN_NODE request.	466	* @param rid Request ID of the VFS_OUT_OPEN_NODE request.
474	* @param request VFS_OUT_OPEN_NODE request data itself.	467	* @param request VFS_OUT_OPEN_NODE request data itself.
475	*	468	*
476	*/	469	*/
477	void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,	470	void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
478	ipc_call_t *request)	471	ipc_call_t *request)
479	{	472	{
480	dev_handle_t dev_handle = IPC_GET_ARG1(*request);	473	dev_handle_t dev_handle = IPC_GET_ARG1(*request);
481	fs_index_t index = IPC_GET_ARG2(*request);	474	fs_index_t index = IPC_GET_ARG2(*request);
482		475
483	fs_node_t *node = ops->node_get(dev_handle, index);	476	fs_node_t *node = ops->node_get(dev_handle, index);
484		477
485	if (node == NULL) {	478	if (node == NULL) {
486	ipc_answer_0(rid, ENOENT);	479	ipc_answer_0(rid, ENOENT);
487	return;	480	return;
488	}	481	}
489		482
490	ipc_answer_5(rid, EOK, fs_handle, dev_handle, index,	483	ipc_answer_5(rid, EOK, fs_handle, dev_handle, index,
491	ops->size_get(node), ops->lnkcnt_get(node));	484	ops->size_get(node), ops->lnkcnt_get(node));
492		485
493	ops->node_put(node);	486	ops->node_put(node);
494	}	487	}
495		488
496	/** @}	489	/** @}
497	*/	490	*/
498		491

Subversion Repositories HelenOS

(root)/trunk/uspace/lib/libfs/libfs.c @ 2770 – Rev 4586 → 4608