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


/*
 * Copyright (c) 2008 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup 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);
}
 
/** 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 next = IPC_GET_ARG1(*request);
    unsigned last = IPC_GET_ARG2(*request);
    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 */
 
    if (last < next)
        last += PLB_SIZE;
 
    void *par = NULL;
    void *cur = ops->root_get();
    void *tmp = ops->child_get(cur);
 
    if (ops->plb_get_char(next) == '/')
        next++;     /* eat slash */
   
    char component[NAME_MAX + 1];
    int len = 0;
    while (tmp && next <= last) {
 
        /* collect the component */
        if (ops->plb_get_char(next) != '/') {
            if (len + 1 == NAME_MAX) {
                /* comopnent length overflow */
                ipc_answer_0(rid, ENAMETOOLONG);
                return;
            }
            component[len++] = ops->plb_get_char(next);
            next++; /* process next character */
            if (next <= last)
                continue;
        }
 
        assert(len);
        component[len] = '\0';
        next++;     /* eat slash */
        len = 0;
 
        /* match the component */
        while (tmp && !ops->match(cur, tmp, component))
            tmp = ops->sibling_get(tmp);
 
        /* handle miss: match amongst siblings */
        if (!tmp) {
            if (next <= last) {
                /* there are unprocessed components */
                ipc_answer_0(rid, ENOENT);
                return;
            }
            /* 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);
                    return;
                }
                void *nodep;
                if (lflag & L_CREATE)
                    nodep = ops->create(lflag);
                else
                    nodep = ops->node_get(fs_handle,
                        dev_handle, index);
                if (nodep) {
                    if (!ops->link(cur, nodep, component)) {
                        if (lflag & L_CREATE)
                            ops->destroy(nodep);
                        ipc_answer_0(rid, ENOSPC);
                    } else {
                        ipc_answer_5(rid, EOK,
                            fs_handle, dev_handle,
                            ops->index_get(nodep),
                            ops->size_get(nodep),
                            ops->lnkcnt_get(nodep));
                    }
                } else {
                    ipc_answer_0(rid, ENOSPC);
                }
                return;
            } else if (lflag & L_PARENT) {
                /* return parent */
                ipc_answer_5(rid, EOK, fs_handle, dev_handle,
                    ops->index_get(cur), ops->size_get(cur),
                    ops->lnkcnt_get(cur));
            }
            ipc_answer_0(rid, ENOENT);
            return;
        }
 
        /* descend one level */
        par = cur;
        cur = tmp;
        tmp = ops->child_get(tmp);
    }
 
    /* handle miss: excessive components */
    if (!tmp && next <= last) {
        if (lflag & (L_CREATE | L_LINK)) {
            if (!ops->is_directory(cur)) {
                ipc_answer_0(rid, ENOTDIR);
                return;
            }
 
            /* collect next component */
            while (next <= last) {
                if (ops->plb_get_char(next) == '/') {
                    /* more than one component */
                    ipc_answer_0(rid, ENOENT);
                    return;
                }
                if (len + 1 == NAME_MAX) {
                    /* component length overflow */
                    ipc_answer_0(rid, ENAMETOOLONG);
                    return;
                }
                component[len++] = ops->plb_get_char(next);
                next++; /* process next character */
            }
            assert(len);
            component[len] = '\0';
            len = 0;
               
            void *nodep;
            if (lflag & L_CREATE)
                nodep = ops->create(lflag);
            else
                nodep = ops->node_get(fs_handle, dev_handle,
                    index);
            if (nodep) {
                if (!ops->link(cur, nodep, component)) {
                    if (lflag & L_CREATE)
                        ops->destroy(nodep);
                    ipc_answer_0(rid, ENOSPC);
                } else {
                    ipc_answer_5(rid, EOK,
                        fs_handle, dev_handle,
                        ops->index_get(nodep),
                        ops->size_get(nodep),
                        ops->lnkcnt_get(nodep));
                }
            } else {
                ipc_answer_0(rid, ENOSPC);
            }
            return;
        }
        ipc_answer_0(rid, ENOENT);
        return;
    }
 
    /* handle hit */
    if (lflag & L_PARENT) {
        cur = par;
        if (!cur) {
            ipc_answer_0(rid, ENOENT);
            return;
        }
    }
    if (lflag & L_UNLINK) {
        unsigned old_lnkcnt = ops->lnkcnt_get(cur);
        int res = ops->unlink(par, cur);
        ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
            ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
        return;
    }
    if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
        (lflag & L_LINK)) {
        ipc_answer_0(rid, EEXIST);
        return;
    }
    if ((lflag & L_FILE) && (ops->is_directory(cur))) {
        ipc_answer_0(rid, EISDIR);
        return;
    }
    if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
        ipc_answer_0(rid, ENOTDIR);
        return;
    }
 
    ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
        ops->size_get(cur), ops->lnkcnt_get(cur));
}
 
/** @}
 */
 

Rev 2763	Rev 2770
1	/*	1	/*
2	* Copyright (c) 2008 Jakub Jermar	2	* Copyright (c) 2008 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup 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	/** Lookup VFS triplet by name in the file system name space.	125	/** Lookup VFS triplet by name in the file system name space.
126	*	126	*
127	* The path passed in the PLB must be in the canonical file system path format	127	* The path passed in the PLB must be in the canonical file system path format
128	* as returned by the canonify() function.	128	* as returned by the canonify() function.
129	*	129	*
130	* @param ops libfs operations structure with function pointers to	130	* @param ops libfs operations structure with function pointers to
131	* file system implementation	131	* file system implementation
132	* @param fs_handle File system handle of the file system where to perform	132	* @param fs_handle File system handle of the file system where to perform
133	* the lookup.	133	* the lookup.
134	* @param rid Request ID of the VFS_LOOKUP request.	134	* @param rid Request ID of the VFS_LOOKUP request.
135	* @param request VFS_LOOKUP request data itself.	135	* @param request VFS_LOOKUP request data itself.
136	*/	136	*/
137	void libfs_lookup(libfs_ops_t *ops, int fs_handle, ipc_callid_t rid,	137	void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
138	ipc_call_t *request)	138	ipc_call_t *request)
139	{	139	{
140	unsigned next = IPC_GET_ARG1(*request);	140	unsigned next = IPC_GET_ARG1(*request);
141	unsigned last = IPC_GET_ARG2(*request);	141	unsigned last = IPC_GET_ARG2(*request);
142	int dev_handle = IPC_GET_ARG3(*request);	142	dev_handle_t dev_handle = IPC_GET_ARG3(*request);
143	int lflag = IPC_GET_ARG4(*request);	143	int lflag = IPC_GET_ARG4(*request);
144	int index = IPC_GET_ARG5(request); / when L_LINK specified */	144	fs_index_t index = IPC_GET_ARG5(request); / when L_LINK specified */
145		145
146	if (last < next)	146	if (last < next)
147	last += PLB_SIZE;	147	last += PLB_SIZE;
148		148
149	void *par = NULL;	149	void *par = NULL;
150	void *cur = ops->root_get();	150	void *cur = ops->root_get();
151	void *tmp = ops->child_get(cur);	151	void *tmp = ops->child_get(cur);
152		152
153	if (ops->plb_get_char(next) == '/')	153	if (ops->plb_get_char(next) == '/')
154	next++; /* eat slash */	154	next++; /* eat slash */
155		155
156	char component[NAME_MAX + 1];	156	char component[NAME_MAX + 1];
157	int len = 0;	157	int len = 0;
158	while (tmp && next <= last) {	158	while (tmp && next <= last) {
159		159
160	/* collect the component */	160	/* collect the component */
161	if (ops->plb_get_char(next) != '/') {	161	if (ops->plb_get_char(next) != '/') {
162	if (len + 1 == NAME_MAX) {	162	if (len + 1 == NAME_MAX) {
163	/* comopnent length overflow */	163	/* comopnent length overflow */
164	ipc_answer_0(rid, ENAMETOOLONG);	164	ipc_answer_0(rid, ENAMETOOLONG);
165	return;	165	return;
166	}	166	}
167	component[len++] = ops->plb_get_char(next);	167	component[len++] = ops->plb_get_char(next);
168	next++; /* process next character */	168	next++; /* process next character */
169	if (next <= last)	169	if (next <= last)
170	continue;	170	continue;
171	}	171	}
172		172
173	assert(len);	173	assert(len);
174	component[len] = '\0';	174	component[len] = '\0';
175	next++; /* eat slash */	175	next++; /* eat slash */
176	len = 0;	176	len = 0;
177		177
178	/* match the component */	178	/* match the component */
179	while (tmp && !ops->match(cur, tmp, component))	179	while (tmp && !ops->match(cur, tmp, component))
180	tmp = ops->sibling_get(tmp);	180	tmp = ops->sibling_get(tmp);
181		181
182	/* handle miss: match amongst siblings */	182	/* handle miss: match amongst siblings */
183	if (!tmp) {	183	if (!tmp) {
184	if (next <= last) {	184	if (next <= last) {
185	/* there are unprocessed components */	185	/* there are unprocessed components */
186	ipc_answer_0(rid, ENOENT);	186	ipc_answer_0(rid, ENOENT);
187	return;	187	return;
188	}	188	}
189	/* miss in the last component */	189	/* miss in the last component */
190	if (lflag & (L_CREATE \| L_LINK)) {	190	if (lflag & (L_CREATE \| L_LINK)) {
191	/* request to create a new link */	191	/* request to create a new link */
192	if (!ops->is_directory(cur)) {	192	if (!ops->is_directory(cur)) {
193	ipc_answer_0(rid, ENOTDIR);	193	ipc_answer_0(rid, ENOTDIR);
194	return;	194	return;
195	}	195	}
196	void *nodep;	196	void *nodep;
197	if (lflag & L_CREATE)	197	if (lflag & L_CREATE)
198	nodep = ops->create(lflag);	198	nodep = ops->create(lflag);
199	else	199	else
200	nodep = ops->node_get(fs_handle,	200	nodep = ops->node_get(fs_handle,
201	dev_handle, index);	201	dev_handle, index);
202	if (nodep) {	202	if (nodep) {
203	if (!ops->link(cur, nodep, component)) {	203	if (!ops->link(cur, nodep, component)) {
204	if (lflag & L_CREATE)	204	if (lflag & L_CREATE)
205	ops->destroy(nodep);	205	ops->destroy(nodep);
206	ipc_answer_0(rid, ENOSPC);	206	ipc_answer_0(rid, ENOSPC);
207	} else {	207	} else {
208	ipc_answer_5(rid, EOK,	208	ipc_answer_5(rid, EOK,
209	fs_handle, dev_handle,	209	fs_handle, dev_handle,
210	ops->index_get(nodep),	210	ops->index_get(nodep),
211	ops->size_get(nodep),	211	ops->size_get(nodep),
212	ops->lnkcnt_get(nodep));	212	ops->lnkcnt_get(nodep));
213	}	213	}
214	} else {	214	} else {
215	ipc_answer_0(rid, ENOSPC);	215	ipc_answer_0(rid, ENOSPC);
216	}	216	}
217	return;	217	return;
218	} else if (lflag & L_PARENT) {	218	} else if (lflag & L_PARENT) {
219	/* return parent */	219	/* return parent */
220	ipc_answer_5(rid, EOK, fs_handle, dev_handle,	220	ipc_answer_5(rid, EOK, fs_handle, dev_handle,
221	ops->index_get(cur), ops->size_get(cur),	221	ops->index_get(cur), ops->size_get(cur),
222	ops->lnkcnt_get(cur));	222	ops->lnkcnt_get(cur));
223	}	223	}
224	ipc_answer_0(rid, ENOENT);	224	ipc_answer_0(rid, ENOENT);
225	return;	225	return;
226	}	226	}
227		227
228	/* descend one level */	228	/* descend one level */
229	par = cur;	229	par = cur;
230	cur = tmp;	230	cur = tmp;
231	tmp = ops->child_get(tmp);	231	tmp = ops->child_get(tmp);
232	}	232	}
233		233
234	/* handle miss: excessive components */	234	/* handle miss: excessive components */
235	if (!tmp && next <= last) {	235	if (!tmp && next <= last) {
236	if (lflag & (L_CREATE \| L_LINK)) {	236	if (lflag & (L_CREATE \| L_LINK)) {
237	if (!ops->is_directory(cur)) {	237	if (!ops->is_directory(cur)) {
238	ipc_answer_0(rid, ENOTDIR);	238	ipc_answer_0(rid, ENOTDIR);
239	return;	239	return;
240	}	240	}
241		241
242	/* collect next component */	242	/* collect next component */
243	while (next <= last) {	243	while (next <= last) {
244	if (ops->plb_get_char(next) == '/') {	244	if (ops->plb_get_char(next) == '/') {
245	/* more than one component */	245	/* more than one component */
246	ipc_answer_0(rid, ENOENT);	246	ipc_answer_0(rid, ENOENT);
247	return;	247	return;
248	}	248	}
249	if (len + 1 == NAME_MAX) {	249	if (len + 1 == NAME_MAX) {
250	/* component length overflow */	250	/* component length overflow */
251	ipc_answer_0(rid, ENAMETOOLONG);	251	ipc_answer_0(rid, ENAMETOOLONG);
252	return;	252	return;
253	}	253	}
254	component[len++] = ops->plb_get_char(next);	254	component[len++] = ops->plb_get_char(next);
255	next++; /* process next character */	255	next++; /* process next character */
256	}	256	}
257	assert(len);	257	assert(len);
258	component[len] = '\0';	258	component[len] = '\0';
259	len = 0;	259	len = 0;
260		260
261	void *nodep;	261	void *nodep;
262	if (lflag & L_CREATE)	262	if (lflag & L_CREATE)
263	nodep = ops->create(lflag);	263	nodep = ops->create(lflag);
264	else	264	else
265	nodep = ops->node_get(fs_handle, dev_handle,	265	nodep = ops->node_get(fs_handle, dev_handle,
266	index);	266	index);
267	if (nodep) {	267	if (nodep) {
268	if (!ops->link(cur, nodep, component)) {	268	if (!ops->link(cur, nodep, component)) {
269	if (lflag & L_CREATE)	269	if (lflag & L_CREATE)
270	ops->destroy(nodep);	270	ops->destroy(nodep);
271	ipc_answer_0(rid, ENOSPC);	271	ipc_answer_0(rid, ENOSPC);
272	} else {	272	} else {
273	ipc_answer_5(rid, EOK,	273	ipc_answer_5(rid, EOK,
274	fs_handle, dev_handle,	274	fs_handle, dev_handle,
275	ops->index_get(nodep),	275	ops->index_get(nodep),
276	ops->size_get(nodep),	276	ops->size_get(nodep),
277	ops->lnkcnt_get(nodep));	277	ops->lnkcnt_get(nodep));
278	}	278	}
279	} else {	279	} else {
280	ipc_answer_0(rid, ENOSPC);	280	ipc_answer_0(rid, ENOSPC);
281	}	281	}
282	return;	282	return;
283	}	283	}
284	ipc_answer_0(rid, ENOENT);	284	ipc_answer_0(rid, ENOENT);
285	return;	285	return;
286	}	286	}
287		287
288	/* handle hit */	288	/* handle hit */
289	if (lflag & L_PARENT) {	289	if (lflag & L_PARENT) {
290	cur = par;	290	cur = par;
291	if (!cur) {	291	if (!cur) {
292	ipc_answer_0(rid, ENOENT);	292	ipc_answer_0(rid, ENOENT);
293	return;	293	return;
294	}	294	}
295	}	295	}
296	if (lflag & L_UNLINK) {	296	if (lflag & L_UNLINK) {
297	unsigned old_lnkcnt = ops->lnkcnt_get(cur);	297	unsigned old_lnkcnt = ops->lnkcnt_get(cur);
298	int res = ops->unlink(par, cur);	298	int res = ops->unlink(par, cur);
299	ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,	299	ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
300	ops->index_get(cur), ops->size_get(cur), old_lnkcnt);	300	ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
301	return;	301	return;
302	}	302	}
303	if (((lflag & (L_CREATE \| L_EXCLUSIVE)) == (L_CREATE \| L_EXCLUSIVE)) \|\|	303	if (((lflag & (L_CREATE \| L_EXCLUSIVE)) == (L_CREATE \| L_EXCLUSIVE)) \|\|
304	(lflag & L_LINK)) {	304	(lflag & L_LINK)) {
305	ipc_answer_0(rid, EEXIST);	305	ipc_answer_0(rid, EEXIST);
306	return;	306	return;
307	}	307	}
308	if ((lflag & L_FILE) && (ops->is_directory(cur))) {	308	if ((lflag & L_FILE) && (ops->is_directory(cur))) {
309	ipc_answer_0(rid, EISDIR);	309	ipc_answer_0(rid, EISDIR);
310	return;	310	return;
311	}	311	}
312	if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {	312	if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
313	ipc_answer_0(rid, ENOTDIR);	313	ipc_answer_0(rid, ENOTDIR);
314	return;	314	return;
315	}	315	}
316		316
317	ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),	317	ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
318	ops->size_get(cur), ops->lnkcnt_get(cur));	318	ops->size_get(cur), ops->lnkcnt_get(cur));
319	}	319	}
320		320
321	/** @}	321	/** @}
322	*/	322	*/
323		323

Subversion Repositories HelenOS

(root)/trunk/uspace/lib/libfs/libfs.c – Rev 2763 → 2770