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

Subversion Repositories HelenOS

(root)/trunk/uspace/lib/libfs/libfs.c – Rev 4484 → 4584