WebSVN – HelenOS – Diff – /trunk/uspace/srv/vfs/vfs.c


/*
 * 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    vfs.c
 * @brief   VFS multiplexer for HelenOS.
 */
 
#include <ipc/ipc.h>
#include <ipc/services.h>
#include <async.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <bool.h>
#include <futex.h>
#include <libadt/list.h>
#include "vfs.h"
 
 
#define dprintf(...)    printf(__VA_ARGS__)
 
atomic_t fs_head_futex = FUTEX_INITIALIZER;
link_t fs_head;
 
/** 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;
            }
        }
    }
   
 
    /*
     * Check if the FS implements mandatory VFS operations.
     */
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_REGISTER)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_REGISTER not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_MOUNT not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_UNMOUNT not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_LOOKUP not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_OPEN)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_OPEN not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_CLOSE not defined by the client.\n");
        return false;
    }
    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_READ)] != VFS_OP_DEFINED) {
        dprintf("Operation VFS_READ not defined by the client.\n");
        return false;
    }
   
    /*
     * Check if each operation is either not defined, defined or default.
     */
    for (i = VFS_FIRST; i < VFS_LAST; i++) {
        if ((info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_NULL) &&
            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFAULT) &&
            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFINED)) {
            dprintf("Operation info not understood.\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.
 */
static 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_receive(&callid, &call, NULL, &size)) {
        /*
         * The client doesn't obey the same protocol as we do.
         */
        dprintf("Receiving of VFS info failed.\n");
        ipc_answer_fast(callid, EINVAL, 0, 0);
        ipc_answer_fast(rid, EINVAL, 0, 0);
        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_fast(callid, EINVAL, 0, 0);
        ipc_answer_fast(rid, EINVAL, 0, 0);
        return;
    }
    fs_info_t *fs_info;
 
    /*
     * Allocate and initialize a buffer for the fs_info structure.
     */
    fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
    if (!fs_info) {
        dprintf("Could not allocate memory for FS info.\n");
        ipc_answer_fast(callid, ENOMEM, 0, 0);
        ipc_answer_fast(rid, ENOMEM, 0, 0);
        return;
    }
    link_initialize(&fs_info->fs_link);
       
    rc = ipc_data_deliver(callid, &call, &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_fast(callid, rc, 0, 0);
        ipc_answer_fast(rid, rc, 0, 0);
        return;
    }
 
    dprintf("VFS info delivered.\n");
       
    if (!vfs_info_sane(&fs_info->vfs_info)) {
        free(fs_info);
        ipc_answer_fast(callid, EINVAL, 0, 0);
        ipc_answer_fast(rid, EINVAL, 0, 0);
        return;
    }
       
    futex_down(&fs_head_futex);
 
    /*
     * Check for duplicit registrations.
     */
    link_t *cur;
    for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
        fs_info_t *fi = list_get_instance(cur, fs_info_t,
            fs_link);
        /* TODO: replace strcmp with strncmp once we have it */
        if (strcmp(fs_info->vfs_info.name, fi->vfs_info.name) == 0) {
            /*
             * We already register a fs like this.
             */
            dprintf("FS is already registered.\n");
            futex_up(&fs_head_futex);
            free(fs_info);
            ipc_answer_fast(callid, EEXISTS, 0, 0);
            ipc_answer_fast(rid, EEXISTS, 0, 0);
            return;
        }
    }
 
    /*
     * Add fs_info to the list of registered FS's.
     */
    dprintf("Adding FS into the registered list.\n");
    list_append(&fs_info->fs_link, &fs_head);
 
    /*
     * ACK receiving a properly formatted, non-duplicit vfs_info.
     */
    ipc_answer_fast(callid, EOK, 0, 0);
   
    /*
     * 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);
        futex_up(&fs_head_futex);
        free(fs_info);
        ipc_answer_fast(callid, EINVAL, 0, 0);
        ipc_answer_fast(rid, EINVAL, 0, 0);
        return;
    }
    fs_info->phone = IPC_GET_ARG3(call);
    ipc_answer_fast(callid, EOK, 0, 0);
 
    dprintf("Callback connection to FS created.\n");
 
    futex_up(&fs_head_futex);
 
    /*
     * That was it. The FS has been registered.
     */
    ipc_answer_fast(rid, EOK, 0, 0);
    dprintf("\"%s\" filesystem successfully registered.\n",
        fs_info->vfs_info.name);
}
 
static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)
{
    bool keep_on_going = 1;
 
    printf("Connection opened from %p\n", icall->in_phone_hash);
 
    /*
     * The connection was opened via the IPC_CONNECT_ME_TO call.
     * This call needs to be answered.
     */
    ipc_answer_fast(iid, EOK, 0, 0);
 
    /*
     * Here we enter the main connection fibril loop.
     * The logic behind this loop and the protocol is that we'd like to keep
     * each connection open for a while before we close it. The benefit of
     * this is that the client doesn't have to establish a new connection
     * upon each request.  On the other hand, the client must be ready to
     * re-establish a connection if we hang it up due to reaching of maximum
     * number of requests per connection or due to the client timing out.
     */
     
    while (keep_on_going) {
        ipc_callid_t callid;
        ipc_call_t call;
 
        callid = async_get_call(&call);
 
        printf("Received call, method=%d\n", IPC_GET_METHOD(call));
       
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_PHONE_HUNGUP:
            keep_on_going = false;
            break;
        case VFS_REGISTER:
            vfs_register(callid, &call);
            keep_on_going = false;
            break;
        case VFS_MOUNT:
        case VFS_UNMOUNT:
        case VFS_OPEN:
        case VFS_CREATE:
        case VFS_CLOSE:
        case VFS_READ:
        case VFS_WRITE:
        case VFS_SEEK:
        default:
            ipc_answer_fast(callid, ENOTSUP, 0, 0);
            break;
        }
    }
 
    /* TODO: cleanup after the client */
   
}
 
int main(int argc, char **argv)
{
    ipcarg_t phonead;
 
    printf("VFS: HelenOS VFS server\n");
 
    list_initialize(&fs_head);
    async_set_client_connection(vfs_connection);
    ipc_connect_to_me(PHONE_NS, SERVICE_VFS, 0, &phonead);
    async_manager();
    return 0;
}
 
/**
 * @}
 */
 

Rev 2531	Rev 2532
1	/*	1	/*
2	* Copyright (c) 2007 Jakub Jermar	2	* Copyright (c) 2007 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.c	34	* @file vfs.c
35	* @brief VFS multiplexer for HelenOS.	35	* @brief VFS multiplexer for HelenOS.
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 <errno.h>	41	#include <errno.h>
-		42	#include <stdio.h>
42	#include <stdlib.h>	43	#include <stdlib.h>
43	#include <string.h>	44	#include <string.h>
44	#include <ctype.h>	45	#include <ctype.h>
45	#include <bool.h>	46	#include <bool.h>
46	#include <futex.h>	47	#include <futex.h>
47	#include <libadt/list.h>	48	#include <libadt/list.h>
48	#include "vfs.h"	49	#include "vfs.h"
49		50
-		51
-		52	#define dprintf(...) printf(__VA_ARGS__)
-		53
50	atomic_t fs_head_futex = FUTEX_INITIALIZER;	54	atomic_t fs_head_futex = FUTEX_INITIALIZER;
51	link_t fs_head;	55	link_t fs_head;
52		56
53	/** Verify the VFS info structure.	57	/** Verify the VFS info structure.
54	*	58	*
55	* @param info Info structure to be verified.	59	* @param info Info structure to be verified.
56	*	60	*
57	* @return Non-zero if the info structure is sane, zero otherwise.	61	* @return Non-zero if the info structure is sane, zero otherwise.
58	*/	62	*/
59	static bool vfs_info_sane(vfs_info_t *info)	63	static bool vfs_info_sane(vfs_info_t *info)
60	{	64	{
61	int i;	65	int i;
62		66
63	/*	67	/*
64	* Check if the name is non-empty and is composed solely of ASCII	68	* Check if the name is non-empty and is composed solely of ASCII
65	* characters [a-z]+[a-z0-9_-]*.	69	* characters [a-z]+[a-z0-9_-]*.
66	*/	70	*/
67	if (!islower(info->name[0]))	71	if (!islower(info->name[0])) {
-		72	dprintf("The name doesn't start with a lowercase character.\n");
68	return false;	73	return false;
-		74	}
69	for (i = 1; i < FS_NAME_MAXLEN; i++) {	75	for (i = 1; i < FS_NAME_MAXLEN; i++) {
70	if (!(islower(info->name[i]) \|\| isdigit(info->name[i])) &&	76	if (!(islower(info->name[i]) \|\| isdigit(info->name[i])) &&
71	(info->name[i] != '-') && (info->name[i] != '_')) {	77	(info->name[i] != '-') && (info->name[i] != '_')) {
72	if (info->name[i] == '\0')	78	if (info->name[i] == '\0') {
73	break;	79	break;
74	else	80	} else {
-		81	dprintf("The name contains illegal "
-		82	"characters.\n");
75	return false;	83	return false;
-		84	}
76	}	85	}
77	}	86	}
78		87
79		88
80	/*	89	/*
81	* Check if the FS implements mandatory VFS operations.	90	* Check if the FS implements mandatory VFS operations.
82	*/	91	*/
83	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_REGISTER)] != VFS_OP_DEFINED)	92	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_REGISTER)] != VFS_OP_DEFINED) {
-		93	dprintf("Operation VFS_REGISTER not defined by the client.\n");
84	return false;	94	return false;
-		95	}
85	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] != VFS_OP_DEFINED)	96	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] != VFS_OP_DEFINED) {
-		97	dprintf("Operation VFS_MOUNT not defined by the client.\n");
86	return false;	98	return false;
-		99	}
87	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] != VFS_OP_DEFINED)	100	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] != VFS_OP_DEFINED) {
-		101	dprintf("Operation VFS_UNMOUNT not defined by the client.\n");
88	return false;	102	return false;
-		103	}
89	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] != VFS_OP_DEFINED)	104	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] != VFS_OP_DEFINED) {
-		105	dprintf("Operation VFS_LOOKUP not defined by the client.\n");
90	return false;	106	return false;
-		107	}
91	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_OPEN)] != VFS_OP_DEFINED)	108	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_OPEN)] != VFS_OP_DEFINED) {
-		109	dprintf("Operation VFS_OPEN not defined by the client.\n");
92	return false;	110	return false;
-		111	}
93	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] != VFS_OP_DEFINED)	112	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] != VFS_OP_DEFINED) {
-		113	dprintf("Operation VFS_CLOSE not defined by the client.\n");
94	return false;	114	return false;
-		115	}
95	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_READ)] != VFS_OP_DEFINED)	116	if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_READ)] != VFS_OP_DEFINED) {
-		117	dprintf("Operation VFS_READ not defined by the client.\n");
96	return false;	118	return false;
-		119	}
97		120
98	/*	121	/*
99	* Check if each operation is either not defined, defined or default.	122	* Check if each operation is either not defined, defined or default.
100	*/	123	*/
101	for (i = VFS_FIRST; i < VFS_LAST; i++) {	124	for (i = VFS_FIRST; i < VFS_LAST; i++) {
102	if ((IPC_METHOD_TO_VFS_OP(i) != VFS_OP_NULL) &&	125	if ((info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_NULL) &&
103	(IPC_METHOD_TO_VFS_OP(i) != VFS_OP_DEFAULT) &&	126	(info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFAULT) &&
104	(IPC_METHOD_TO_VFS_OP(i) != VFS_OP_DEFINED))	127	(info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFINED)) {
-		128	dprintf("Operation info not understood.\n");
105	return false;	129	return false;
-		130	}
106	}	131	}
107	return true;	132	return true;
108	}	133	}
109		134
110	/** VFS_REGISTER protocol function.	135	/** VFS_REGISTER protocol function.
111	*	136	*
112	* @param rid Hash of the call with the request.	137	* @param rid Hash of the call with the request.
113	* @param request Call structure with the request.	138	* @param request Call structure with the request.
114	*/	139	*/
115	static void vfs_register(ipc_callid_t rid, ipc_call_t *request)	140	static void vfs_register(ipc_callid_t rid, ipc_call_t *request)
116	{	141	{
117	ipc_callid_t callid;	142	ipc_callid_t callid;
118	ipc_call_t call;	143	ipc_call_t call;
119	int rc;	144	int rc;
120	size_t size;	145	size_t size;
121		146
-		147	dprintf("Processing VFS_REGISTER request received from %p.\n",
-		148	request->in_phone_hash);
-		149
122	/*	150	/*
123	* The first call has to be IPC_M_DATA_SEND in which we receive the	151	* The first call has to be IPC_M_DATA_SEND in which we receive the
124	* VFS info structure from the client FS.	152	* VFS info structure from the client FS.
125	*/	153	*/
126	if (!ipc_data_receive(&callid, &call, NULL, &size)) {	154	if (!ipc_data_receive(&callid, &call, NULL, &size)) {
127	/*	155	/*
128	* The client doesn't obey the same protocol as we do.	156	* The client doesn't obey the same protocol as we do.
129	*/	157	*/
-		158	dprintf("Receiving of VFS info failed.\n");
130	ipc_answer_fast(callid, EINVAL, 0, 0);	159	ipc_answer_fast(callid, EINVAL, 0, 0);
131	ipc_answer_fast(rid, EINVAL, 0, 0);	160	ipc_answer_fast(rid, EINVAL, 0, 0);
132	return;	161	return;
133	}	162	}
134		163
-		164	dprintf("VFS info received, size = %d\n", size);
-		165
135	/*	166	/*
136	* We know the size of the VFS info structure. See if the client	167	* We know the size of the VFS info structure. See if the client
137	* understands this easy concept too.	168	* understands this easy concept too.
138	*/	169	*/
139	if (size != sizeof(vfs_info_t)) {	170	if (size != sizeof(vfs_info_t)) {
140	/*	171	/*
141	* The client is sending us something, which cannot be	172	* The client is sending us something, which cannot be
142	* the info structure.	173	* the info structure.
143	*/	174	*/
-		175	dprintf("Received VFS info has bad size.\n");
144	ipc_answer_fast(callid, EINVAL, 0, 0);	176	ipc_answer_fast(callid, EINVAL, 0, 0);
145	ipc_answer_fast(rid, EINVAL, 0, 0);	177	ipc_answer_fast(rid, EINVAL, 0, 0);
146	return;	178	return;
147	}	179	}
148	fs_info_t *fs_info;	180	fs_info_t *fs_info;
149		181
150	/*	182	/*
151	* Allocate and initialize a buffer for the fs_info structure.	183	* Allocate and initialize a buffer for the fs_info structure.
152	*/	184	*/
153	fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));	185	fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
154	if (!fs_info) {	186	if (!fs_info) {
-		187	dprintf("Could not allocate memory for FS info.\n");
155	ipc_answer_fast(callid, ENOMEM, 0, 0);	188	ipc_answer_fast(callid, ENOMEM, 0, 0);
156	ipc_answer_fast(rid, ENOMEM, 0, 0);	189	ipc_answer_fast(rid, ENOMEM, 0, 0);
157	return;	190	return;
158	}	191	}
159	link_initialize(&fs_info->fs_link);	192	link_initialize(&fs_info->fs_link);
160		193
161	rc = ipc_data_deliver(callid, &call, &fs_info->vfs_info, size);	194	rc = ipc_data_deliver(callid, &call, &fs_info->vfs_info, size);
-		195	if (rc != EOK) {
-		196	dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
162	if (!rc) {	197	rc);
163	free(fs_info);	198	free(fs_info);
164	ipc_answer_fast(callid, rc, 0, 0);	199	ipc_answer_fast(callid, rc, 0, 0);
165	ipc_answer_fast(rid, rc, 0, 0);	200	ipc_answer_fast(rid, rc, 0, 0);
166	return;	201	return;
167	}	202	}
-		203
-		204	dprintf("VFS info delivered.\n");
168		205
169	if (!vfs_info_sane(&fs_info->vfs_info)) {	206	if (!vfs_info_sane(&fs_info->vfs_info)) {
170	free(fs_info);	207	free(fs_info);
171	ipc_answer_fast(callid, EINVAL, 0, 0);	208	ipc_answer_fast(callid, EINVAL, 0, 0);
172	ipc_answer_fast(rid, EINVAL, 0, 0);	209	ipc_answer_fast(rid, EINVAL, 0, 0);
173	return;	210	return;
174	}	211	}
175		212
176	futex_down(&fs_head_futex);	213	futex_down(&fs_head_futex);
177		214
178	/*	215	/*
179	* Check for duplicit registrations.	216	* Check for duplicit registrations.
180	*/	217	*/
181	link_t *cur;	218	link_t *cur;
182	for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {	219	for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
183	fs_info_t *fi = list_get_instance(cur, fs_info_t,	220	fs_info_t *fi = list_get_instance(cur, fs_info_t,
184	fs_link);	221	fs_link);
185	/* TODO: replace strcmp with strncmp once we have it */	222	/* TODO: replace strcmp with strncmp once we have it */
186	if (strcmp(fs_info->vfs_info.name, fi->vfs_info.name) == 0) {	223	if (strcmp(fs_info->vfs_info.name, fi->vfs_info.name) == 0) {
187	/*	224	/*
188	* We already register a fs like this.	225	* We already register a fs like this.
189	*/	226	*/
-		227	dprintf("FS is already registered.\n");
190	futex_up(&fs_head_futex);	228	futex_up(&fs_head_futex);
191	free(fs_info);	229	free(fs_info);
192	ipc_answer_fast(callid, EEXISTS, 0, 0);	230	ipc_answer_fast(callid, EEXISTS, 0, 0);
193	ipc_answer_fast(rid, EEXISTS, 0, 0);	231	ipc_answer_fast(rid, EEXISTS, 0, 0);
194	return;	232	return;
195	}	233	}
196	}	234	}
197		235
198	/*	236	/*
199	* Add fs_info to the list of registered FS's.	237	* Add fs_info to the list of registered FS's.
200	*/	238	*/
-		239	dprintf("Adding FS into the registered list.\n");
201	list_append(&fs_info->fs_link, &fs_head);	240	list_append(&fs_info->fs_link, &fs_head);
202		241
203	/*	242	/*
204	* ACK receiving a properly formatted, non-duplicit vfs_info.	243	* ACK receiving a properly formatted, non-duplicit vfs_info.
205	*/	244	*/
206	ipc_answer_fast(callid, EOK, 0, 0);	245	ipc_answer_fast(callid, EOK, 0, 0);
207		246
208	/*	247	/*
209	* Now we want the client to send us the IPC_M_CONNECT_TO_ME call so	248	* 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	249	* that a callback connection is created and we have a phone through
211	* which to forward VFS requests to it.	250	* which to forward VFS requests to it.
212	*/	251	*/
213	callid = async_get_call(&call);	252	callid = async_get_call(&call);
214	if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {	253	if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
-		254	dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
215	list_remove(&fs_info->fs_link);	255	list_remove(&fs_info->fs_link);
216	futex_up(&fs_head_futex);	256	futex_up(&fs_head_futex);
217	free(fs_info);	257	free(fs_info);
218	ipc_answer_fast(callid, EINVAL, 0, 0);	258	ipc_answer_fast(callid, EINVAL, 0, 0);
219	ipc_answer_fast(rid, EINVAL, 0, 0);	259	ipc_answer_fast(rid, EINVAL, 0, 0);
220	return;	260	return;
221	}	261	}
222	fs_info->phone = IPC_GET_ARG3(call);	262	fs_info->phone = IPC_GET_ARG3(call);
223	ipc_answer_fast(callid, EOK, 0, 0);	263	ipc_answer_fast(callid, EOK, 0, 0);
224		264
-		265	dprintf("Callback connection to FS created.\n");
-		266
225	futex_up(&fs_head_futex);	267	futex_up(&fs_head_futex);
226		268
227	/*	269	/*
228	* That was it. The FS has been registered.	270	* That was it. The FS has been registered.
229	*/	271	*/
230	ipc_answer_fast(rid, EOK, 0, 0);	272	ipc_answer_fast(rid, EOK, 0, 0);
-		273	dprintf("\"%s\" filesystem successfully registered.\n",
-		274	fs_info->vfs_info.name);
231	}	275	}
232		276
233	static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)	277	static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)
234	{	278	{
235	bool keep_on_going = 1;	279	bool keep_on_going = 1;
236		280
-		281	printf("Connection opened from %p\n", icall->in_phone_hash);
-		282
237	/*	283	/*
238	* The connection was opened via the IPC_CONNECT_ME_TO call.	284	* The connection was opened via the IPC_CONNECT_ME_TO call.
239	* This call needs to be answered.	285	* This call needs to be answered.
240	*/	286	*/
241	ipc_answer_fast(iid, EOK, 0, 0);	287	ipc_answer_fast(iid, EOK, 0, 0);
242		288
243	/*	289	/*
244	* Here we enter the main connection fibril loop.	290	* Here we enter the main connection fibril loop.
245	* The logic behind this loop and the protocol is that we'd like to keep	291	* The logic behind this loop and the protocol is that we'd like to keep
246	* each connection open for a while before we close it. The benefit of	292	* each connection open for a while before we close it. The benefit of
247	* this is that the client doesn't have to establish a new connection	293	* this is that the client doesn't have to establish a new connection
248	* upon each request. On the other hand, the client must be ready to	294	* upon each request. On the other hand, the client must be ready to
249	* re-establish a connection if we hang it up due to reaching of maximum	295	* re-establish a connection if we hang it up due to reaching of maximum
250	* number of requests per connection or due to the client timing out.	296	* number of requests per connection or due to the client timing out.
251	*/	297	*/
252		298
253	while (keep_on_going) {	299	while (keep_on_going) {
254	ipc_callid_t callid;	300	ipc_callid_t callid;
255	ipc_call_t call;	301	ipc_call_t call;
256		302
257	callid = async_get_call(&call);	303	callid = async_get_call(&call);
-		304
-		305	printf("Received call, method=%d\n", IPC_GET_METHOD(call));
258		306
259	switch (IPC_GET_METHOD(call)) {	307	switch (IPC_GET_METHOD(call)) {
260	case IPC_M_PHONE_HUNGUP:	308	case IPC_M_PHONE_HUNGUP:
261	keep_on_going = false;	309	keep_on_going = false;
262	break;	310	break;
263	case VFS_REGISTER:	311	case VFS_REGISTER:
264	vfs_register(callid, &call);	312	vfs_register(callid, &call);
265	keep_on_going = false;	313	keep_on_going = false;
266	break;	314	break;
267	case VFS_MOUNT:	315	case VFS_MOUNT:
268	case VFS_UNMOUNT:	316	case VFS_UNMOUNT:
269	case VFS_OPEN:	317	case VFS_OPEN:
270	case VFS_CREATE:	318	case VFS_CREATE:
271	case VFS_CLOSE:	319	case VFS_CLOSE:
272	case VFS_READ:	320	case VFS_READ:
273	case VFS_WRITE:	321	case VFS_WRITE:
274	case VFS_SEEK:	322	case VFS_SEEK:
275	default:	323	default:
276	ipc_answer_fast(callid, ENOTSUP, 0, 0);	324	ipc_answer_fast(callid, ENOTSUP, 0, 0);
277	break;	325	break;
278	}	326	}
279	}	327	}
280		328
281	/* TODO: cleanup after the client */	329	/* TODO: cleanup after the client */
282		330
283	}	331	}
284		332
285	int main(int argc, char **argv)	333	int main(int argc, char **argv)
286	{	334	{
287	ipcarg_t phonead;	335	ipcarg_t phonead;
288		336
-		337	printf("VFS: HelenOS VFS server\n");
-		338
289	list_initialize(&fs_head);	339	list_initialize(&fs_head);
290	async_set_client_connection(vfs_connection);	340	async_set_client_connection(vfs_connection);
291	ipc_connect_to_me(PHONE_NS, SERVICE_VFS, 0, &phonead);	341	ipc_connect_to_me(PHONE_NS, SERVICE_VFS, 0, &phonead);
292	async_manager();	342	async_manager();
293	return 0;	343	return 0;
294	}	344	}
295		345
296	/**	346	/**
297	* @}	347	* @}
298	*/	348	*/
299		349

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/vfs/vfs.c – Rev 2531 → 2532