WebSVN – HelenOS – Diff – /trunk/uspace/lib/libblock/libblock.c


/*
 * Copyright (c) 2008 Jakub Jermar
 * Copyright (c) 2008 Martin Decky
 * 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 libblock
 * @{
 */
/**
 * @file
 * @brief
 */
 
#include "libblock.h" 
#include "../../srv/vfs/vfs.h"
#include "../../srv/rd/rd.h"
#include <ipc/devmap.h>
#include <ipc/services.h>
#include <errno.h>
#include <sys/mman.h>
#include <async.h>
#include <ipc/ipc.h>
#include <as.h>
#include <assert.h>
#include <futex.h>
#include <libadt/list.h>
 
/** Lock protecting the device connection list */
static futex_t dcl_lock = FUTEX_INITIALIZER;
/** Device connection list head. */
static LIST_INITIALIZE(dcl_head);
 
typedef struct {
    link_t link;
    int dev_handle;
    int dev_phone;
    void *com_area;
    size_t com_size;
    void *bb_buf;
    off_t bb_off;
    size_t bb_size;
} devcon_t;
 
static devcon_t *devcon_search(dev_handle_t dev_handle)
{
    link_t *cur;
 
    futex_down(&dcl_lock);
    for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
        devcon_t *devcon = list_get_instance(cur, devcon_t, link);
        if (devcon->dev_handle == dev_handle) {
            futex_up(&dcl_lock);
            return devcon;
        }
    }
    futex_up(&dcl_lock);
    return NULL;
}
 
static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
   size_t com_size)
{
    link_t *cur;
    devcon_t *devcon;
 
    devcon = malloc(sizeof(devcon_t));
    if (!devcon)
        return ENOMEM;
   
    link_initialize(&devcon->link);
    devcon->dev_handle = dev_handle;
    devcon->dev_phone = dev_phone;
    devcon->com_area = com_area;
    devcon->com_size = com_size;
    devcon->bb_buf = NULL;
    devcon->bb_off = 0;
    devcon->bb_size = 0;
 
    futex_down(&dcl_lock);
    for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
        devcon_t *d = list_get_instance(cur, devcon_t, link);
        if (d->dev_handle == dev_handle) {
            futex_up(&dcl_lock);
            free(devcon);
            return EEXIST;
        }
    }
    list_append(&devcon->link, &dcl_head);
    futex_up(&dcl_lock);
    return EOK;
}
 
static void devcon_remove(devcon_t *devcon)
{
    futex_down(&dcl_lock);
    list_remove(&devcon->link);
    futex_up(&dcl_lock);
}
 
 
int block_init(dev_handle_t dev_handle, size_t com_size)
 
{
    int rc;
    int dev_phone;
    void *com_area;
 
 
 
 
 
   
    com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    if (!com_area) {
 
        return ENOMEM;
    }
    dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
 
    if (dev_phone < 0) {
 
        munmap(com_area, com_size);
        return dev_phone;
    }
 
    rc = ipc_share_out_start(dev_phone, com_area,
        AS_AREA_READ | AS_AREA_WRITE);
    if (rc != EOK) {
 
            munmap(com_area, com_size);
        ipc_hangup(dev_phone);
        return rc;
    }
   
    rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
 
    if (rc != EOK) {
 
        munmap(com_area, com_size);
        ipc_hangup(dev_phone);
        return rc;
    }
 
 
 
 
 
 
 
 
 
    return EOK;
}
 
void block_fini(dev_handle_t dev_handle)
{
    devcon_t *devcon = devcon_search(dev_handle);
    assert(devcon);
   
    devcon_remove(devcon);
 
    if (devcon->bb_buf)
        free(devcon->bb_buf);
    munmap(devcon->com_area, devcon->com_size);
    ipc_hangup(devcon->dev_phone);
 
    free(devcon);  
}
 
int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
{
    void *bb_buf;
 
    devcon_t *devcon = devcon_search(dev_handle);
    if (!devcon)
        return ENOENT;
    if (devcon->bb_buf)
        return EEXIST;
    bb_buf = malloc(size);
    if (!bb_buf)
        return ENOMEM;
   
    off_t bufpos = 0;
    size_t buflen = 0;
    if (!block_read(dev_handle, &bufpos, &buflen, &off,
        bb_buf, size, size)) {
            free(bb_buf);
        return EIO; /* XXX real error code */
    }
    devcon->bb_buf = bb_buf;
    devcon->bb_off = off;
    devcon->bb_size = size;
 
    return EOK;
}
 
void *block_bb_get(dev_handle_t dev_handle)
{
    devcon_t *devcon = devcon_search(dev_handle);
    assert(devcon);
    return devcon->bb_buf;
}
 
/** Read data from a block device.
 *
 * @param dev_handle    Device handle of the block device.
 * @param bufpos    Pointer to the first unread valid offset within the
 *          communication buffer.
 * @param buflen    Pointer to the number of unread bytes that are ready in
 *          the communication buffer.
 * @param pos       Device position to be read.
 * @param dst       Destination buffer.
 * @param size      Size of the destination buffer.
 * @param block_size    Block size to be used for the transfer.
 *
 * @return      True on success, false on failure.
 */
bool
block_read(int dev_handle, off_t *bufpos, size_t *buflen, off_t *pos, void *dst,
    size_t size, size_t block_size)
{
    off_t offset = 0;
    size_t left = size;
    devcon_t *devcon = devcon_search(dev_handle);
    assert(devcon);
   
    while (left > 0) {
        size_t rd;
       
        if (*bufpos + left < *buflen)
            rd = left;
        else
            rd = *buflen - *bufpos;
       
        if (rd > 0) {
            /*
             * Copy the contents of the communication buffer to the
             * destination buffer.
             */
            memcpy(dst + offset, devcon->com_area + *bufpos, rd);
            offset += rd;
            *bufpos += rd;
            *pos += rd;
            left -= rd;
        }
       
        if (*bufpos == *buflen) {
            /* Refill the communication buffer with a new block. */
            ipcarg_t retval;
            int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK,
                *pos / block_size, block_size, &retval);
            if ((rc != EOK) || (retval != EOK))
                return false;
           
            *bufpos = 0;
            *buflen = block_size;
        }
    }
   
    return true;
}
 
block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
{
    /* FIXME */
    block_t *b;
    off_t bufpos = 0;
    size_t buflen = 0;
    off_t pos = offset * bs;
 
    b = malloc(sizeof(block_t));
    if (!b)
        return NULL;
   
    b->data = malloc(bs);
    if (!b->data) {
        free(b);
        return NULL;
    }
    b->size = bs;
 
    if (!block_read(dev_handle, &bufpos, &buflen, &pos, b->data,
        bs, bs)) {
        free(b->data);
        free(b);
        return NULL;
    }
 
    return b;
}
 
void block_put(block_t *block)
{
    /* FIXME */
    free(block->data);
    free(block);
}
 
/** @}
 */
 

Rev 3531	Rev 3537
1	/*	1	/*
2	* Copyright (c) 2008 Jakub Jermar	2	* Copyright (c) 2008 Jakub Jermar
3	* Copyright (c) 2008 Martin Decky	3	* Copyright (c) 2008 Martin Decky
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 libblock	30	/** @addtogroup libblock
31	* @{	31	* @{
32	*/	32	*/
33	/**	33	/**
34	* @file	34	* @file
35	* @brief	35	* @brief
36	*/	36	*/
37		37
38	#include "libblock.h"	38	#include "libblock.h"
39	#include "../../srv/vfs/vfs.h"	39	#include "../../srv/vfs/vfs.h"
40	#include "../../srv/rd/rd.h"	40	#include "../../srv/rd/rd.h"
41	#include <ipc/devmap.h>	41	#include <ipc/devmap.h>
42	#include <ipc/services.h>	42	#include <ipc/services.h>
43	#include <errno.h>	43	#include <errno.h>
44	#include <sys/mman.h>	44	#include <sys/mman.h>
45	#include <async.h>	45	#include <async.h>
46	#include <ipc/ipc.h>	46	#include <ipc/ipc.h>
47	#include <as.h>	47	#include <as.h>
48	#include <assert.h>	48	#include <assert.h>
49	#include <futex.h>	49	#include <futex.h>
50	#include <libadt/list.h>	50	#include <libadt/list.h>
51		51
52	/** Lock protecting the device connection list */	52	/** Lock protecting the device connection list */
53	static futex_t dcl_lock = FUTEX_INITIALIZER;	53	static futex_t dcl_lock = FUTEX_INITIALIZER;
54	/** Device connection list head. */	54	/** Device connection list head. */
55	static LIST_INITIALIZE(dcl_head);	55	static LIST_INITIALIZE(dcl_head);
56		56
57	typedef struct {	57	typedef struct {
58	link_t link;	58	link_t link;
59	int dev_handle;	59	int dev_handle;
60	int dev_phone;	60	int dev_phone;
61	void *com_area;	61	void *com_area;
62	size_t com_size;	62	size_t com_size;
63	void *bb_buf;	63	void *bb_buf;
64	off_t bb_off;	64	off_t bb_off;
65	size_t bb_size;	65	size_t bb_size;
66	} devcon_t;	66	} devcon_t;
67		67
68	static devcon_t *devcon_search(dev_handle_t dev_handle)	68	static devcon_t *devcon_search(dev_handle_t dev_handle)
69	{	69	{
70	link_t *cur;	70	link_t *cur;
71		71
72	futex_down(&dcl_lock);	72	futex_down(&dcl_lock);
73	for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {	73	for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
74	devcon_t *devcon = list_get_instance(cur, devcon_t, link);	74	devcon_t *devcon = list_get_instance(cur, devcon_t, link);
75	if (devcon->dev_handle == dev_handle) {	75	if (devcon->dev_handle == dev_handle) {
76	futex_up(&dcl_lock);	76	futex_up(&dcl_lock);
77	return devcon;	77	return devcon;
78	}	78	}
79	}	79	}
80	futex_up(&dcl_lock);	80	futex_up(&dcl_lock);
81	return NULL;	81	return NULL;
82	}	82	}
83		83
84	static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,	84	static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
85	size_t com_size, void *bb_buf, off_t bb_off, size_t bb_size)	85	size_t com_size)
86	{	86	{
87	link_t *cur;	87	link_t *cur;
88	devcon_t *devcon;	88	devcon_t *devcon;
89		89
90	devcon = malloc(sizeof(devcon_t));	90	devcon = malloc(sizeof(devcon_t));
91	if (!devcon)	91	if (!devcon)
92	return ENOMEM;	92	return ENOMEM;
93		93
94	link_initialize(&devcon->link);	94	link_initialize(&devcon->link);
95	devcon->dev_handle = dev_handle;	95	devcon->dev_handle = dev_handle;
96	devcon->dev_phone = dev_phone;	96	devcon->dev_phone = dev_phone;
97	devcon->com_area = com_area;	97	devcon->com_area = com_area;
98	devcon->com_size = com_size;	98	devcon->com_size = com_size;
99	devcon->bb_buf = bb_buf;	99	devcon->bb_buf = NULL;
100	devcon->bb_off = bb_off;	100	devcon->bb_off = 0;
101	devcon->bb_size = bb_size;	101	devcon->bb_size = 0;
102		102
103	futex_down(&dcl_lock);	103	futex_down(&dcl_lock);
104	for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {	104	for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
105	devcon_t *d = list_get_instance(cur, devcon_t, link);	105	devcon_t *d = list_get_instance(cur, devcon_t, link);
106	if (d->dev_handle == dev_handle) {	106	if (d->dev_handle == dev_handle) {
107	futex_up(&dcl_lock);	107	futex_up(&dcl_lock);
108	free(devcon);	108	free(devcon);
109	return EEXIST;	109	return EEXIST;
110	}	110	}
111	}	111	}
112	list_append(&devcon->link, &dcl_head);	112	list_append(&devcon->link, &dcl_head);
113	futex_up(&dcl_lock);	113	futex_up(&dcl_lock);
114	return EOK;	114	return EOK;
115	}	115	}
116		116
117	static void devcon_remove(devcon_t *devcon)	117	static void devcon_remove(devcon_t *devcon)
118	{	118	{
119	futex_down(&dcl_lock);	119	futex_down(&dcl_lock);
120	list_remove(&devcon->link);	120	list_remove(&devcon->link);
121	futex_up(&dcl_lock);	121	futex_up(&dcl_lock);
122	}	122	}
123		123
124	int	-
125	block_init(dev_handle_t dev_handle, size_t com_size, off_t bb_off,	124	int block_init(dev_handle_t dev_handle, size_t com_size)
126	size_t bb_size)	-
127	{	125	{
128	int rc;	126	int rc;
129	int dev_phone;	127	int dev_phone;
130	void *com_area;	128	void *com_area;
131	void *bb_buf;	-
132		-
133	bb_buf = malloc(bb_size);	-
134	if (!bb_buf)	-
135	return ENOMEM;	-
136		129
137	com_area = mmap(NULL, com_size, PROTO_READ \| PROTO_WRITE,	130	com_area = mmap(NULL, com_size, PROTO_READ \| PROTO_WRITE,
138	MAP_ANONYMOUS \| MAP_PRIVATE, 0, 0);	131	MAP_ANONYMOUS \| MAP_PRIVATE, 0, 0);
139	if (!com_area) {	132	if (!com_area) {
140	free(bb_buf);	-
141	return ENOMEM;	133	return ENOMEM;
142	}	134	}
143	dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,	135	dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
144	DEVMAP_CONNECT_TO_DEVICE, dev_handle);	136	DEVMAP_CONNECT_TO_DEVICE, dev_handle);
145		137
146	if (dev_phone < 0) {	138	if (dev_phone < 0) {
147	free(bb_buf);	-
148	munmap(com_area, com_size);	139	munmap(com_area, com_size);
149	return dev_phone;	140	return dev_phone;
150	}	141	}
151		142
152	rc = ipc_share_out_start(dev_phone, com_area,	143	rc = ipc_share_out_start(dev_phone, com_area,
153	AS_AREA_READ \| AS_AREA_WRITE);	144	AS_AREA_READ \| AS_AREA_WRITE);
154	if (rc != EOK) {	145	if (rc != EOK) {
155	free(bb_buf);	-
156	munmap(com_area, com_size);	146	munmap(com_area, com_size);
157	ipc_hangup(dev_phone);	147	ipc_hangup(dev_phone);
158	return rc;	148	return rc;
159	}	149	}
160		150
161	rc = devcon_add(dev_handle, dev_phone, com_area, com_size, bb_buf,	151	rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
162	bb_off, bb_size);	-
163	if (rc != EOK) {	152	if (rc != EOK) {
164	free(bb_buf);	-
165	munmap(com_area, com_size);	153	munmap(com_area, com_size);
166	ipc_hangup(dev_phone);	154	ipc_hangup(dev_phone);
167	return rc;	155	return rc;
168	}	156	}
169		157
170	off_t bufpos = 0;	-
171	size_t buflen = 0;	-
172	if (!block_read(dev_handle, &bufpos, &buflen, &bb_off,	-
173	bb_buf, bb_size, bb_size)) {	-
174	block_fini(dev_handle);	-
175	return EIO; /* XXX real error code */	-
176	}	-
177		-
178	return EOK;	158	return EOK;
179	}	159	}
180		160
181	void block_fini(dev_handle_t dev_handle)	161	void block_fini(dev_handle_t dev_handle)
182	{	162	{
183	devcon_t *devcon = devcon_search(dev_handle);	163	devcon_t *devcon = devcon_search(dev_handle);
184	assert(devcon);	164	assert(devcon);
185		165
186	devcon_remove(devcon);	166	devcon_remove(devcon);
187		167
-		168	if (devcon->bb_buf)
188	free(devcon->bb_buf);	169	free(devcon->bb_buf);
189	munmap(devcon->com_area, devcon->com_size);	170	munmap(devcon->com_area, devcon->com_size);
190	ipc_hangup(devcon->dev_phone);	171	ipc_hangup(devcon->dev_phone);
191		172
192	free(devcon);	173	free(devcon);
193	}	174	}
-		175
-		176	int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
-		177	{
-		178	void *bb_buf;
-		179
-		180	devcon_t *devcon = devcon_search(dev_handle);
-		181	if (!devcon)
-		182	return ENOENT;
-		183	if (devcon->bb_buf)
-		184	return EEXIST;
-		185	bb_buf = malloc(size);
-		186	if (!bb_buf)
-		187	return ENOMEM;
-		188
-		189	off_t bufpos = 0;
-		190	size_t buflen = 0;
-		191	if (!block_read(dev_handle, &bufpos, &buflen, &off,
-		192	bb_buf, size, size)) {
-		193	free(bb_buf);
-		194	return EIO; /* XXX real error code */
-		195	}
-		196	devcon->bb_buf = bb_buf;
-		197	devcon->bb_off = off;
-		198	devcon->bb_size = size;
-		199
-		200	return EOK;
-		201	}
194		202
195	void *block_bb_get(dev_handle_t dev_handle)	203	void *block_bb_get(dev_handle_t dev_handle)
196	{	204	{
197	devcon_t *devcon = devcon_search(dev_handle);	205	devcon_t *devcon = devcon_search(dev_handle);
198	assert(devcon);	206	assert(devcon);
199	return devcon->bb_buf;	207	return devcon->bb_buf;
200	}	208	}
201		209
202	/** Read data from a block device.	210	/** Read data from a block device.
203	*	211	*
204	* @param dev_handle Device handle of the block device.	212	* @param dev_handle Device handle of the block device.
205	* @param bufpos Pointer to the first unread valid offset within the	213	* @param bufpos Pointer to the first unread valid offset within the
206	* communication buffer.	214	* communication buffer.
207	* @param buflen Pointer to the number of unread bytes that are ready in	215	* @param buflen Pointer to the number of unread bytes that are ready in
208	* the communication buffer.	216	* the communication buffer.
209	* @param pos Device position to be read.	217	* @param pos Device position to be read.
210	* @param dst Destination buffer.	218	* @param dst Destination buffer.
211	* @param size Size of the destination buffer.	219	* @param size Size of the destination buffer.
212	* @param block_size Block size to be used for the transfer.	220	* @param block_size Block size to be used for the transfer.
213	*	221	*
214	* @return True on success, false on failure.	222	* @return True on success, false on failure.
215	*/	223	*/
216	bool	224	bool
217	block_read(int dev_handle, off_t bufpos, size_t buflen, off_t pos, void dst,	225	block_read(int dev_handle, off_t bufpos, size_t buflen, off_t pos, void dst,
218	size_t size, size_t block_size)	226	size_t size, size_t block_size)
219	{	227	{
220	off_t offset = 0;	228	off_t offset = 0;
221	size_t left = size;	229	size_t left = size;
222	devcon_t *devcon = devcon_search(dev_handle);	230	devcon_t *devcon = devcon_search(dev_handle);
223	assert(devcon);	231	assert(devcon);
224		232
225	while (left > 0) {	233	while (left > 0) {
226	size_t rd;	234	size_t rd;
227		235
228	if (bufpos + left < buflen)	236	if (bufpos + left < buflen)
229	rd = left;	237	rd = left;
230	else	238	else
231	rd = buflen - bufpos;	239	rd = buflen - bufpos;
232		240
233	if (rd > 0) {	241	if (rd > 0) {
234	/*	242	/*
235	* Copy the contents of the communication buffer to the	243	* Copy the contents of the communication buffer to the
236	* destination buffer.	244	* destination buffer.
237	*/	245	*/
238	memcpy(dst + offset, devcon->com_area + *bufpos, rd);	246	memcpy(dst + offset, devcon->com_area + *bufpos, rd);
239	offset += rd;	247	offset += rd;
240	*bufpos += rd;	248	*bufpos += rd;
241	*pos += rd;	249	*pos += rd;
242	left -= rd;	250	left -= rd;
243	}	251	}
244		252
245	if (bufpos == buflen) {	253	if (bufpos == buflen) {
246	/* Refill the communication buffer with a new block. */	254	/* Refill the communication buffer with a new block. */
247	ipcarg_t retval;	255	ipcarg_t retval;
248	int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK,	256	int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK,
249	*pos / block_size, block_size, &retval);	257	*pos / block_size, block_size, &retval);
250	if ((rc != EOK) \|\| (retval != EOK))	258	if ((rc != EOK) \|\| (retval != EOK))
251	return false;	259	return false;
252		260
253	*bufpos = 0;	261	*bufpos = 0;
254	*buflen = block_size;	262	*buflen = block_size;
255	}	263	}
256	}	264	}
257		265
258	return true;	266	return true;
259	}	267	}
260		268
261	block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)	269	block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
262	{	270	{
263	/* FIXME */	271	/* FIXME */
264	block_t *b;	272	block_t *b;
265	off_t bufpos = 0;	273	off_t bufpos = 0;
266	size_t buflen = 0;	274	size_t buflen = 0;
267	off_t pos = offset * bs;	275	off_t pos = offset * bs;
268		276
269	b = malloc(sizeof(block_t));	277	b = malloc(sizeof(block_t));
270	if (!b)	278	if (!b)
271	return NULL;	279	return NULL;
272		280
273	b->data = malloc(bs);	281	b->data = malloc(bs);
274	if (!b->data) {	282	if (!b->data) {
275	free(b);	283	free(b);
276	return NULL;	284	return NULL;
277	}	285	}
278	b->size = bs;	286	b->size = bs;
279		287
280	if (!block_read(dev_handle, &bufpos, &buflen, &pos, b->data,	288	if (!block_read(dev_handle, &bufpos, &buflen, &pos, b->data,
281	bs, bs)) {	289	bs, bs)) {
282	free(b->data);	290	free(b->data);
283	free(b);	291	free(b);
284	return NULL;	292	return NULL;
285	}	293	}
286		294
287	return b;	295	return b;
288	}	296	}
289		297
290	void block_put(block_t *block)	298	void block_put(block_t *block)
291	{	299	{
292	/* FIXME */	300	/* FIXME */
293	free(block->data);	301	free(block->data);
294	free(block);	302	free(block);
295	}	303	}
296		304
297	/** @}	305	/** @}
298	*/	306	*/
299		307

Subversion Repositories HelenOS

(root)/trunk/uspace/lib/libblock/libblock.c – Rev 3531 → 3537