WebSVN – HelenOS – Diff – /branches/network/uspace/srv/bd/file_bd/file_bd.c


/*
 * Copyright (c) 2009 Jiri Svoboda
 * 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 bd
 * @{
 */
 
/**
 * @file
 * @brief File-backed block device driver
 *
 * Allows accessing a file as a block device. Useful for, e.g., mounting
 * a disk image.
 */
 
#include <stdio.h>
#include <unistd.h>
#include <ipc/ipc.h>
#include <ipc/bd.h>
#include <async.h>
#include <as.h>
#include <fibril_sync.h>
#include <devmap.h>
#include <sys/types.h>
#include <errno.h>
#include <bool.h>
#include <task.h>
 
#define NAME "file_bd"
 
static size_t comm_size;
static FILE *img;
 
static dev_handle_t dev_handle;
static fibril_mutex_t dev_lock;
 
static int file_bd_init(const char *fname);
static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
static int file_bd_read(off_t blk_idx, size_t size, void *buf);
static int file_bd_write(off_t blk_idx, size_t size, void *buf);
 
int main(int argc, char **argv)
{
    int rc;
 
    printf(NAME ": File-backed block device driver\n");
 
    if (argc != 3) {
        printf("Expected two arguments (image name, device name).\n");
        return -1;
    }
 
    if (file_bd_init(argv[1]) != EOK)
        return -1;
 
    rc = devmap_device_register(argv[2], &dev_handle);
    if (rc != EOK) {
        devmap_hangup_phone(DEVMAP_DRIVER);
        printf(NAME ": Unable to register device %s.\n",
            argv[2]);
        return rc;
    }
 
    printf(NAME ": Accepting connections\n");
    task_retval(0);
    async_manager();
 
    /* Not reached */
    return 0;
}
 
static int file_bd_init(const char *fname)
{
    int rc;
 
    rc = devmap_driver_register(NAME, file_bd_connection);
    if (rc < 0) {
        printf(NAME ": Unable to register driver.\n");
        return rc;
    }
 
    img = fopen(fname, "rb+");
    if (img == NULL)
        return EINVAL;
 
    fibril_mutex_initialize(&dev_lock);
 
    return EOK;
}
 
static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
{
    void *fs_va = NULL;
    ipc_callid_t callid;
    ipc_call_t call;
    ipcarg_t method;
    int flags;
    int retval;
    off_t idx;
    size_t size;
 
    /* Answer the IPC_M_CONNECT_ME_TO call. */
    ipc_answer_0(iid, EOK);
 
    if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
        ipc_answer_0(callid, EHANGUP);
        return;
    }
 
    fs_va = as_get_mappable_page(comm_size);
    if (fs_va == NULL) {
        ipc_answer_0(callid, EHANGUP);
        return;
    }
 
    (void) ipc_share_out_finalize(callid, fs_va);
 
    while (1) {
        callid = async_get_call(&call);
        method = IPC_GET_METHOD(call);
        switch (method) {
        case IPC_M_PHONE_HUNGUP:
            /* The other side has hung up. */
            ipc_answer_0(callid, EOK);
            return;
        case BD_READ_BLOCK:
        case BD_WRITE_BLOCK:
            idx = IPC_GET_ARG1(call);
            size = IPC_GET_ARG2(call);
            if (size > comm_size) {
                retval = EINVAL;
                break;
            }
            if (method == BD_READ_BLOCK)
                retval = file_bd_read(idx, size, fs_va);
            else
                retval = file_bd_write(idx, size, fs_va);
            break;
        default:
            retval = EINVAL;
            break;
        }
        ipc_answer_0(callid, retval);
    }
}
 
static int file_bd_read(off_t blk_idx, size_t size, void *buf)
{
    size_t n_rd;
 
    fibril_mutex_lock(&dev_lock);
 
    fseek(img, blk_idx * size, SEEK_SET);
    n_rd = fread(buf, 1, size, img);
 
    if (ferror(img)) {
        fibril_mutex_unlock(&dev_lock);
        return EIO; /* Read error */
    }
 
    fibril_mutex_unlock(&dev_lock);
 
    if (n_rd < size)
        return EINVAL;  /* Read beyond end of disk */
 
    return EOK;
}
 
static int file_bd_write(off_t blk_idx, size_t size, void *buf)
{
    size_t n_wr;
 
    fibril_mutex_lock(&dev_lock);
 
    fseek(img, blk_idx * size, SEEK_SET);
    n_wr = fread(buf, 1, size, img);
 
    if (ferror(img) || n_wr < size) {
        fibril_mutex_unlock(&dev_lock);
        return EIO; /* Write error */
    }
 
    fibril_mutex_unlock(&dev_lock);
 
    return EOK;
}
 
/**
 * @}
 */
 

Rev 4581	Rev 4718
1	/*	1	/*
2	* Copyright (c) 2009 Jiri Svoboda	2	* Copyright (c) 2009 Jiri Svoboda
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 bd	29	/** @addtogroup bd
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file	34	* @file
35	* @brief File-backed block device driver	35	* @brief File-backed block device driver
36	*	36	*
37	* Allows accessing a file as a block device. Useful for, e.g., mounting	37	* Allows accessing a file as a block device. Useful for, e.g., mounting
38	* a disk image.	38	* a disk image.
39	*/	39	*/
40		40
41	#include <stdio.h>	41	#include <stdio.h>
42	#include <unistd.h>	42	#include <unistd.h>
43	#include <ipc/ipc.h>	43	#include <ipc/ipc.h>
44	#include <ipc/bd.h>	44	#include <ipc/bd.h>
45	#include <async.h>	45	#include <async.h>
46	#include <as.h>	46	#include <as.h>
47	#include <fibril_sync.h>	47	#include <fibril_sync.h>
48	#include <devmap.h>	48	#include <devmap.h>
49	#include <sys/types.h>	49	#include <sys/types.h>
50	#include <errno.h>	50	#include <errno.h>
51	#include <bool.h>	51	#include <bool.h>
-		52	#include <task.h>
52		53
53	#define NAME "file_bd"	54	#define NAME "file_bd"
54		55
55	static size_t comm_size;	56	static size_t comm_size;
56	static FILE *img;	57	static FILE *img;
57		58
58	static dev_handle_t dev_handle;	59	static dev_handle_t dev_handle;
59	static fibril_mutex_t dev_lock;	60	static fibril_mutex_t dev_lock;
60		61
61	static int file_bd_init(const char *fname);	62	static int file_bd_init(const char *fname);
62	static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall);	63	static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
63	static int file_bd_read(off_t blk_idx, size_t size, void *buf);	64	static int file_bd_read(off_t blk_idx, size_t size, void *buf);
64	static int file_bd_write(off_t blk_idx, size_t size, void *buf);	65	static int file_bd_write(off_t blk_idx, size_t size, void *buf);
65		66
66	int main(int argc, char **argv)	67	int main(int argc, char **argv)
67	{	68	{
68	int rc;	69	int rc;
69		70
70	printf(NAME ": File-backed block device driver\n");	71	printf(NAME ": File-backed block device driver\n");
71		72
72	if (argc != 3) {	73	if (argc != 3) {
73	printf("Expected two arguments (image name, device name).\n");	74	printf("Expected two arguments (image name, device name).\n");
74	return -1;	75	return -1;
75	}	76	}
76		77
77	if (file_bd_init(argv[1]) != EOK)	78	if (file_bd_init(argv[1]) != EOK)
78	return -1;	79	return -1;
79		80
80	rc = devmap_device_register(argv[2], &dev_handle);	81	rc = devmap_device_register(argv[2], &dev_handle);
81	if (rc != EOK) {	82	if (rc != EOK) {
82	devmap_hangup_phone(DEVMAP_DRIVER);	83	devmap_hangup_phone(DEVMAP_DRIVER);
83	printf(NAME ": Unable to register device %s.\n",	84	printf(NAME ": Unable to register device %s.\n",
84	argv[2]);	85	argv[2]);
85	return rc;	86	return rc;
86	}	87	}
87		88
88	printf(NAME ": Accepting connections\n");	89	printf(NAME ": Accepting connections\n");
-		90	task_retval(0);
89	async_manager();	91	async_manager();
90		92
91	/* Not reached */	93	/* Not reached */
92	return 0;	94	return 0;
93	}	95	}
94		96
95	static int file_bd_init(const char *fname)	97	static int file_bd_init(const char *fname)
96	{	98	{
97	int rc;	99	int rc;
98		100
99	rc = devmap_driver_register(NAME, file_bd_connection);	101	rc = devmap_driver_register(NAME, file_bd_connection);
100	if (rc < 0) {	102	if (rc < 0) {
101	printf(NAME ": Unable to register driver.\n");	103	printf(NAME ": Unable to register driver.\n");
102	return rc;	104	return rc;
103	}	105	}
104		106
105	img = fopen(fname, "rb+");	107	img = fopen(fname, "rb+");
106	if (img == NULL)	108	if (img == NULL)
107	return EINVAL;	109	return EINVAL;
108		110
109	fibril_mutex_initialize(&dev_lock);	111	fibril_mutex_initialize(&dev_lock);
110		112
111	return EOK;	113	return EOK;
112	}	114	}
113		115
114	static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall)	116	static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
115	{	117	{
116	void *fs_va = NULL;	118	void *fs_va = NULL;
117	ipc_callid_t callid;	119	ipc_callid_t callid;
118	ipc_call_t call;	120	ipc_call_t call;
119	ipcarg_t method;	121	ipcarg_t method;
120	int flags;	122	int flags;
121	int retval;	123	int retval;
122	off_t idx;	124	off_t idx;
123	size_t size;	125	size_t size;
124		126
125	/* Answer the IPC_M_CONNECT_ME_TO call. */	127	/* Answer the IPC_M_CONNECT_ME_TO call. */
126	ipc_answer_0(iid, EOK);	128	ipc_answer_0(iid, EOK);
127		129
128	if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {	130	if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
129	ipc_answer_0(callid, EHANGUP);	131	ipc_answer_0(callid, EHANGUP);
130	return;	132	return;
131	}	133	}
132		134
133	fs_va = as_get_mappable_page(comm_size);	135	fs_va = as_get_mappable_page(comm_size);
134	if (fs_va == NULL) {	136	if (fs_va == NULL) {
135	ipc_answer_0(callid, EHANGUP);	137	ipc_answer_0(callid, EHANGUP);
136	return;	138	return;
137	}	139	}
138		140
139	(void) ipc_share_out_finalize(callid, fs_va);	141	(void) ipc_share_out_finalize(callid, fs_va);
140		142
141	while (1) {	143	while (1) {
142	callid = async_get_call(&call);	144	callid = async_get_call(&call);
143	method = IPC_GET_METHOD(call);	145	method = IPC_GET_METHOD(call);
144	switch (method) {	146	switch (method) {
145	case IPC_M_PHONE_HUNGUP:	147	case IPC_M_PHONE_HUNGUP:
146	/* The other side has hung up. */	148	/* The other side has hung up. */
147	ipc_answer_0(callid, EOK);	149	ipc_answer_0(callid, EOK);
148	return;	150	return;
149	case BD_READ_BLOCK:	151	case BD_READ_BLOCK:
150	case BD_WRITE_BLOCK:	152	case BD_WRITE_BLOCK:
151	idx = IPC_GET_ARG1(call);	153	idx = IPC_GET_ARG1(call);
152	size = IPC_GET_ARG2(call);	154	size = IPC_GET_ARG2(call);
153	if (size > comm_size) {	155	if (size > comm_size) {
154	retval = EINVAL;	156	retval = EINVAL;
155	break;	157	break;
156	}	158	}
157	if (method == BD_READ_BLOCK)	159	if (method == BD_READ_BLOCK)
158	retval = file_bd_read(idx, size, fs_va);	160	retval = file_bd_read(idx, size, fs_va);
159	else	161	else
160	retval = file_bd_write(idx, size, fs_va);	162	retval = file_bd_write(idx, size, fs_va);
161	break;	163	break;
162	default:	164	default:
163	retval = EINVAL;	165	retval = EINVAL;
164	break;	166	break;
165	}	167	}
166	ipc_answer_0(callid, retval);	168	ipc_answer_0(callid, retval);
167	}	169	}
168	}	170	}
169		171
170	static int file_bd_read(off_t blk_idx, size_t size, void *buf)	172	static int file_bd_read(off_t blk_idx, size_t size, void *buf)
171	{	173	{
172	size_t n_rd;	174	size_t n_rd;
173		175
174	fibril_mutex_lock(&dev_lock);	176	fibril_mutex_lock(&dev_lock);
175		177
176	fseek(img, blk_idx * size, SEEK_SET);	178	fseek(img, blk_idx * size, SEEK_SET);
177	n_rd = fread(buf, 1, size, img);	179	n_rd = fread(buf, 1, size, img);
178		180
179	if (ferror(img)) {	181	if (ferror(img)) {
180	fibril_mutex_unlock(&dev_lock);	182	fibril_mutex_unlock(&dev_lock);
181	return EIO; /* Read error */	183	return EIO; /* Read error */
182	}	184	}
183		185
184	fibril_mutex_unlock(&dev_lock);	186	fibril_mutex_unlock(&dev_lock);
185		187
186	if (n_rd < size)	188	if (n_rd < size)
187	return EINVAL; /* Read beyond end of disk */	189	return EINVAL; /* Read beyond end of disk */
188		190
189	return EOK;	191	return EOK;
190	}	192	}
191		193
192	static int file_bd_write(off_t blk_idx, size_t size, void *buf)	194	static int file_bd_write(off_t blk_idx, size_t size, void *buf)
193	{	195	{
194	size_t n_wr;	196	size_t n_wr;
195		197
196	fibril_mutex_lock(&dev_lock);	198	fibril_mutex_lock(&dev_lock);
197		199
198	fseek(img, blk_idx * size, SEEK_SET);	200	fseek(img, blk_idx * size, SEEK_SET);
199	n_wr = fread(buf, 1, size, img);	201	n_wr = fread(buf, 1, size, img);
200		202
201	if (ferror(img) \|\| n_wr < size) {	203	if (ferror(img) \|\| n_wr < size) {
202	fibril_mutex_unlock(&dev_lock);	204	fibril_mutex_unlock(&dev_lock);
203	return EIO; /* Write error */	205	return EIO; /* Write error */
204	}	206	}
205		207
206	fibril_mutex_unlock(&dev_lock);	208	fibril_mutex_unlock(&dev_lock);
207		209
208	return EOK;	210	return EOK;
209	}	211	}
210		212
211	/**	213	/**
212	* @}	214	* @}
213	*/	215	*/
214		216

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/bd/file_bd/file_bd.c – Rev 4581 → 4718