WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/fs/fat/fat.c


/*
 * Copyright (c) 2006 Martin Decky
 * Copyright (c) 2007 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    fat.c
 * @brief   FAT file system driver for HelenOS.
 */
 
#include <ipc/ipc.h>
#include <ipc/services.h>
#include <async.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <as.h>>
#include "../../vfs/vfs.h"
 
#define dprintf(...)    printf(__VA_ARGS__)
 
vfs_info_t fat_vfs_info = {
    .name = "fat",
    .ops = {
        [IPC_METHOD_TO_VFS_OP(VFS_REGISTER)] = VFS_OP_DEFINED,
        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_DEFINED,
        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_DEFINED,
        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
        [IPC_METHOD_TO_VFS_OP(VFS_OPEN)] = VFS_OP_DEFINED,
        [IPC_METHOD_TO_VFS_OP(VFS_CREATE)] = VFS_OP_DEFINED,
        [IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] = VFS_OP_DEFINED,
        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_NULL,
        [IPC_METHOD_TO_VFS_OP(VFS_SEEK)] = VFS_OP_DEFAULT
    }
};
 
uint8_t *plb_ro = NULL;
 
/**
 * This connection fibril processes VFS requests from VFS.
 *
 * In order to support simultaneous VFS requests, our design is as follows.
 * The connection fibril accepts VFS requests from VFS. If there is only one
 * instance of the fibril, VFS will need to serialize all VFS requests it sends
 * to FAT. To overcome this bottleneck, VFS can send FAT the IPC_M_CONNECT_ME_TO
 * call. In that case, a new connection fibril will be created, which in turn
 * will accept the call. Thus, a new phone will be opened for VFS.
 *
 * There are few issues with this arrangement. First, VFS can run out of
 * available phones. In that case, VFS can close some other phones or use one
 * phone for more serialized requests. Similarly, FAT can refuse to duplicate
 * the connection. VFS should then just make use of already existing phones and
 * route its requests through them. To avoid paying the fibril creation price
 * upon each request, FAT might want to keep the connections open after the
 * request has been completed.
 */
static void fat_connection(ipc_callid_t iid, ipc_call_t *icall)
{
    if (iid) {
        /*
         * This only happens for connections opened by
         * IPC_M_CONNECT_ME_TO calls as opposed to callback connections
         * created by IPC_M_CONNECT_TO_ME.
         */
        ipc_answer_fast(iid, EOK, 0, 0);
    }
   
    dprintf("VFS-FAT connection established.\n");
    while (1) {
        ipc_callid_t callid;
        ipc_call_t call;
   
        callid = async_get_call(&call);
        switch  (IPC_GET_METHOD(call)) {
        default:
            ipc_answer_fast(callid, ENOTSUP, 0, 0);
            break;
        }
    }
}
 
int main(int argc, char **argv)
{
    int vfs_phone;
 
    printf("FAT: HelenOS FAT file system server.\n");
 
    vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0);
    while (vfs_phone < EOK) {
        usleep(10000);
        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0);
    }
   
    /*
     * 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_2(vfs_phone, VFS_REGISTER, 0, 0, &answer);
 
    /*
     * Send our VFS info structure to VFS.
     */
    int rc = ipc_data_send(vfs_phone, &fat_vfs_info, sizeof(fat_vfs_info));
    if (rc != EOK) {
        async_wait_for(req, NULL);
        return rc;
    }
 
    /*
     * Ask VFS for callback connection.
     */
    ipcarg_t phonehash;
    ipc_connect_to_me(vfs_phone, 0, 0, &phonehash);
 
    /*
     * Allocate piece of address space for PLB.
     */
    plb_ro = as_get_mappable_page(PLB_SIZE);
    if (!plb_ro) {
        async_wait_for(req, NULL);
        return ENOMEM;
    }
 
    /*
     * Request sharing the Path Lookup Buffer with VFS.
     */
    rc = ipc_call_sync_3(vfs_phone, IPC_M_AS_AREA_RECV, plb_ro, PLB_SIZE, 0,
        NULL, NULL, NULL);
    if (rc) {
        async_wait_for(req, NULL);
        return rc;
    }
     
    /*
     * Create a connection fibril to handle the callback connection.
     */
    async_new_connection(phonehash, 0, NULL, fat_connection);
   
    /*
     * Tell the async framework that other connections are to be handled by
     * the same connection fibril as well.
     */
    async_set_client_connection(fat_connection);
 
    /*
     * Pick up the answer for the request to the VFS_REQUEST call.
     */
    async_wait_for(req, NULL);
    dprintf("FAT filesystem registered.\n");
 
    async_create_manager();
 
    /*
     * TODO: Interestingly, if we merely return, the only thread dies.
     *   If the only thread dies, the whole task is destroyed.
     *   Prevent the thread from exiting when there are active fibrils.
     */
    fibril_schedule_next_adv(FIBRIL_FROM_DEAD);
    /* not reached */
 
    return 0;
}
 
/**
 * @}
 */
 

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/fs/fat/fat.c @ 3674 – Rev 2536 → 2543

Rev 2536		Rev 2543
1	/*	1	/*
2	* Copyright (c) 2006 Martin Decky	2	* Copyright (c) 2006 Martin Decky
3	* Copyright (c) 2007 Jakub Jermar	3	* Copyright (c) 2007 Jakub Jermar
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	14	* documentation and/or other materials provided with the distribution.
15	* - The name of the author may not be used to endorse or promote products	15	* - The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30	/** @addtogroup fs	30	/** @addtogroup fs
31	* @{	31	* @{
32	*/	32	*/
33		33
34	/**	34	/**
35	* @file fat.c	35	* @file fat.c
36	* @brief FAT file system driver for HelenOS.	36	* @brief FAT file system driver for HelenOS.
37	*/	37	*/
38		38
39	#include <ipc/ipc.h>	39	#include <ipc/ipc.h>
40	#include <ipc/services.h>	40	#include <ipc/services.h>
41	#include <async.h>	41	#include <async.h>
42	#include <errno.h>	42	#include <errno.h>
43	#include <unistd.h>	43	#include <unistd.h>
44	#include <stdio.h>	44	#include <stdio.h>
-		45	#include <as.h>>
45	#include "../../vfs/vfs.h"	46	#include "../../vfs/vfs.h"
46		47
47	#define dprintf(...) printf(__VA_ARGS__)	48	#define dprintf(...) printf(__VA_ARGS__)
48		49
49	vfs_info_t fat_vfs_info = {	50	vfs_info_t fat_vfs_info = {
50	.name = "fat",	51	.name = "fat",
51	.ops = {	52	.ops = {
52	[IPC_METHOD_TO_VFS_OP(VFS_REGISTER)] = VFS_OP_DEFINED,	53	[IPC_METHOD_TO_VFS_OP(VFS_REGISTER)] = VFS_OP_DEFINED,
53	[IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_DEFINED,	54	[IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_DEFINED,
54	[IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_DEFINED,	55	[IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_DEFINED,
55	[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,	56	[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
56	[IPC_METHOD_TO_VFS_OP(VFS_OPEN)] = VFS_OP_DEFINED,	57	[IPC_METHOD_TO_VFS_OP(VFS_OPEN)] = VFS_OP_DEFINED,
57	[IPC_METHOD_TO_VFS_OP(VFS_CREATE)] = VFS_OP_DEFINED,	58	[IPC_METHOD_TO_VFS_OP(VFS_CREATE)] = VFS_OP_DEFINED,
58	[IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] = VFS_OP_DEFINED,	59	[IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] = VFS_OP_DEFINED,
59	[IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,	60	[IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
60	[IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_NULL,	61	[IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_NULL,
61	[IPC_METHOD_TO_VFS_OP(VFS_SEEK)] = VFS_OP_DEFAULT	62	[IPC_METHOD_TO_VFS_OP(VFS_SEEK)] = VFS_OP_DEFAULT
62	}	63	}
63	};	64	};
64		65
-		66	uint8_t *plb_ro = NULL;
-		67
65	/**	68	/**
66	* This connection fibril processes VFS requests from VFS.	69	* This connection fibril processes VFS requests from VFS.
67	*	70	*
68	* In order to support simultaneous VFS requests, our design is as follows.	71	* In order to support simultaneous VFS requests, our design is as follows.
69	* The connection fibril accepts VFS requests from VFS. If there is only one	72	* The connection fibril accepts VFS requests from VFS. If there is only one
70	* instance of the fibril, VFS will need to serialize all VFS requests it sends	73	* instance of the fibril, VFS will need to serialize all VFS requests it sends
71	* to FAT. To overcome this bottleneck, VFS can send FAT the IPC_M_CONNECT_ME_TO	74	* to FAT. To overcome this bottleneck, VFS can send FAT the IPC_M_CONNECT_ME_TO
72	* call. In that case, a new connection fibril will be created, which in turn	75	* call. In that case, a new connection fibril will be created, which in turn
73	* will accept the call. Thus, a new phone will be opened for VFS.	76	* will accept the call. Thus, a new phone will be opened for VFS.
74	*	77	*
75	* There are few issues with this arrangement. First, VFS can run out of	78	* There are few issues with this arrangement. First, VFS can run out of
76	* available phones. In that case, VFS can close some other phones or use one	79	* available phones. In that case, VFS can close some other phones or use one
77	* phone for more serialized requests. Similarly, FAT can refuse to duplicate	80	* phone for more serialized requests. Similarly, FAT can refuse to duplicate
78	* the connection. VFS should then just make use of already existing phones and	81	* the connection. VFS should then just make use of already existing phones and
79	* route its requests through them. To avoid paying the fibril creation price	82	* route its requests through them. To avoid paying the fibril creation price
80	* upon each request, FAT might want to keep the connections open after the	83	* upon each request, FAT might want to keep the connections open after the
81	* request has been completed.	84	* request has been completed.
82	*/	85	*/
83	static void fat_connection(ipc_callid_t iid, ipc_call_t *icall)	86	static void fat_connection(ipc_callid_t iid, ipc_call_t *icall)
84	{	87	{
85	if (iid) {	88	if (iid) {
86	/*	89	/*
87	* This only happens for connections opened by	90	* This only happens for connections opened by
88	* IPC_M_CONNECT_ME_TO calls as opposed to callback connections	91	* IPC_M_CONNECT_ME_TO calls as opposed to callback connections
89	* created by IPC_M_CONNECT_TO_ME.	92	* created by IPC_M_CONNECT_TO_ME.
90	*/	93	*/
91	ipc_answer_fast(iid, EOK, 0, 0);	94	ipc_answer_fast(iid, EOK, 0, 0);
92	}	95	}
93		96
94	dprintf("VFS-FAT connection established.\n");	97	dprintf("VFS-FAT connection established.\n");
95	while (1) {	98	while (1) {
96	ipc_callid_t callid;	99	ipc_callid_t callid;
97	ipc_call_t call;	100	ipc_call_t call;
98		101
99	callid = async_get_call(&call);	102	callid = async_get_call(&call);
100	switch (IPC_GET_METHOD(call)) {	103	switch (IPC_GET_METHOD(call)) {
101	default:	104	default:
102	ipc_answer_fast(callid, ENOTSUP, 0, 0);	105	ipc_answer_fast(callid, ENOTSUP, 0, 0);
103	break;	106	break;
104	}	107	}
105	}	108	}
106	}	109	}
107		110
108	int main(int argc, char **argv)	111	int main(int argc, char **argv)
109	{	112	{
110	int vfs_phone;	113	int vfs_phone;
111		114
112	printf("FAT: HelenOS FAT file system server.\n");	115	printf("FAT: HelenOS FAT file system server.\n");
113		116
114	vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0);	117	vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0);
115	while (vfs_phone < EOK) {	118	while (vfs_phone < EOK) {
116	usleep(10000);	119	usleep(10000);
117	vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0);	120	vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0);
118	}	121	}
119		122
120	/*	123	/*
121	* Tell VFS that we are here and want to get registered.	124	* Tell VFS that we are here and want to get registered.
122	* We use the async framework because VFS will answer the request	125	* We use the async framework because VFS will answer the request
123	* out-of-order, when it knows that the operation succeeded or failed.	126	* out-of-order, when it knows that the operation succeeded or failed.
124	*/	127	*/
125	ipc_call_t answer;	128	ipc_call_t answer;
126	aid_t req = async_send_2(vfs_phone, VFS_REGISTER, 0, 0, &answer);	129	aid_t req = async_send_2(vfs_phone, VFS_REGISTER, 0, 0, &answer);
127		130
128	/*	131	/*
129	* Send our VFS info structure to VFS.	132	* Send our VFS info structure to VFS.
130	*/	133	*/
131	int rc = ipc_data_send(vfs_phone, &fat_vfs_info, sizeof(fat_vfs_info));	134	int rc = ipc_data_send(vfs_phone, &fat_vfs_info, sizeof(fat_vfs_info));
132	if (rc != EOK) {	135	if (rc != EOK) {
133	async_wait_for(req, NULL);	136	async_wait_for(req, NULL);
134	return rc;	137	return rc;
135	}	138	}
136		139
137	/*	140	/*
138	* Ask VFS for callback connection.	141	* Ask VFS for callback connection.
139	*/	142	*/
140	ipcarg_t phonehash;	143	ipcarg_t phonehash;
141	ipc_connect_to_me(vfs_phone, 0, 0, &phonehash);	144	ipc_connect_to_me(vfs_phone, 0, 0, &phonehash);
142		145
143	/*	146	/*
-		147	* Allocate piece of address space for PLB.
-		148	*/
-		149	plb_ro = as_get_mappable_page(PLB_SIZE);
-		150	if (!plb_ro) {
-		151	async_wait_for(req, NULL);
-		152	return ENOMEM;
-		153	}
-		154
-		155	/*
-		156	* Request sharing the Path Lookup Buffer with VFS.
-		157	*/
-		158	rc = ipc_call_sync_3(vfs_phone, IPC_M_AS_AREA_RECV, plb_ro, PLB_SIZE, 0,
-		159	NULL, NULL, NULL);
-		160	if (rc) {
-		161	async_wait_for(req, NULL);
-		162	return rc;
-		163	}
-		164
-		165	/*
144	* Create a connection fibril to handle the callback connection.	166	* Create a connection fibril to handle the callback connection.
145	*/	167	*/
146	async_new_connection(phonehash, 0, NULL, fat_connection);	168	async_new_connection(phonehash, 0, NULL, fat_connection);
147		169
148	/*	170	/*
149	* Tell the async framework that other connections are to be handled by	171	* Tell the async framework that other connections are to be handled by
150	* the same connection fibril as well.	172	* the same connection fibril as well.
151	*/	173	*/
152	async_set_client_connection(fat_connection);	174	async_set_client_connection(fat_connection);
153		175
154	/*	176	/*
155	* Pick up the answer for the request to the VFS_REQUEST call.	177	* Pick up the answer for the request to the VFS_REQUEST call.
156	*/	178	*/
157	async_wait_for(req, NULL);	179	async_wait_for(req, NULL);
158	dprintf("FAT filesystem registered.\n");	180	dprintf("FAT filesystem registered.\n");
159		181
160	async_create_manager();	182	async_create_manager();
161		183
162	/*	184	/*
163	* TODO: Interestingly, if we merely return, the only thread dies.	185	* TODO: Interestingly, if we merely return, the only thread dies.
164	* If the only thread dies, the whole task is destroyed.	186	* If the only thread dies, the whole task is destroyed.
165	* Prevent the thread from exiting when there are active fibrils.	187	* Prevent the thread from exiting when there are active fibrils.
166	*/	188	*/
167	fibril_schedule_next_adv(FIBRIL_FROM_DEAD);	189	fibril_schedule_next_adv(FIBRIL_FROM_DEAD);
168	/* not reached */	190	/* not reached */
169		191
170	return 0;	192	return 0;
171	}	193	}
172		194
173	/**	195	/**
174	* @}	196	* @}
175	*/	197	*/
176		198