WebSVN – HelenOS – Diff – /trunk/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 <ipc/ipc.h>
#include <async.h>
#include <errno.h>
#include <string.h>
#include <bool.h>
#include <futex.h>
#include <libadt/list.h>
#include <atomic.h>
#include "vfs.h"
 
#define min(a, b)   ((a) < (b) ? (a) : (b))
 
atomic_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 needn't be an ASCIIZ string.
 * @param len       Number of path characters pointed by path.
 * @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, size_t len, int lflag,
    vfs_lookup_res_t *result, vfs_pair_t *altroot)
{
    vfs_pair_t *root;
 
    if (!len)
        return EINVAL;
 
    if (altroot)
        root = altroot;
    else
        root = (vfs_pair_t *) &rootfs;
 
    if (!root->fs_handle)
        return ENOENT;
   
    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_4(phone, VFS_LOOKUP, (ipcarg_t) first,
        (ipcarg_t) (first + len - 1) % PLB_SIZE,
        (ipcarg_t) root->dev_handle, (ipcarg_t) lflag, &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 = (int) IPC_GET_ARG1(answer);
        result->triplet.dev_handle = (int) IPC_GET_ARG2(answer);
        result->triplet.index = (int) IPC_GET_ARG3(answer);
        result->size = (size_t) IPC_GET_ARG4(answer);
        result->lnkcnt = (unsigned) IPC_GET_ARG5(answer);
    }
 
    return rc;
}
 
/**
 * @}
 */
 

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

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/vfs/vfs_lookup.c – Rev 2707 → 2730