WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/vfs/vfs_lookup.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 fs
 * @{
 */
 
/**
 * @file    vfs_lookup.c
 * @brief
 */
 
#include "vfs.h"
#include <ipc/ipc.h>
#include <async.h>
#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <bool.h>
#include <futex.h>
#include <libadt/list.h>
#include <vfs/canonify.h>
 
#define min(a, b)   ((a) < (b) ? (a) : (b))
 
futex_t plb_futex = FUTEX_INITIALIZER;
link_t plb_head;    /**< PLB entry ring buffer. */
uint8_t *plb = NULL;
 
/** Perform a path lookup.
 *
 * @param path      Path to be resolved; it must be a NULL-terminated
 *          string.
 * @param lflag     Flags to be used during lookup.
 * @param result    Empty structure where the lookup result will be stored.
 *          Can be NULL.
 * @param altroot   If non-empty, will be used instead of rootfs as the root
 *          of the whole VFS tree.
 *
 * @return      EOK on success or an error code from errno.h.
 */
int vfs_lookup_internal(char *path, int lflag, vfs_lookup_res_t *result,
    vfs_pair_t *altroot, ...)
{
    vfs_pair_t *root;
 
    if (altroot)
        root = altroot;
    else
        root = &rootfs;
 
    if (!root->fs_handle)
        return ENOENT;
   
    size_t len;
    path = canonify(path, &len);
    if (!path)
        return EINVAL;
   
    fs_index_t index = 0;
    if (lflag & L_LINK) {
        va_list ap;
 
        va_start(ap, altroot);
        index = va_arg(ap, fs_index_t);
        va_end(ap);
    }
   
    futex_down(&plb_futex);
 
    plb_entry_t entry;
    link_initialize(&entry.plb_link);
    entry.len = len;
 
    off_t first;    /* the first free index */
    off_t last; /* the last free index */
 
    if (list_empty(&plb_head)) {
        first = 0;
        last = PLB_SIZE - 1;
    } else {
        plb_entry_t *oldest = list_get_instance(plb_head.next,
            plb_entry_t, plb_link);
        plb_entry_t *newest = list_get_instance(plb_head.prev,
            plb_entry_t, plb_link);
 
        first = (newest->index + newest->len) % PLB_SIZE;
        last = (oldest->index - 1) % PLB_SIZE;
    }
 
    if (first <= last) {
        if ((last - first) + 1 < len) {
            /*
             * The buffer cannot absorb the path.
             */
            futex_up(&plb_futex);
            return ELIMIT;
        }
    } else {
        if (PLB_SIZE - ((first - last) + 1) < len) {
            /*
             * The buffer cannot absorb the path.
             */
            futex_up(&plb_futex);
            return ELIMIT;
        }
    }
 
    /*
     * We know the first free index in PLB and we also know that there is
     * enough space in the buffer to hold our path.
     */
 
    entry.index = first;
    entry.len = len;
 
    /*
     * Claim PLB space by inserting the entry into the PLB entry ring
     * buffer.
     */
    list_append(&entry.plb_link, &plb_head);
   
    futex_up(&plb_futex);
 
    /*
     * Copy the path into PLB.
     */
    size_t cnt1 = min(len, (PLB_SIZE - first) + 1);
    size_t cnt2 = len - cnt1;
   
    memcpy(&plb[first], path, cnt1);
    memcpy(plb, &path[cnt1], cnt2);
 
    ipc_call_t answer;
    int phone = vfs_grab_phone(root->fs_handle);
    aid_t req = async_send_5(phone, VFS_LOOKUP, (ipcarg_t) first,
        (ipcarg_t) (first + len - 1) % PLB_SIZE,
        (ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index,
        &answer);
    vfs_release_phone(phone);
 
    ipcarg_t rc;
    async_wait_for(req, &rc);
 
    futex_down(&plb_futex);
    list_remove(&entry.plb_link);
    /*
     * Erasing the path from PLB will come handy for debugging purposes.
     */
    memset(&plb[first], 0, cnt1);
    memset(plb, 0, cnt2);
    futex_up(&plb_futex);
 
    if ((rc == EOK) && result) {
        result->triplet.fs_handle = (fs_handle_t) IPC_GET_ARG1(answer);
        result->triplet.dev_handle = (dev_handle_t) IPC_GET_ARG2(answer);
        result->triplet.index = (fs_index_t) IPC_GET_ARG3(answer);
        result->size = (size_t) IPC_GET_ARG4(answer);
        result->lnkcnt = (unsigned) IPC_GET_ARG5(answer);
        if (lflag & L_FILE)
            result->type = VFS_NODE_FILE;
        else if (lflag & L_DIRECTORY)
            result->type = VFS_NODE_DIRECTORY;
        else
            result->type = VFS_NODE_UNKNOWN;
    }
 
    return rc;
}
 
/**
 * @}
 */
 

Rev 3153	Rev 3674
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 fs	29	/** @addtogroup fs
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file vfs_lookup.c	34	* @file vfs_lookup.c
35	* @brief	35	* @brief
36	*/	36	*/
37		37
38	#include "vfs.h"	38	#include "vfs.h"
39	#include <ipc/ipc.h>	39	#include <ipc/ipc.h>
40	#include <async.h>	40	#include <async.h>
41	#include <errno.h>	41	#include <errno.h>
42	#include <string.h>	42	#include <string.h>
43	#include <stdarg.h>	43	#include <stdarg.h>
44	#include <bool.h>	44	#include <bool.h>
45	#include <futex.h>	45	#include <futex.h>
46	#include <libadt/list.h>	46	#include <libadt/list.h>
47	#include <vfs/canonify.h>	47	#include <vfs/canonify.h>
48		48
49	#define min(a, b) ((a) < (b) ? (a) : (b))	49	#define min(a, b) ((a) < (b) ? (a) : (b))
50		50
51	futex_t plb_futex = FUTEX_INITIALIZER;	51	futex_t plb_futex = FUTEX_INITIALIZER;
52	link_t plb_head; /*< PLB entry ring buffer. /	52	link_t plb_head; /*< PLB entry ring buffer. /
53	uint8_t *plb = NULL;	53	uint8_t *plb = NULL;
54		54
55	/** Perform a path lookup.	55	/** Perform a path lookup.
56	*	56	*
57	* @param path Path to be resolved; it must be a NULL-terminated	57	* @param path Path to be resolved; it must be a NULL-terminated
58	* string.	58	* string.
59	* @param lflag Flags to be used during lookup.	59	* @param lflag Flags to be used during lookup.
60	* @param result Empty structure where the lookup result will be stored.	60	* @param result Empty structure where the lookup result will be stored.
61	* Can be NULL.	61	* Can be NULL.
62	* @param altroot If non-empty, will be used instead of rootfs as the root	62	* @param altroot If non-empty, will be used instead of rootfs as the root
63	* of the whole VFS tree.	63	* of the whole VFS tree.
64	*	64	*
65	* @return EOK on success or an error code from errno.h.	65	* @return EOK on success or an error code from errno.h.
66	*/	66	*/
67	int vfs_lookup_internal(char path, int lflag, vfs_lookup_res_t result,	67	int vfs_lookup_internal(char path, int lflag, vfs_lookup_res_t result,
68	vfs_pair_t *altroot, ...)	68	vfs_pair_t *altroot, ...)
69	{	69	{
70	vfs_pair_t *root;	70	vfs_pair_t *root;
71		71
72	if (altroot)	72	if (altroot)
73	root = altroot;	73	root = altroot;
74	else	74	else
75	root = &rootfs;	75	root = &rootfs;
76		76
77	if (!root->fs_handle)	77	if (!root->fs_handle)
78	return ENOENT;	78	return ENOENT;
79		79
80	size_t len;	80	size_t len;
81	path = canonify(path, &len);	81	path = canonify(path, &len);
82	if (!path)	82	if (!path)
83	return EINVAL;	83	return EINVAL;
84		84
85	fs_index_t index = 0;	85	fs_index_t index = 0;
86	if (lflag & L_LINK) {	86	if (lflag & L_LINK) {
87	va_list ap;	87	va_list ap;
88		88
89	va_start(ap, altroot);	89	va_start(ap, altroot);
90	index = va_arg(ap, fs_index_t);	90	index = va_arg(ap, fs_index_t);
91	va_end(ap);	91	va_end(ap);
92	}	92	}
93		93
94	futex_down(&plb_futex);	94	futex_down(&plb_futex);
95		95
96	plb_entry_t entry;	96	plb_entry_t entry;
97	link_initialize(&entry.plb_link);	97	link_initialize(&entry.plb_link);
98	entry.len = len;	98	entry.len = len;
99		99
100	off_t first; /* the first free index */	100	off_t first; /* the first free index */
101	off_t last; /* the last free index */	101	off_t last; /* the last free index */
102		102
103	if (list_empty(&plb_head)) {	103	if (list_empty(&plb_head)) {
104	first = 0;	104	first = 0;
105	last = PLB_SIZE - 1;	105	last = PLB_SIZE - 1;
106	} else {	106	} else {
107	plb_entry_t *oldest = list_get_instance(plb_head.next,	107	plb_entry_t *oldest = list_get_instance(plb_head.next,
108	plb_entry_t, plb_link);	108	plb_entry_t, plb_link);
109	plb_entry_t *newest = list_get_instance(plb_head.prev,	109	plb_entry_t *newest = list_get_instance(plb_head.prev,
110	plb_entry_t, plb_link);	110	plb_entry_t, plb_link);
111		111
112	first = (newest->index + newest->len) % PLB_SIZE;	112	first = (newest->index + newest->len) % PLB_SIZE;
113	last = (oldest->index - 1) % PLB_SIZE;	113	last = (oldest->index - 1) % PLB_SIZE;
114	}	114	}
115		115
116	if (first <= last) {	116	if (first <= last) {
117	if ((last - first) + 1 < len) {	117	if ((last - first) + 1 < len) {
118	/*	118	/*
119	* The buffer cannot absorb the path.	119	* The buffer cannot absorb the path.
120	*/	120	*/
121	futex_up(&plb_futex);	121	futex_up(&plb_futex);
122	return ELIMIT;	122	return ELIMIT;
123	}	123	}
124	} else {	124	} else {
125	if (PLB_SIZE - ((first - last) + 1) < len) {	125	if (PLB_SIZE - ((first - last) + 1) < len) {
126	/*	126	/*
127	* The buffer cannot absorb the path.	127	* The buffer cannot absorb the path.
128	*/	128	*/
129	futex_up(&plb_futex);	129	futex_up(&plb_futex);
130	return ELIMIT;	130	return ELIMIT;
131	}	131	}
132	}	132	}
133		133
134	/*	134	/*
135	* We know the first free index in PLB and we also know that there is	135	* We know the first free index in PLB and we also know that there is
136	* enough space in the buffer to hold our path.	136	* enough space in the buffer to hold our path.
137	*/	137	*/
138		138
139	entry.index = first;	139	entry.index = first;
140	entry.len = len;	140	entry.len = len;
141		141
142	/*	142	/*
143	* Claim PLB space by inserting the entry into the PLB entry ring	143	* Claim PLB space by inserting the entry into the PLB entry ring
144	* buffer.	144	* buffer.
145	*/	145	*/
146	list_append(&entry.plb_link, &plb_head);	146	list_append(&entry.plb_link, &plb_head);
147		147
148	futex_up(&plb_futex);	148	futex_up(&plb_futex);
149		149
150	/*	150	/*
151	* Copy the path into PLB.	151	* Copy the path into PLB.
152	*/	152	*/
153	size_t cnt1 = min(len, (PLB_SIZE - first) + 1);	153	size_t cnt1 = min(len, (PLB_SIZE - first) + 1);
154	size_t cnt2 = len - cnt1;	154	size_t cnt2 = len - cnt1;
155		155
156	memcpy(&plb[first], path, cnt1);	156	memcpy(&plb[first], path, cnt1);
157	memcpy(plb, &path[cnt1], cnt2);	157	memcpy(plb, &path[cnt1], cnt2);
158		158
159	ipc_call_t answer;	159	ipc_call_t answer;
160	int phone = vfs_grab_phone(root->fs_handle);	160	int phone = vfs_grab_phone(root->fs_handle);
161	aid_t req = async_send_5(phone, VFS_LOOKUP, (ipcarg_t) first,	161	aid_t req = async_send_5(phone, VFS_LOOKUP, (ipcarg_t) first,
162	(ipcarg_t) (first + len - 1) % PLB_SIZE,	162	(ipcarg_t) (first + len - 1) % PLB_SIZE,
163	(ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index,	163	(ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index,
164	&answer);	164	&answer);
165	vfs_release_phone(phone);	165	vfs_release_phone(phone);
166		166
167	ipcarg_t rc;	167	ipcarg_t rc;
168	async_wait_for(req, &rc);	168	async_wait_for(req, &rc);
169		169
170	futex_down(&plb_futex);	170	futex_down(&plb_futex);
171	list_remove(&entry.plb_link);	171	list_remove(&entry.plb_link);
172	/*	172	/*
173	* Erasing the path from PLB will come handy for debugging purposes.	173	* Erasing the path from PLB will come handy for debugging purposes.
174	*/	174	*/
175	memset(&plb[first], 0, cnt1);	175	memset(&plb[first], 0, cnt1);
176	memset(plb, 0, cnt2);	176	memset(plb, 0, cnt2);
177	futex_up(&plb_futex);	177	futex_up(&plb_futex);
178		178
179	if ((rc == EOK) && result) {	179	if ((rc == EOK) && result) {
180	result->triplet.fs_handle = (fs_handle_t) IPC_GET_ARG1(answer);	180	result->triplet.fs_handle = (fs_handle_t) IPC_GET_ARG1(answer);
181	result->triplet.dev_handle = (dev_handle_t) IPC_GET_ARG2(answer);	181	result->triplet.dev_handle = (dev_handle_t) IPC_GET_ARG2(answer);
182	result->triplet.index = (fs_index_t) IPC_GET_ARG3(answer);	182	result->triplet.index = (fs_index_t) IPC_GET_ARG3(answer);
183	result->size = (size_t) IPC_GET_ARG4(answer);	183	result->size = (size_t) IPC_GET_ARG4(answer);
184	result->lnkcnt = (unsigned) IPC_GET_ARG5(answer);	184	result->lnkcnt = (unsigned) IPC_GET_ARG5(answer);
-		185	if (lflag & L_FILE)
-		186	result->type = VFS_NODE_FILE;
-		187	else if (lflag & L_DIRECTORY)
-		188	result->type = VFS_NODE_DIRECTORY;
-		189	else
-		190	result->type = VFS_NODE_UNKNOWN;
185	}	191	}
186		192
187	return rc;	193	return rc;
188	}	194	}
189		195
190	/**	196	/**
191	* @}	197	* @}
192	*/	198	*/
193		199

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/vfs/vfs_lookup.c – Rev 3153 → 3674