WebSVN – HelenOS – Diff – /branches/dd/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>
 
/** 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_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_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_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_LOOKUP request.
 * @param request   VFS_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_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_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);
}
 
/** @}
 */
 

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

Subversion Repositories HelenOS

(root)/branches/dd/uspace/lib/libfs/libfs.c – Rev 4420 → 4439