WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/vfs/vfs_register.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_register.c
 * @brief
 */
 
#include <ipc/ipc.h>
#include <ipc/services.h>
#include <async.h>
#include <fibril.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <bool.h>
#include <fibril_sync.h>
#include <adt/list.h>
#include <as.h>
#include <assert.h>
#include <atomic.h>
#include "vfs.h"
 
FIBRIL_CONDVAR_INITIALIZE(fs_head_cv);
FIBRIL_MUTEX_INITIALIZE(fs_head_lock);
LIST_INITIALIZE(fs_head);
 
atomic_t fs_handle_next = {
    .count = 1
};
 
/** Verify the VFS info structure.
 *
 * @param info      Info structure to be verified.
 *
 * @return      Non-zero if the info structure is sane, zero otherwise.
 */
static bool vfs_info_sane(vfs_info_t *info)
{
    int i;
 
    /*
     * Check if the name is non-empty and is composed solely of ASCII
     * characters [a-z]+[a-z0-9_-]*.
     */
    if (!islower(info->name[0])) {
        dprintf("The name doesn't start with a lowercase character.\n");
        return false;
    }
    for (i = 1; i < FS_NAME_MAXLEN; i++) {
        if (!(islower(info->name[i]) || isdigit(info->name[i])) &&
            (info->name[i] != '-') && (info->name[i] != '_')) {
            if (info->name[i] == '\0') {
                break;
            } else {
                dprintf("The name contains illegal "
                    "characters.\n");
                return false;
            }
        }
    }
    /*
     * This check is not redundant. It ensures that the name is
     * NULL-terminated, even if FS_NAME_MAXLEN characters are used.
     */
    if (info->name[i] != '\0') {
        dprintf("The name is not properly NULL-terminated.\n");
        return false;
    }
   
    return true;
}
 
/** VFS_REGISTER protocol function.
 *
 * @param rid       Hash of the call with the request.
 * @param request   Call structure with the request.
 */
void vfs_register(ipc_callid_t rid, ipc_call_t *request)
{
    ipc_callid_t callid;
    ipc_call_t call;
    int rc;
    size_t size;
 
    dprintf("Processing VFS_REGISTER request received from %p.\n",
        request->in_phone_hash);
 
    /*
     * The first call has to be IPC_M_DATA_SEND in which we receive the
     * VFS info structure from the client FS.
     */
    if (!ipc_data_write_receive(&callid, &size)) {
        /*
         * The client doesn't obey the same protocol as we do.
         */
        dprintf("Receiving of VFS info failed.\n");
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
   
    dprintf("VFS info received, size = %d\n", size);
   
    /*
     * We know the size of the VFS info structure. See if the client
     * understands this easy concept too.
     */
    if (size != sizeof(vfs_info_t)) {
        /*
         * The client is sending us something, which cannot be
         * the info structure.
         */
        dprintf("Received VFS info has bad size.\n");
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Allocate and initialize a buffer for the fs_info structure.
     */
    fs_info_t *fs_info;
    fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
    if (!fs_info) {
        dprintf("Could not allocate memory for FS info.\n");
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
    link_initialize(&fs_info->fs_link);
    fibril_mutex_initialize(&fs_info->phone_lock);
       
    rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);
    if (rc != EOK) {
        dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
            rc);
        free(fs_info);
        ipc_answer_0(callid, rc);
        ipc_answer_0(rid, rc);
        return;
    }
 
    dprintf("VFS info delivered.\n");
       
    if (!vfs_info_sane(&fs_info->vfs_info)) {
        free(fs_info);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
       
    fibril_mutex_lock(&fs_head_lock);
 
 
    /*
     * Check for duplicit registrations.
     */
    if (fs_name_to_handle(fs_info->vfs_info.name, false)) {
        /*
         * We already register a fs like this.
         */
        dprintf("FS is already registered.\n");
 
        fibril_mutex_unlock(&fs_head_lock);
        free(fs_info);
        ipc_answer_0(callid, EEXISTS);
        ipc_answer_0(rid, EEXISTS);
        return;
    }
 
    /*
     * Add fs_info to the list of registered FS's.
     */
    dprintf("Inserting FS into the list of registered file systems.\n");
    list_append(&fs_info->fs_link, &fs_head);
   
    /*
     * Now we want the client to send us the IPC_M_CONNECT_TO_ME call so
     * that a callback connection is created and we have a phone through
     * which to forward VFS requests to it.
     */
    callid = async_get_call(&call);
    if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
        dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
        list_remove(&fs_info->fs_link);
 
        fibril_mutex_unlock(&fs_head_lock);
        free(fs_info);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
    fs_info->phone = IPC_GET_ARG5(call);
    ipc_answer_0(callid, EOK);
 
    dprintf("Callback connection to FS created.\n");
 
    /*
     * The client will want us to send him the address space area with PLB.
     */
 
    if (!ipc_share_in_receive(&callid, &size)) {
        dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
        list_remove(&fs_info->fs_link);
 
        fibril_mutex_unlock(&fs_head_lock);
        ipc_hangup(fs_info->phone);
        free(fs_info);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
   
    /*
     * We can only send the client address space area PLB_SIZE bytes long.
     */
    if (size != PLB_SIZE) {
        dprintf("Client suggests wrong size of PFB, size = %d\n", size);
        list_remove(&fs_info->fs_link);
 
        fibril_mutex_unlock(&fs_head_lock);
        ipc_hangup(fs_info->phone);
        free(fs_info);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * Commit to read-only sharing the PLB with the client.
     */
    (void) ipc_share_in_finalize(callid, plb,
        AS_AREA_READ | AS_AREA_CACHEABLE);
 
    dprintf("Sharing PLB.\n");
 
    /*
     * That was it. The FS has been registered.
     * In reply to the VFS_REGISTER request, we assign the client file
     * system a global file system handle.
     */
    fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next);
    ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
   
    fibril_condvar_broadcast(&fs_head_cv);
    fibril_mutex_unlock(&fs_head_lock);
   
    dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
        FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);
 
 
 
 
 
}
 
/** For a given file system handle, implement policy for allocating a phone.
 *
 * @param handle    File system handle.
 *
 * @return      Phone over which a multi-call request can be safely
 *          sent. Return 0 if no phone was found.
 */
int vfs_grab_phone(fs_handle_t handle)
{
    int phone;
 
    /*
     * For now, we don't try to be very clever and very fast.  We simply
     * lookup the phone in the fs_head list and duplicate it.  The duplicate
     * phone will be returned to the client and the client will use it for
 
     * communication.  In the future, we should cache the connections so
     * that they do not have to be reestablished over and over again.
     */
    fibril_mutex_lock(&fs_head_lock);
    link_t *cur;
    fs_info_t *fs;
    for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
        fs = list_get_instance(cur, fs_info_t, fs_link);
        if (fs->fs_handle == handle) {
            fibril_mutex_unlock(&fs_head_lock);
 
 
            fibril_mutex_lock(&fs->phone_lock);
            phone = ipc_connect_me_to(fs->phone, 0, 0, 0);
 
            fibril_mutex_unlock(&fs->phone_lock);
 
 
 
 
            assert(phone > 0);
            return phone;
        }
    }
    fibril_mutex_unlock(&fs_head_lock);
    return 0;
}
 
/** Tell VFS that the phone is not needed anymore.
 *
 * @param phone     Phone to FS task.
 */
void vfs_release_phone(int phone)
{
 
 
 
    /* TODO: implement connection caching */
 
 
 
 
 
 
 
    ipc_hangup(phone);
 
 
 
 
 
 
 
 
 
 
 
 
}
 
/** Convert file system name to its handle.
 *
 * @param name      File system name.
 * @param lock      If true, the function will lock and unlock the
 *          fs_head_lock.
 *
 * @return      File system handle or zero if file system not found.
 */
fs_handle_t fs_name_to_handle(char *name, bool lock)
{
    int handle = 0;
   
    if (lock)
        fibril_mutex_lock(&fs_head_lock);
    link_t *cur;
    for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
        fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
        if (str_cmp(fs->vfs_info.name, name) == 0) {
            handle = fs->fs_handle;
            break;
        }
    }
    if (lock)
        fibril_mutex_unlock(&fs_head_lock);
    return handle;
}
 
/**
 * @}
 */
 

Rev 4348	Rev 4691
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_register.c	34	* @file vfs_register.c
35	* @brief	35	* @brief
36	*/	36	*/
37		37
38	#include <ipc/ipc.h>	38	#include <ipc/ipc.h>
39	#include <ipc/services.h>	39	#include <ipc/services.h>
40	#include <async.h>	40	#include <async.h>
41	#include <fibril.h>	41	#include <fibril.h>
42	#include <errno.h>	42	#include <errno.h>
43	#include <stdio.h>	43	#include <stdio.h>
44	#include <stdlib.h>	44	#include <stdlib.h>
45	#include <string.h>	45	#include <string.h>
46	#include <ctype.h>	46	#include <ctype.h>
47	#include <bool.h>	47	#include <bool.h>
48	#include <futex.h>	48	#include <fibril_sync.h>
49	#include <libadt/list.h>	49	#include <adt/list.h>
50	#include <as.h>	50	#include <as.h>
51	#include <assert.h>	51	#include <assert.h>
52	#include <atomic.h>	52	#include <atomic.h>
53	#include "vfs.h"	53	#include "vfs.h"
54		54
-		55	FIBRIL_CONDVAR_INITIALIZE(fs_head_cv);
55	atomic_t fs_head_futex = FUTEX_INITIALIZER;	56	FIBRIL_MUTEX_INITIALIZE(fs_head_lock);
56	link_t fs_head;	57	LIST_INITIALIZE(fs_head);
57		58
58	atomic_t fs_handle_next = {	59	atomic_t fs_handle_next = {
59	.count = 1	60	.count = 1
60	};	61	};
61		62
62	/** Verify the VFS info structure.	63	/** Verify the VFS info structure.
63	*	64	*
64	* @param info Info structure to be verified.	65	* @param info Info structure to be verified.
65	*	66	*
66	* @return Non-zero if the info structure is sane, zero otherwise.	67	* @return Non-zero if the info structure is sane, zero otherwise.
67	*/	68	*/
68	static bool vfs_info_sane(vfs_info_t *info)	69	static bool vfs_info_sane(vfs_info_t *info)
69	{	70	{
70	int i;	71	int i;
71		72
72	/*	73	/*
73	* Check if the name is non-empty and is composed solely of ASCII	74	* Check if the name is non-empty and is composed solely of ASCII
74	* characters [a-z]+[a-z0-9_-]*.	75	* characters [a-z]+[a-z0-9_-]*.
75	*/	76	*/
76	if (!islower(info->name[0])) {	77	if (!islower(info->name[0])) {
77	dprintf("The name doesn't start with a lowercase character.\n");	78	dprintf("The name doesn't start with a lowercase character.\n");
78	return false;	79	return false;
79	}	80	}
80	for (i = 1; i < FS_NAME_MAXLEN; i++) {	81	for (i = 1; i < FS_NAME_MAXLEN; i++) {
81	if (!(islower(info->name[i]) \|\| isdigit(info->name[i])) &&	82	if (!(islower(info->name[i]) \|\| isdigit(info->name[i])) &&
82	(info->name[i] != '-') && (info->name[i] != '_')) {	83	(info->name[i] != '-') && (info->name[i] != '_')) {
83	if (info->name[i] == '\0') {	84	if (info->name[i] == '\0') {
84	break;	85	break;
85	} else {	86	} else {
86	dprintf("The name contains illegal "	87	dprintf("The name contains illegal "
87	"characters.\n");	88	"characters.\n");
88	return false;	89	return false;
89	}	90	}
90	}	91	}
91	}	92	}
92	/*	93	/*
93	* This check is not redundant. It ensures that the name is	94	* This check is not redundant. It ensures that the name is
94	* NULL-terminated, even if FS_NAME_MAXLEN characters are used.	95	* NULL-terminated, even if FS_NAME_MAXLEN characters are used.
95	*/	96	*/
96	if (info->name[i] != '\0') {	97	if (info->name[i] != '\0') {
97	dprintf("The name is not properly NULL-terminated.\n");	98	dprintf("The name is not properly NULL-terminated.\n");
98	return false;	99	return false;
99	}	100	}
100		101
101	return true;	102	return true;
102	}	103	}
103		104
104	/** VFS_REGISTER protocol function.	105	/** VFS_REGISTER protocol function.
105	*	106	*
106	* @param rid Hash of the call with the request.	107	* @param rid Hash of the call with the request.
107	* @param request Call structure with the request.	108	* @param request Call structure with the request.
108	*/	109	*/
109	void vfs_register(ipc_callid_t rid, ipc_call_t *request)	110	void vfs_register(ipc_callid_t rid, ipc_call_t *request)
110	{	111	{
111	ipc_callid_t callid;	112	ipc_callid_t callid;
112	ipc_call_t call;	113	ipc_call_t call;
113	int rc;	114	int rc;
114	size_t size;	115	size_t size;
115		116
116	dprintf("Processing VFS_REGISTER request received from %p.\n",	117	dprintf("Processing VFS_REGISTER request received from %p.\n",
117	request->in_phone_hash);	118	request->in_phone_hash);
118		119
119	/*	120	/*
120	* The first call has to be IPC_M_DATA_SEND in which we receive the	121	* The first call has to be IPC_M_DATA_SEND in which we receive the
121	* VFS info structure from the client FS.	122	* VFS info structure from the client FS.
122	*/	123	*/
123	if (!ipc_data_write_receive(&callid, &size)) {	124	if (!ipc_data_write_receive(&callid, &size)) {
124	/*	125	/*
125	* The client doesn't obey the same protocol as we do.	126	* The client doesn't obey the same protocol as we do.
126	*/	127	*/
127	dprintf("Receiving of VFS info failed.\n");	128	dprintf("Receiving of VFS info failed.\n");
128	ipc_answer_0(callid, EINVAL);	129	ipc_answer_0(callid, EINVAL);
129	ipc_answer_0(rid, EINVAL);	130	ipc_answer_0(rid, EINVAL);
130	return;	131	return;
131	}	132	}
132		133
133	dprintf("VFS info received, size = %d\n", size);	134	dprintf("VFS info received, size = %d\n", size);
134		135
135	/*	136	/*
136	* We know the size of the VFS info structure. See if the client	137	* We know the size of the VFS info structure. See if the client
137	* understands this easy concept too.	138	* understands this easy concept too.
138	*/	139	*/
139	if (size != sizeof(vfs_info_t)) {	140	if (size != sizeof(vfs_info_t)) {
140	/*	141	/*
141	* The client is sending us something, which cannot be	142	* The client is sending us something, which cannot be
142	* the info structure.	143	* the info structure.
143	*/	144	*/
144	dprintf("Received VFS info has bad size.\n");	145	dprintf("Received VFS info has bad size.\n");
145	ipc_answer_0(callid, EINVAL);	146	ipc_answer_0(callid, EINVAL);
146	ipc_answer_0(rid, EINVAL);	147	ipc_answer_0(rid, EINVAL);
147	return;	148	return;
148	}	149	}
149		150
150	/*	151	/*
151	* Allocate and initialize a buffer for the fs_info structure.	152	* Allocate and initialize a buffer for the fs_info structure.
152	*/	153	*/
153	fs_info_t *fs_info;	154	fs_info_t *fs_info;
154	fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));	155	fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
155	if (!fs_info) {	156	if (!fs_info) {
156	dprintf("Could not allocate memory for FS info.\n");	157	dprintf("Could not allocate memory for FS info.\n");
157	ipc_answer_0(callid, ENOMEM);	158	ipc_answer_0(callid, ENOMEM);
158	ipc_answer_0(rid, ENOMEM);	159	ipc_answer_0(rid, ENOMEM);
159	return;	160	return;
160	}	161	}
161	link_initialize(&fs_info->fs_link);	162	link_initialize(&fs_info->fs_link);
162	futex_initialize(&fs_info->phone_futex, 1);	163	fibril_mutex_initialize(&fs_info->phone_lock);
163		164
164	rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);	165	rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);
165	if (rc != EOK) {	166	if (rc != EOK) {
166	dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",	167	dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
167	rc);	168	rc);
168	free(fs_info);	169	free(fs_info);
169	ipc_answer_0(callid, rc);	170	ipc_answer_0(callid, rc);
170	ipc_answer_0(rid, rc);	171	ipc_answer_0(rid, rc);
171	return;	172	return;
172	}	173	}
173		174
174	dprintf("VFS info delivered.\n");	175	dprintf("VFS info delivered.\n");
175		176
176	if (!vfs_info_sane(&fs_info->vfs_info)) {	177	if (!vfs_info_sane(&fs_info->vfs_info)) {
177	free(fs_info);	178	free(fs_info);
178	ipc_answer_0(callid, EINVAL);	179	ipc_answer_0(callid, EINVAL);
179	ipc_answer_0(rid, EINVAL);	180	ipc_answer_0(rid, EINVAL);
180	return;	181	return;
181	}	182	}
182		183
183	futex_down(&fs_head_futex);	184	fibril_mutex_lock(&fs_head_lock);
184	fibril_inc_sercount();	-
185		185
186	/*	186	/*
187	* Check for duplicit registrations.	187	* Check for duplicit registrations.
188	*/	188	*/
189	if (fs_name_to_handle(fs_info->vfs_info.name, false)) {	189	if (fs_name_to_handle(fs_info->vfs_info.name, false)) {
190	/*	190	/*
191	* We already register a fs like this.	191	* We already register a fs like this.
192	*/	192	*/
193	dprintf("FS is already registered.\n");	193	dprintf("FS is already registered.\n");
194	fibril_dec_sercount();	-
195	futex_up(&fs_head_futex);	194	fibril_mutex_unlock(&fs_head_lock);
196	free(fs_info);	195	free(fs_info);
197	ipc_answer_0(callid, EEXISTS);	196	ipc_answer_0(callid, EEXISTS);
198	ipc_answer_0(rid, EEXISTS);	197	ipc_answer_0(rid, EEXISTS);
199	return;	198	return;
200	}	199	}
201		200
202	/*	201	/*
203	* Add fs_info to the list of registered FS's.	202	* Add fs_info to the list of registered FS's.
204	*/	203	*/
205	dprintf("Inserting FS into the list of registered file systems.\n");	204	dprintf("Inserting FS into the list of registered file systems.\n");
206	list_append(&fs_info->fs_link, &fs_head);	205	list_append(&fs_info->fs_link, &fs_head);
207		206
208	/*	207	/*
209	* Now we want the client to send us the IPC_M_CONNECT_TO_ME call so	208	* Now we want the client to send us the IPC_M_CONNECT_TO_ME call so
210	* that a callback connection is created and we have a phone through	209	* that a callback connection is created and we have a phone through
211	* which to forward VFS requests to it.	210	* which to forward VFS requests to it.
212	*/	211	*/
213	callid = async_get_call(&call);	212	callid = async_get_call(&call);
214	if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {	213	if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
215	dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));	214	dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
216	list_remove(&fs_info->fs_link);	215	list_remove(&fs_info->fs_link);
217	fibril_dec_sercount();	-
218	futex_up(&fs_head_futex);	216	fibril_mutex_unlock(&fs_head_lock);
219	free(fs_info);	217	free(fs_info);
220	ipc_answer_0(callid, EINVAL);	218	ipc_answer_0(callid, EINVAL);
221	ipc_answer_0(rid, EINVAL);	219	ipc_answer_0(rid, EINVAL);
222	return;	220	return;
223	}	221	}
224	fs_info->phone = IPC_GET_ARG5(call);	222	fs_info->phone = IPC_GET_ARG5(call);
225	ipc_answer_0(callid, EOK);	223	ipc_answer_0(callid, EOK);
226		224
227	dprintf("Callback connection to FS created.\n");	225	dprintf("Callback connection to FS created.\n");
228		226
229	/*	227	/*
230	* The client will want us to send him the address space area with PLB.	228	* The client will want us to send him the address space area with PLB.
231	*/	229	*/
232		230
233	if (!ipc_share_in_receive(&callid, &size)) {	231	if (!ipc_share_in_receive(&callid, &size)) {
234	dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));	232	dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
235	list_remove(&fs_info->fs_link);	233	list_remove(&fs_info->fs_link);
236	fibril_dec_sercount();	-
237	futex_up(&fs_head_futex);	234	fibril_mutex_unlock(&fs_head_lock);
238	ipc_hangup(fs_info->phone);	235	ipc_hangup(fs_info->phone);
239	free(fs_info);	236	free(fs_info);
240	ipc_answer_0(callid, EINVAL);	237	ipc_answer_0(callid, EINVAL);
241	ipc_answer_0(rid, EINVAL);	238	ipc_answer_0(rid, EINVAL);
242	return;	239	return;
243	}	240	}
244		241
245	/*	242	/*
246	* We can only send the client address space area PLB_SIZE bytes long.	243	* We can only send the client address space area PLB_SIZE bytes long.
247	*/	244	*/
248	if (size != PLB_SIZE) {	245	if (size != PLB_SIZE) {
249	dprintf("Client suggests wrong size of PFB, size = %d\n", size);	246	dprintf("Client suggests wrong size of PFB, size = %d\n", size);
250	list_remove(&fs_info->fs_link);	247	list_remove(&fs_info->fs_link);
251	fibril_dec_sercount();	-
252	futex_up(&fs_head_futex);	248	fibril_mutex_unlock(&fs_head_lock);
253	ipc_hangup(fs_info->phone);	249	ipc_hangup(fs_info->phone);
254	free(fs_info);	250	free(fs_info);
255	ipc_answer_0(callid, EINVAL);	251	ipc_answer_0(callid, EINVAL);
256	ipc_answer_0(rid, EINVAL);	252	ipc_answer_0(rid, EINVAL);
257	return;	253	return;
258	}	254	}
259		255
260	/*	256	/*
261	* Commit to read-only sharing the PLB with the client.	257	* Commit to read-only sharing the PLB with the client.
262	*/	258	*/
263	(void) ipc_share_in_finalize(callid, plb,	259	(void) ipc_share_in_finalize(callid, plb,
264	AS_AREA_READ \| AS_AREA_CACHEABLE);	260	AS_AREA_READ \| AS_AREA_CACHEABLE);
265		261
266	dprintf("Sharing PLB.\n");	262	dprintf("Sharing PLB.\n");
267		263
268	/*	264	/*
269	* That was it. The FS has been registered.	265	* That was it. The FS has been registered.
270	* In reply to the VFS_REGISTER request, we assign the client file	266	* In reply to the VFS_REGISTER request, we assign the client file
271	* system a global file system handle.	267	* system a global file system handle.
272	*/	268	*/
273	fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next);	269	fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next);
274	ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);	270	ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
275		271
276	fibril_dec_sercount();	272	fibril_condvar_broadcast(&fs_head_cv);
277	futex_up(&fs_head_futex);	273	fibril_mutex_unlock(&fs_head_lock);
278		274
279	dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",	275	dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
280	FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);	276	FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);
281		-
282	/* Process pending mount requests possibly waiting	-
283	* for this filesystem implementation.	-
284	*/	-
285	vfs_process_pending_mount();	-
286	}	277	}
287		278
288	/** For a given file system handle, implement policy for allocating a phone.	279	/** For a given file system handle, implement policy for allocating a phone.
289	*	280	*
290	* @param handle File system handle.	281	* @param handle File system handle.
291	*	282	*
292	* @return Phone over which a multi-call request can be safely	283	* @return Phone over which a multi-call request can be safely
293	* sent. Return 0 if no phone was found.	284	* sent. Return 0 if no phone was found.
294	*/	285	*/
295	int vfs_grab_phone(fs_handle_t handle)	286	int vfs_grab_phone(fs_handle_t handle)
296	{	287	{
-		288	int phone;
-		289
297	/*	290	/*
298	* For now, we don't try to be very clever and very fast.	291	* For now, we don't try to be very clever and very fast. We simply
299	* We simply lookup the phone in the fs_head list. We currently don't	292	* lookup the phone in the fs_head list and duplicate it. The duplicate
300	* open any additional phones (even though that itself would be pretty	293	* phone will be returned to the client and the client will use it for
301	* straightforward; housekeeping multiple open phones to a FS task would	-
302	* be more demanding). Instead, we simply take the respective	294	* communication. In the future, we should cache the connections so
303	* phone_futex and keep it until vfs_release_phone().	295	* that they do not have to be reestablished over and over again.
304	*/	296	*/
305	futex_down(&fs_head_futex);	297	fibril_mutex_lock(&fs_head_lock);
306	link_t *cur;	298	link_t *cur;
307	fs_info_t *fs;	299	fs_info_t *fs;
308	for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {	300	for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
309	fs = list_get_instance(cur, fs_info_t, fs_link);	301	fs = list_get_instance(cur, fs_info_t, fs_link);
310	if (fs->fs_handle == handle) {	302	if (fs->fs_handle == handle) {
311	futex_up(&fs_head_futex);	303	fibril_mutex_unlock(&fs_head_lock);
312	/*	-
313	* For now, take the futex unconditionally.	-
314	* Oh yeah, serialization rocks.	304	fibril_mutex_lock(&fs->phone_lock);
315	* It will be up'ed in vfs_release_phone().	305	phone = ipc_connect_me_to(fs->phone, 0, 0, 0);
316	*/	-
317	futex_down(&fs->phone_futex);	306	fibril_mutex_unlock(&fs->phone_lock);
318	/*	307
319	* Avoid deadlock with other fibrils in the same thread	-
320	* by disabling fibril preemption.	-
321	*/	-
322	fibril_inc_sercount();	308	assert(phone > 0);
323	return fs->phone;	309	return phone;
324	}	310	}
325	}	311	}
326	futex_up(&fs_head_futex);	312	fibril_mutex_unlock(&fs_head_lock);
327	return 0;	313	return 0;
328	}	314	}
329		315
330	/** Tell VFS that the phone is in use for any request.	316	/** Tell VFS that the phone is not needed anymore.
331	*	317	*
332	* @param phone Phone to FS task.	318	* @param phone Phone to FS task.
333	*/	319	*/
334	void vfs_release_phone(int phone)	320	void vfs_release_phone(int phone)
335	{	321	{
336	bool found = false;	-
337		-
338	/*	-
339	* Undo the fibril_inc_sercount() done in vfs_grab_phone().	322	/* TODO: implement connection caching */
340	*/	-
341	fibril_dec_sercount();	-
342		-
343	futex_down(&fs_head_futex);	-
344	link_t *cur;	-
345	for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {	-
346	fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);	-
347	if (fs->phone == phone) {	323	ipc_hangup(phone);
348	found = true;	-
349	futex_up(&fs_head_futex);	-
350	futex_up(&fs->phone_futex);	-
351	return;	-
352	}	-
353	}	-
354	futex_up(&fs_head_futex);	-
355		-
356	/*	-
357	* Not good to get here.	-
358	*/	-
359	assert(found == true);	-
360	}	324	}
361		325
362	/** Convert file system name to its handle.	326	/** Convert file system name to its handle.
363	*	327	*
364	* @param name File system name.	328	* @param name File system name.
365	* @param lock If true, the function will down and up the	329	* @param lock If true, the function will lock and unlock the
366	* fs_head_futex.	330	* fs_head_lock.
367	*	331	*
368	* @return File system handle or zero if file system not found.	332	* @return File system handle or zero if file system not found.
369	*/	333	*/
370	fs_handle_t fs_name_to_handle(char *name, bool lock)	334	fs_handle_t fs_name_to_handle(char *name, bool lock)
371	{	335	{
372	int handle = 0;	336	int handle = 0;
373		337
374	if (lock)	338	if (lock)
375	futex_down(&fs_head_futex);	339	fibril_mutex_lock(&fs_head_lock);
376	link_t *cur;	340	link_t *cur;
377	for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {	341	for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
378	fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);	342	fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
379	if (str_cmp(fs->vfs_info.name, name) == 0) {	343	if (str_cmp(fs->vfs_info.name, name) == 0) {
380	handle = fs->fs_handle;	344	handle = fs->fs_handle;
381	break;	345	break;
382	}	346	}
383	}	347	}
384	if (lock)	348	if (lock)
385	futex_up(&fs_head_futex);	349	fibril_mutex_unlock(&fs_head_lock);
386	return handle;	350	return handle;
387	}	351	}
388		352
389	/**	353	/**
390	* @}	354	* @}
391	*/	355	*/
392		356

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/vfs/vfs_register.c – Rev 4348 → 4691