WebSVN – HelenOS – Diff – /branches/sparc/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 "../../srv/rd/rd.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 */
    char component[NAME_MAX + 1];
    int len;
 
    if (last < next)
        last += PLB_SIZE;
 
    void *par = NULL;
    void *cur = ops->root_get(dev_handle);
    void *tmp = NULL;
 
    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);
 
        /* 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;
                }
                void *nodep;
                if (lflag & L_CREATE)
                    nodep = ops->create(lflag);
                else
                    nodep = ops->node_get(dev_handle,
                        index);
                if (nodep) {
                    if (!ops->link(cur, nodep, component)) {
                        if (lflag & L_CREATE) {
                            (void)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));
                        ops->node_put(nodep);
                    }
                } else {
                    ipc_answer_0(rid, ENOSPC);
                }
                goto out;
            } 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);
            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';
               
            void *nodep;
            if (lflag & L_CREATE)
                nodep = ops->create(lflag);
            else
                nodep = ops->node_get(dev_handle, index);
            if (nodep) {
                if (!ops->link(cur, nodep, component)) {
                    if (lflag & L_CREATE)
                        (void)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));
                    ops->node_put(nodep);
                }
            } else {
                ipc_answer_0(rid, ENOSPC);
            }
            goto out;
        }
        ipc_answer_0(rid, ENOENT);
        goto out;
    }
 
    /* handle hit */
    if (lflag & L_PARENT) {
        ops->node_put(cur);
        cur = par;
        par = NULL;
        if (!cur) {
            ipc_answer_0(rid, ENOENT);
            goto out;
        }
    }
    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);
        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);
}
 
/** Read data from a block device.
 *
 * @param phone     Phone to be used to communicate with the device.
 * @param buffer    Communication buffer shared with the device.
 * @param bufpos    Pointer to the first unread valid offset within the
 *          communication buffer.
 * @param buflen    Pointer to the number of unread bytes that are ready in
 *          the communication buffer.
 * @param pos       Device position to be read.
 * @param dst       Destination buffer.
 * @param size      Size of the destination buffer.
 * @param block_size    Block size to be used for the transfer.
 *
 * @return      True on success, false on failure.
 */
bool libfs_blockread(int phone, void *buffer, off_t *bufpos, size_t *buflen,
    off_t *pos, void *dst, size_t size, size_t block_size)
{
    off_t offset = 0;
    size_t left = size;
   
    while (left > 0) {
        size_t rd;
       
        if (*bufpos + left < *buflen)
            rd = left;
        else
            rd = *buflen - *bufpos;
       
        if (rd > 0) {
            /*
             * Copy the contents of the communication buffer to the
             * destination buffer.
             */
            memcpy(dst + offset, buffer + *bufpos, rd);
            offset += rd;
            *bufpos += rd;
            *pos += rd;
            left -= rd;
        }
       
        if (*bufpos == *buflen) {
            /* Refill the communication buffer with a new block. */
            ipcarg_t retval;
            int rc = async_req_2_1(phone, RD_READ_BLOCK,
                *pos / block_size, block_size, &retval);
            if ((rc != EOK) || (retval != EOK))
                return false;
           
            *bufpos = 0;
            *buflen = block_size;
        }
    }
   
    return true;
}
 
/** @}
 */
 

Rev 3254	Rev 3343
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 "../../srv/rd/rd.h"	39	#include "../../srv/rd/rd.h"
40	#include <errno.h>	40	#include <errno.h>
41	#include <async.h>	41	#include <async.h>
42	#include <ipc/ipc.h>	42	#include <ipc/ipc.h>
43	#include <as.h>	43	#include <as.h>
44	#include <assert.h>	44	#include <assert.h>
45	#include <dirent.h>	45	#include <dirent.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_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_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	/** Lookup VFS triplet by name in the file system name space.	126	/** Lookup VFS triplet by name in the file system name space.
127	*	127	*
128	* The path passed in the PLB must be in the canonical file system path format	128	* The path passed in the PLB must be in the canonical file system path format
129	* as returned by the canonify() function.	129	* as returned by the canonify() function.
130	*	130	*
131	* @param ops libfs operations structure with function pointers to	131	* @param ops libfs operations structure with function pointers to
132	* file system implementation	132	* file system implementation
133	* @param fs_handle File system handle of the file system where to perform	133	* @param fs_handle File system handle of the file system where to perform
134	* the lookup.	134	* the lookup.
135	* @param rid Request ID of the VFS_LOOKUP request.	135	* @param rid Request ID of the VFS_LOOKUP request.
136	* @param request VFS_LOOKUP request data itself.	136	* @param request VFS_LOOKUP request data itself.
137	*/	137	*/
138	void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,	138	void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
139	ipc_call_t *request)	139	ipc_call_t *request)
140	{	140	{
141	unsigned next = IPC_GET_ARG1(*request);	141	unsigned next = IPC_GET_ARG1(*request);
142	unsigned last = IPC_GET_ARG2(*request);	142	unsigned last = IPC_GET_ARG2(*request);
143	dev_handle_t dev_handle = IPC_GET_ARG3(*request);	143	dev_handle_t dev_handle = IPC_GET_ARG3(*request);
144	int lflag = IPC_GET_ARG4(*request);	144	int lflag = IPC_GET_ARG4(*request);
145	fs_index_t index = IPC_GET_ARG5(request); / when L_LINK specified */	145	fs_index_t index = IPC_GET_ARG5(request); / when L_LINK specified */
146	char component[NAME_MAX + 1];	146	char component[NAME_MAX + 1];
147	int len;	147	int len;
148		148
149	if (last < next)	149	if (last < next)
150	last += PLB_SIZE;	150	last += PLB_SIZE;
151		151
152	void *par = NULL;	152	void *par = NULL;
153	void *cur = ops->root_get(dev_handle);	153	void *cur = ops->root_get(dev_handle);
154	void *tmp = NULL;	154	void *tmp = NULL;
155		155
156	if (ops->plb_get_char(next) == '/')	156	if (ops->plb_get_char(next) == '/')
157	next++; /* eat slash */	157	next++; /* eat slash */
158		158
159	while (next <= last && ops->has_children(cur)) {	159	while (next <= last && ops->has_children(cur)) {
160	/* collect the component */	160	/* collect the component */
161	len = 0;	161	len = 0;
162	while ((next <= last) && (ops->plb_get_char(next) != '/')) {	162	while ((next <= last) && (ops->plb_get_char(next) != '/')) {
163	if (len + 1 == NAME_MAX) {	163	if (len + 1 == NAME_MAX) {
164	/* component length overflow */	164	/* component length overflow */
165	ipc_answer_0(rid, ENAMETOOLONG);	165	ipc_answer_0(rid, ENAMETOOLONG);
166	goto out;	166	goto out;
167	}	167	}
168	component[len++] = ops->plb_get_char(next);	168	component[len++] = ops->plb_get_char(next);
169	next++; /* process next character */	169	next++; /* process next character */
170	}	170	}
171		171
172	assert(len);	172	assert(len);
173	component[len] = '\0';	173	component[len] = '\0';
174	next++; /* eat slash */	174	next++; /* eat slash */
175		175
176	/* match the component */	176	/* match the component */
177	tmp = ops->match(cur, component);	177	tmp = ops->match(cur, component);
178		178
179	/* handle miss: match amongst siblings */	179	/* handle miss: match amongst siblings */
180	if (!tmp) {	180	if (!tmp) {
181	if (next <= last) {	181	if (next <= last) {
182	/* there are unprocessed components */	182	/* there are unprocessed components */
183	ipc_answer_0(rid, ENOENT);	183	ipc_answer_0(rid, ENOENT);
184	goto out;	184	goto out;
185	}	185	}
186	/* miss in the last component */	186	/* miss in the last component */
187	if (lflag & (L_CREATE \| L_LINK)) {	187	if (lflag & (L_CREATE \| L_LINK)) {
188	/* request to create a new link */	188	/* request to create a new link */
189	if (!ops->is_directory(cur)) {	189	if (!ops->is_directory(cur)) {
190	ipc_answer_0(rid, ENOTDIR);	190	ipc_answer_0(rid, ENOTDIR);
191	goto out;	191	goto out;
192	}	192	}
193	void *nodep;	193	void *nodep;
194	if (lflag & L_CREATE)	194	if (lflag & L_CREATE)
195	nodep = ops->create(lflag);	195	nodep = ops->create(lflag);
196	else	196	else
197	nodep = ops->node_get(dev_handle,	197	nodep = ops->node_get(dev_handle,
198	index);	198	index);
199	if (nodep) {	199	if (nodep) {
200	if (!ops->link(cur, nodep, component)) {	200	if (!ops->link(cur, nodep, component)) {
201	if (lflag & L_CREATE) {	201	if (lflag & L_CREATE) {
202	(void)ops->destroy(	202	(void)ops->destroy(
203	nodep);	203	nodep);
204	}	204	}
205	ipc_answer_0(rid, ENOSPC);	205	ipc_answer_0(rid, ENOSPC);
206	} else {	206	} else {
207	ipc_answer_5(rid, EOK,	207	ipc_answer_5(rid, EOK,
208	fs_handle, dev_handle,	208	fs_handle, dev_handle,
209	ops->index_get(nodep),	209	ops->index_get(nodep),
210	ops->size_get(nodep),	210	ops->size_get(nodep),
211	ops->lnkcnt_get(nodep));	211	ops->lnkcnt_get(nodep));
212	ops->node_put(nodep);	212	ops->node_put(nodep);
213	}	213	}
214	} else {	214	} else {
215	ipc_answer_0(rid, ENOSPC);	215	ipc_answer_0(rid, ENOSPC);
216	}	216	}
217	goto out;	217	goto out;
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	goto out;	225	goto out;
226	}	226	}
227		227
228	if (par)	228	if (par)
229	ops->node_put(par);	229	ops->node_put(par);
230		230
231	/* descend one level */	231	/* descend one level */
232	par = cur;	232	par = cur;
233	cur = tmp;	233	cur = tmp;
234	tmp = NULL;	234	tmp = NULL;
235	}	235	}
236		236
237	/* handle miss: excessive components */	237	/* handle miss: excessive components */
238	if (next <= last && !ops->has_children(cur)) {	238	if (next <= last && !ops->has_children(cur)) {
239	if (lflag & (L_CREATE \| L_LINK)) {	239	if (lflag & (L_CREATE \| L_LINK)) {
240	if (!ops->is_directory(cur)) {	240	if (!ops->is_directory(cur)) {
241	ipc_answer_0(rid, ENOTDIR);	241	ipc_answer_0(rid, ENOTDIR);
242	goto out;	242	goto out;
243	}	243	}
244		244
245	/* collect next component */	245	/* collect next component */
246	len = 0;	246	len = 0;
247	while (next <= last) {	247	while (next <= last) {
248	if (ops->plb_get_char(next) == '/') {	248	if (ops->plb_get_char(next) == '/') {
249	/* more than one component */	249	/* more than one component */
250	ipc_answer_0(rid, ENOENT);	250	ipc_answer_0(rid, ENOENT);
251	goto out;	251	goto out;
252	}	252	}
253	if (len + 1 == NAME_MAX) {	253	if (len + 1 == NAME_MAX) {
254	/* component length overflow */	254	/* component length overflow */
255	ipc_answer_0(rid, ENAMETOOLONG);	255	ipc_answer_0(rid, ENAMETOOLONG);
256	goto out;	256	goto out;
257	}	257	}
258	component[len++] = ops->plb_get_char(next);	258	component[len++] = ops->plb_get_char(next);
259	next++; /* process next character */	259	next++; /* process next character */
260	}	260	}
261	assert(len);	261	assert(len);
262	component[len] = '\0';	262	component[len] = '\0';
263		263
264	void *nodep;	264	void *nodep;
265	if (lflag & L_CREATE)	265	if (lflag & L_CREATE)
266	nodep = ops->create(lflag);	266	nodep = ops->create(lflag);
267	else	267	else
268	nodep = ops->node_get(dev_handle, index);	268	nodep = ops->node_get(dev_handle, index);
269	if (nodep) {	269	if (nodep) {
270	if (!ops->link(cur, nodep, component)) {	270	if (!ops->link(cur, nodep, component)) {
271	if (lflag & L_CREATE)	271	if (lflag & L_CREATE)
272	(void)ops->destroy(nodep);	272	(void)ops->destroy(nodep);
273	ipc_answer_0(rid, ENOSPC);	273	ipc_answer_0(rid, ENOSPC);
274	} else {	274	} else {
275	ipc_answer_5(rid, EOK,	275	ipc_answer_5(rid, EOK,
276	fs_handle, dev_handle,	276	fs_handle, dev_handle,
277	ops->index_get(nodep),	277	ops->index_get(nodep),
278	ops->size_get(nodep),	278	ops->size_get(nodep),
279	ops->lnkcnt_get(nodep));	279	ops->lnkcnt_get(nodep));
280	ops->node_put(nodep);	280	ops->node_put(nodep);
281	}	281	}
282	} else {	282	} else {
283	ipc_answer_0(rid, ENOSPC);	283	ipc_answer_0(rid, ENOSPC);
284	}	284	}
285	goto out;	285	goto out;
286	}	286	}
287	ipc_answer_0(rid, ENOENT);	287	ipc_answer_0(rid, ENOENT);
288	goto out;	288	goto out;
289	}	289	}
290		290
291	/* handle hit */	291	/* handle hit */
292	if (lflag & L_PARENT) {	292	if (lflag & L_PARENT) {
293	ops->node_put(cur);	293	ops->node_put(cur);
294	cur = par;	294	cur = par;
295	par = NULL;	295	par = NULL;
296	if (!cur) {	296	if (!cur) {
297	ipc_answer_0(rid, ENOENT);	297	ipc_answer_0(rid, ENOENT);
298	goto out;	298	goto out;
299	}	299	}
300	}	300	}
301	if (lflag & L_UNLINK) {	301	if (lflag & L_UNLINK) {
302	unsigned old_lnkcnt = ops->lnkcnt_get(cur);	302	unsigned old_lnkcnt = ops->lnkcnt_get(cur);
303	int res = ops->unlink(par, cur);	303	int res = ops->unlink(par, cur);
304	ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,	304	ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
305	ops->index_get(cur), ops->size_get(cur), old_lnkcnt);	305	ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
306	goto out;	306	goto out;
307	}	307	}
308	if (((lflag & (L_CREATE \| L_EXCLUSIVE)) == (L_CREATE \| L_EXCLUSIVE)) \|\|	308	if (((lflag & (L_CREATE \| L_EXCLUSIVE)) == (L_CREATE \| L_EXCLUSIVE)) \|\|
309	(lflag & L_LINK)) {	309	(lflag & L_LINK)) {
310	ipc_answer_0(rid, EEXIST);	310	ipc_answer_0(rid, EEXIST);
311	goto out;	311	goto out;
312	}	312	}
313	if ((lflag & L_FILE) && (ops->is_directory(cur))) {	313	if ((lflag & L_FILE) && (ops->is_directory(cur))) {
314	ipc_answer_0(rid, EISDIR);	314	ipc_answer_0(rid, EISDIR);
315	goto out;	315	goto out;
316	}	316	}
317	if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {	317	if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
318	ipc_answer_0(rid, ENOTDIR);	318	ipc_answer_0(rid, ENOTDIR);
319	goto out;	319	goto out;
320	}	320	}
321		321
322	ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),	322	ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
323	ops->size_get(cur), ops->lnkcnt_get(cur));	323	ops->size_get(cur), ops->lnkcnt_get(cur));
324		324
325	out:	325	out:
326	if (par)	326	if (par)
327	ops->node_put(par);	327	ops->node_put(par);
328	if (cur)	328	if (cur)
329	ops->node_put(cur);	329	ops->node_put(cur);
330	if (tmp)	330	if (tmp)
331	ops->node_put(tmp);	331	ops->node_put(tmp);
332	}	332	}
333		333
334	/** Read data from a block device.	334	/** Read data from a block device.
335	*	335	*
336	* @param phone Phone to be used to communicate with the device.	336	* @param phone Phone to be used to communicate with the device.
337	* @param buffer Communication buffer shared with the device.	337	* @param buffer Communication buffer shared with the device.
338	* @param bufpos Pointer to the first unread valid offset within the	338	* @param bufpos Pointer to the first unread valid offset within the
339	* communication buffer.	339	* communication buffer.
340	* @param buflen Pointer to the number of unread bytes that are ready in	340	* @param buflen Pointer to the number of unread bytes that are ready in
341	* the communication buffer.	341	* the communication buffer.
342	* @param pos Device position to be read.	342	* @param pos Device position to be read.
343	* @param dst Destination buffer.	343	* @param dst Destination buffer.
344	* @param size Size of the destination buffer.	344	* @param size Size of the destination buffer.
345	* @param block_size Block size to be used for the transfer.	345	* @param block_size Block size to be used for the transfer.
346	*	346	*
347	* @return True on success, false on failure.	347	* @return True on success, false on failure.
348	*/	348	*/
349	bool libfs_blockread(int phone, void buffer, off_t bufpos, size_t *buflen,	349	bool libfs_blockread(int phone, void buffer, off_t bufpos, size_t *buflen,
350	off_t pos, void dst, size_t size, size_t block_size)	350	off_t pos, void dst, size_t size, size_t block_size)
351	{	351	{
352	off_t offset = 0;	352	off_t offset = 0;
353	size_t left = size;	353	size_t left = size;
354		354
355	while (left > 0) {	355	while (left > 0) {
356	size_t rd;	356	size_t rd;
357		357
358	if (bufpos + left < buflen)	358	if (bufpos + left < buflen)
359	rd = left;	359	rd = left;
360	else	360	else
361	rd = buflen - bufpos;	361	rd = buflen - bufpos;
362		362
363	if (rd > 0) {	363	if (rd > 0) {
364	/*	364	/*
365	* Copy the contents of the communication buffer to the	365	* Copy the contents of the communication buffer to the
366	* destination buffer.	366	* destination buffer.
367	*/	367	*/
368	memcpy(dst + offset, buffer + *bufpos, rd);	368	memcpy(dst + offset, buffer + *bufpos, rd);
369	offset += rd;	369	offset += rd;
370	*bufpos += rd;	370	*bufpos += rd;
371	*pos += rd;	371	*pos += rd;
372	left -= rd;	372	left -= rd;
373	}	373	}
374		374
375	if (bufpos == buflen) {	375	if (bufpos == buflen) {
376	/* Refill the communication buffer with a new block. */	376	/* Refill the communication buffer with a new block. */
377	ipcarg_t retval;	377	ipcarg_t retval;
378	int rc = async_req_2_1(phone, RD_READ_BLOCK,	378	int rc = async_req_2_1(phone, RD_READ_BLOCK,
379	*pos / block_size, block_size, &retval);	379	*pos / block_size, block_size, &retval);
380	if ((rc != EOK) \|\| (retval != EOK))	380	if ((rc != EOK) \|\| (retval != EOK))
381	return false;	381	return false;
382		382
383	*bufpos = 0;	383	*bufpos = 0;
384	*buflen = block_size;	384	*buflen = block_size;
385	}	385	}
386	}	386	}
387		387
388	return true;	388	return true;
389	}	389	}
390		390
391	/** @}	391	/** @}
392	*/	392	*/
393		393

Subversion Repositories HelenOS

(root)/branches/sparc/uspace/lib/libfs/libfs.c @ 3593 – Rev 3254 → 3343