WebSVN – HelenOS – Diff – /branches/network/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 <ipc/devmap.h>
#include <ipc/bd.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 <fibril_sync.h>
#include <adt/list.h>
#include <adt/hash_table.h>
#include <mem.h>
 
/** Lock protecting the device connection list */
static FIBRIL_MUTEX_INITIALIZE(dcl_lock);
/** Device connection list head. */
static LIST_INITIALIZE(dcl_head);
 
#define CACHE_BUCKETS_LOG2      10
#define CACHE_BUCKETS           (1 << CACHE_BUCKETS_LOG2)
 
typedef struct {
    fibril_mutex_t lock;
    size_t block_size;      /**< Block size. */
    unsigned block_count;       /**< Total number of blocks. */
    hash_table_t block_hash;
    link_t free_head;
    enum cache_mode mode;
} cache_t;
 
typedef struct {
    link_t link;
    dev_handle_t dev_handle;
    int dev_phone;
    void *com_area;
    size_t com_size;
    void *bb_buf;
    off_t bb_off;
    size_t bb_size;
    cache_t *cache;
} devcon_t;
 
static int write_block(devcon_t *devcon, bn_t boff, size_t block_size,
    const void *src);
 
static devcon_t *devcon_search(dev_handle_t dev_handle)
{
    link_t *cur;
 
    fibril_mutex_lock(&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) {
            fibril_mutex_unlock(&dcl_lock);
            return devcon;
        }
    }
    fibril_mutex_unlock(&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;
    devcon->cache = NULL;
 
    fibril_mutex_lock(&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) {
            fibril_mutex_unlock(&dcl_lock);
            free(devcon);
            return EEXIST;
        }
    }
    list_append(&devcon->link, &dcl_head);
    fibril_mutex_unlock(&dcl_lock);
    return EOK;
}
 
static void devcon_remove(devcon_t *devcon)
{
    fibril_mutex_lock(&dcl_lock);
    list_remove(&devcon->link);
    fibril_mutex_unlock(&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 = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING);
    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);
 
    if (devcon->cache) {
        hash_table_destroy(&devcon->cache->block_hash);
        free(devcon->cache);
    }
 
    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;
    int rc;
 
    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;
    rc = block_read(dev_handle, &bufpos, &buflen, &off,
        bb_buf, size, size);
    if (rc != EOK) {
            free(bb_buf);
        return rc;
    }
    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;
}
 
static hash_index_t cache_hash(unsigned long *key)
{
    return *key & (CACHE_BUCKETS - 1);
}
 
static int cache_compare(unsigned long *key, hash_count_t keys, link_t *item)
{
    block_t *b = hash_table_get_instance(item, block_t, hash_link);
    return b->boff == *key;
}
 
static void cache_remove_callback(link_t *item)
{
}
 
static hash_table_operations_t cache_ops = {
    .hash = cache_hash,
    .compare = cache_compare,
    .remove_callback = cache_remove_callback
};
 
int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks,
    enum cache_mode mode)
{
    devcon_t *devcon = devcon_search(dev_handle);
    cache_t *cache;
    if (!devcon)
        return ENOENT;
    if (devcon->cache)
        return EEXIST;
    cache = malloc(sizeof(cache_t));
    if (!cache)
        return ENOMEM;
   
    fibril_mutex_initialize(&cache->lock);
    list_initialize(&cache->free_head);
    cache->block_size = size;
    cache->block_count = blocks;
    cache->mode = mode;
 
    if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
        &cache_ops)) {
        free(cache);
        return ENOMEM;
    }
 
    devcon->cache = cache;
    return EOK;
}
 
static bool cache_can_grow(cache_t *cache)
{
    return true;
}
 
static void block_initialize(block_t *b)
{
    fibril_mutex_initialize(&b->lock);
    b->refcnt = 1;
    b->dirty = false;
    fibril_rwlock_initialize(&b->contents_lock);
    link_initialize(&b->free_link);
    link_initialize(&b->hash_link);
}
 
/** Instantiate a block in memory and get a reference to it.
 *
 * @param dev_handle        Device handle of the block device.
 * @param boff          Block offset.
 * @param flags         If BLOCK_FLAGS_NOREAD is specified, block_get()
 *              will not read the contents of the block from the
 *              device.
 *
 * @return          Block structure.
 */
block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags)
{
    devcon_t *devcon;
    cache_t *cache;
    block_t *b;
    link_t *l;
    unsigned long key = boff;
   
    devcon = devcon_search(dev_handle);
 
    assert(devcon);
    assert(devcon->cache);
   
    cache = devcon->cache;
    fibril_mutex_lock(&cache->lock);
    l = hash_table_find(&cache->block_hash, &key);
    if (l) {
        /*
         * We found the block in the cache.
         */
        b = hash_table_get_instance(l, block_t, hash_link);
        fibril_mutex_lock(&b->lock);
        if (b->refcnt++ == 0)
            list_remove(&b->free_link);
        fibril_mutex_unlock(&b->lock);
        fibril_mutex_unlock(&cache->lock);
    } else {
        /*
         * The block was not found in the cache.
         */
        int rc;
        off_t bufpos = 0;
        size_t buflen = 0;
        off_t pos = boff * cache->block_size;
        bool sync = false;
 
        if (cache_can_grow(cache)) {
            /*
             * We can grow the cache by allocating new blocks.
             * Should the allocation fail, we fail over and try to
             * recycle a block from the cache.
             */
            b = malloc(sizeof(block_t));
            if (!b)
                goto recycle;
            b->data = malloc(cache->block_size);
            if (!b->data) {
                free(b);
                goto recycle;
            }
        } else {
            /*
             * Try to recycle a block from the free list.
             */
            unsigned long temp_key;
recycle:
            assert(!list_empty(&cache->free_head));
            l = cache->free_head.next;
            list_remove(l);
            b = hash_table_get_instance(l, block_t, hash_link);
            sync = b->dirty;
            temp_key = b->boff;
            hash_table_remove(&cache->block_hash, &temp_key, 1);
        }
 
        block_initialize(b);
        b->dev_handle = dev_handle;
        b->size = cache->block_size;
        b->boff = boff;
        hash_table_insert(&cache->block_hash, &key, &b->hash_link);
 
        /*
         * Lock the block before releasing the cache lock. Thus we don't
         * kill concurent operations on the cache while doing I/O on the
         * block.
         */
        fibril_mutex_lock(&b->lock);
        fibril_mutex_unlock(&cache->lock);
 
        if (sync) {
            /*
             * The block is dirty and needs to be written back to
             * the device before we can read in the new contents.
             */
            abort();    /* TODO: block_write() */
        }
        if (!(flags & BLOCK_FLAGS_NOREAD)) {
            /*
             * The block contains old or no data. We need to read
             * the new contents from the device.
             */
            rc = block_read(dev_handle, &bufpos, &buflen, &pos,
                b->data, cache->block_size, cache->block_size);
            assert(rc == EOK);
        }
 
        fibril_mutex_unlock(&b->lock);
    }
    return b;
}
 
/** Release a reference to a block.
 *
 * If the last reference is dropped, the block is put on the free list.
 *
 * @param block     Block of which a reference is to be released.
 */
void block_put(block_t *block)
{
    devcon_t *devcon = devcon_search(block->dev_handle);
    cache_t *cache;
    int rc;
 
    assert(devcon);
    assert(devcon->cache);
 
    cache = devcon->cache;
    fibril_mutex_lock(&cache->lock);
    fibril_mutex_lock(&block->lock);
    if (!--block->refcnt) {
        /*
         * Last reference to the block was dropped, put the block on the
         * free list.
         */
        list_append(&block->free_link, &cache->free_head);
        if (cache->mode != CACHE_MODE_WB && block->dirty) {
            rc = write_block(devcon, block->boff, block->size,
                block->data);
            assert(rc == EOK);
 
            block->dirty = false;
        }
    }
    fibril_mutex_unlock(&block->lock);
    fibril_mutex_unlock(&cache->lock);
}
 
/** 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      EOK on success or a negative return code on failure.
 */
int
block_read(dev_handle_t 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 == (off_t) *buflen) {
            /* Refill the communication buffer with a new block. */
            ipcarg_t retval;
            int rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK,
                *pos / block_size, block_size, &retval);
            if ((rc != EOK) || (retval != EOK))
                return (rc != EOK ? rc : (int) retval);
           
            *bufpos = 0;
            *buflen = block_size;
        }
    }
   
    return EOK;
}
 
/** Write block to block device.
 *
 * @param devcon    Device connection.
 * @param boff      Block index.
 * @param block_size    Block size.
 * @param src       Buffer containing the data to write.
 *
 * @return      EOK on success or negative error code on failure.
 */
static int write_block(devcon_t *devcon, bn_t boff, size_t block_size,
    const void *src)
{
    ipcarg_t retval;
    int rc;
 
    assert(devcon);
    memcpy(devcon->com_area, src, block_size);
   
    rc = async_req_2_1(devcon->dev_phone, BD_WRITE_BLOCK,
        boff, block_size, &retval);
    if ((rc != EOK) || (retval != EOK))
        return (rc != EOK ? rc : (int) retval);
 
    return EOK;
}
 
/** @}
 */
 

Rev 4153	Rev 4581
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"	-
41	#include <ipc/devmap.h>	40	#include <ipc/devmap.h>
-		41	#include <ipc/bd.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 <fibril_sync.h>
50	#include <libadt/list.h>	50	#include <adt/list.h>
51	#include <libadt/hash_table.h>	51	#include <adt/hash_table.h>
-		52	#include <mem.h>
52		53
53	/** Lock protecting the device connection list */	54	/** Lock protecting the device connection list */
54	static futex_t dcl_lock = FUTEX_INITIALIZER;	55	static FIBRIL_MUTEX_INITIALIZE(dcl_lock);
55	/** Device connection list head. */	56	/** Device connection list head. */
56	static LIST_INITIALIZE(dcl_head);	57	static LIST_INITIALIZE(dcl_head);
57		58
58	#define CACHE_BUCKETS_LOG2 10	59	#define CACHE_BUCKETS_LOG2 10
59	#define CACHE_BUCKETS (1 << CACHE_BUCKETS_LOG2)	60	#define CACHE_BUCKETS (1 << CACHE_BUCKETS_LOG2)
60		61
61	typedef struct {	62	typedef struct {
62	futex_t lock;	63	fibril_mutex_t lock;
63	size_t block_size; /*< Block size. /	64	size_t block_size; /*< Block size. /
64	unsigned block_count; /*< Total number of blocks. /	65	unsigned block_count; /*< Total number of blocks. /
65	hash_table_t block_hash;	66	hash_table_t block_hash;
66	link_t free_head;	67	link_t free_head;
-		68	enum cache_mode mode;
67	} cache_t;	69	} cache_t;
68		70
69	typedef struct {	71	typedef struct {
70	link_t link;	72	link_t link;
71	int dev_handle;	73	dev_handle_t dev_handle;
72	int dev_phone;	74	int dev_phone;
73	void *com_area;	75	void *com_area;
74	size_t com_size;	76	size_t com_size;
75	void *bb_buf;	77	void *bb_buf;
76	off_t bb_off;	78	off_t bb_off;
77	size_t bb_size;	79	size_t bb_size;
78	cache_t *cache;	80	cache_t *cache;
79	} devcon_t;	81	} devcon_t;
80		82
-		83	static int write_block(devcon_t *devcon, bn_t boff, size_t block_size,
-		84	const void *src);
-		85
81	static devcon_t *devcon_search(dev_handle_t dev_handle)	86	static devcon_t *devcon_search(dev_handle_t dev_handle)
82	{	87	{
83	link_t *cur;	88	link_t *cur;
84		89
85	futex_down(&dcl_lock);	90	fibril_mutex_lock(&dcl_lock);
86	for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {	91	for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
87	devcon_t *devcon = list_get_instance(cur, devcon_t, link);	92	devcon_t *devcon = list_get_instance(cur, devcon_t, link);
88	if (devcon->dev_handle == dev_handle) {	93	if (devcon->dev_handle == dev_handle) {
89	futex_up(&dcl_lock);	94	fibril_mutex_unlock(&dcl_lock);
90	return devcon;	95	return devcon;
91	}	96	}
92	}	97	}
93	futex_up(&dcl_lock);	98	fibril_mutex_unlock(&dcl_lock);
94	return NULL;	99	return NULL;
95	}	100	}
96		101
97	static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,	102	static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
98	size_t com_size)	103	size_t com_size)
99	{	104	{
100	link_t *cur;	105	link_t *cur;
101	devcon_t *devcon;	106	devcon_t *devcon;
102		107
103	devcon = malloc(sizeof(devcon_t));	108	devcon = malloc(sizeof(devcon_t));
104	if (!devcon)	109	if (!devcon)
105	return ENOMEM;	110	return ENOMEM;
106		111
107	link_initialize(&devcon->link);	112	link_initialize(&devcon->link);
108	devcon->dev_handle = dev_handle;	113	devcon->dev_handle = dev_handle;
109	devcon->dev_phone = dev_phone;	114	devcon->dev_phone = dev_phone;
110	devcon->com_area = com_area;	115	devcon->com_area = com_area;
111	devcon->com_size = com_size;	116	devcon->com_size = com_size;
112	devcon->bb_buf = NULL;	117	devcon->bb_buf = NULL;
113	devcon->bb_off = 0;	118	devcon->bb_off = 0;
114	devcon->bb_size = 0;	119	devcon->bb_size = 0;
115	devcon->cache = NULL;	120	devcon->cache = NULL;
116		121
117	futex_down(&dcl_lock);	122	fibril_mutex_lock(&dcl_lock);
118	for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {	123	for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
119	devcon_t *d = list_get_instance(cur, devcon_t, link);	124	devcon_t *d = list_get_instance(cur, devcon_t, link);
120	if (d->dev_handle == dev_handle) {	125	if (d->dev_handle == dev_handle) {
121	futex_up(&dcl_lock);	126	fibril_mutex_unlock(&dcl_lock);
122	free(devcon);	127	free(devcon);
123	return EEXIST;	128	return EEXIST;
124	}	129	}
125	}	130	}
126	list_append(&devcon->link, &dcl_head);	131	list_append(&devcon->link, &dcl_head);
127	futex_up(&dcl_lock);	132	fibril_mutex_unlock(&dcl_lock);
128	return EOK;	133	return EOK;
129	}	134	}
130		135
131	static void devcon_remove(devcon_t *devcon)	136	static void devcon_remove(devcon_t *devcon)
132	{	137	{
133	futex_down(&dcl_lock);	138	fibril_mutex_lock(&dcl_lock);
134	list_remove(&devcon->link);	139	list_remove(&devcon->link);
135	futex_up(&dcl_lock);	140	fibril_mutex_unlock(&dcl_lock);
136	}	141	}
137		142
138	int block_init(dev_handle_t dev_handle, size_t com_size)	143	int block_init(dev_handle_t dev_handle, size_t com_size)
139	{	144	{
140	int rc;	145	int rc;
141	int dev_phone;	146	int dev_phone;
142	void *com_area;	147	void *com_area;
143		148
144	com_area = mmap(NULL, com_size, PROTO_READ \| PROTO_WRITE,	149	com_area = mmap(NULL, com_size, PROTO_READ \| PROTO_WRITE,
145	MAP_ANONYMOUS \| MAP_PRIVATE, 0, 0);	150	MAP_ANONYMOUS \| MAP_PRIVATE, 0, 0);
146	if (!com_area) {	151	if (!com_area) {
147	return ENOMEM;	152	return ENOMEM;
148	}	153	}
149	dev_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,	-
150	DEVMAP_CONNECT_TO_DEVICE, dev_handle);	-
151		154
-		155	dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING);
152	if (dev_phone < 0) {	156	if (dev_phone < 0) {
153	munmap(com_area, com_size);	157	munmap(com_area, com_size);
154	return dev_phone;	158	return dev_phone;
155	}	159	}
156		160
157	rc = ipc_share_out_start(dev_phone, com_area,	161	rc = ipc_share_out_start(dev_phone, com_area,
158	AS_AREA_READ \| AS_AREA_WRITE);	162	AS_AREA_READ \| AS_AREA_WRITE);
159	if (rc != EOK) {	163	if (rc != EOK) {
160	munmap(com_area, com_size);	164	munmap(com_area, com_size);
161	ipc_hangup(dev_phone);	165	ipc_hangup(dev_phone);
162	return rc;	166	return rc;
163	}	167	}
164		168
165	rc = devcon_add(dev_handle, dev_phone, com_area, com_size);	169	rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
166	if (rc != EOK) {	170	if (rc != EOK) {
167	munmap(com_area, com_size);	171	munmap(com_area, com_size);
168	ipc_hangup(dev_phone);	172	ipc_hangup(dev_phone);
169	return rc;	173	return rc;
170	}	174	}
171		175
172	return EOK;	176	return EOK;
173	}	177	}
174		178
175	void block_fini(dev_handle_t dev_handle)	179	void block_fini(dev_handle_t dev_handle)
176	{	180	{
177	devcon_t *devcon = devcon_search(dev_handle);	181	devcon_t *devcon = devcon_search(dev_handle);
178	assert(devcon);	182	assert(devcon);
179		183
180	devcon_remove(devcon);	184	devcon_remove(devcon);
181		185
182	if (devcon->bb_buf)	186	if (devcon->bb_buf)
183	free(devcon->bb_buf);	187	free(devcon->bb_buf);
184		188
185	if (devcon->cache) {	189	if (devcon->cache) {
186	hash_table_destroy(&devcon->cache->block_hash);	190	hash_table_destroy(&devcon->cache->block_hash);
187	free(devcon->cache);	191	free(devcon->cache);
188	}	192	}
189		193
190	munmap(devcon->com_area, devcon->com_size);	194	munmap(devcon->com_area, devcon->com_size);
191	ipc_hangup(devcon->dev_phone);	195	ipc_hangup(devcon->dev_phone);
192		196
193	free(devcon);	197	free(devcon);
194	}	198	}
195		199
196	int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)	200	int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
197	{	201	{
198	void *bb_buf;	202	void *bb_buf;
199	int rc;	203	int rc;
200		204
201	devcon_t *devcon = devcon_search(dev_handle);	205	devcon_t *devcon = devcon_search(dev_handle);
202	if (!devcon)	206	if (!devcon)
203	return ENOENT;	207	return ENOENT;
204	if (devcon->bb_buf)	208	if (devcon->bb_buf)
205	return EEXIST;	209	return EEXIST;
206	bb_buf = malloc(size);	210	bb_buf = malloc(size);
207	if (!bb_buf)	211	if (!bb_buf)
208	return ENOMEM;	212	return ENOMEM;
209		213
210	off_t bufpos = 0;	214	off_t bufpos = 0;
211	size_t buflen = 0;	215	size_t buflen = 0;
212	rc = block_read(dev_handle, &bufpos, &buflen, &off,	216	rc = block_read(dev_handle, &bufpos, &buflen, &off,
213	bb_buf, size, size);	217	bb_buf, size, size);
214	if (rc != EOK) {	218	if (rc != EOK) {
215	free(bb_buf);	219	free(bb_buf);
216	return rc;	220	return rc;
217	}	221	}
218	devcon->bb_buf = bb_buf;	222	devcon->bb_buf = bb_buf;
219	devcon->bb_off = off;	223	devcon->bb_off = off;
220	devcon->bb_size = size;	224	devcon->bb_size = size;
221		225
222	return EOK;	226	return EOK;
223	}	227	}
224		228
225	void *block_bb_get(dev_handle_t dev_handle)	229	void *block_bb_get(dev_handle_t dev_handle)
226	{	230	{
227	devcon_t *devcon = devcon_search(dev_handle);	231	devcon_t *devcon = devcon_search(dev_handle);
228	assert(devcon);	232	assert(devcon);
229	return devcon->bb_buf;	233	return devcon->bb_buf;
230	}	234	}
231		235
232	static hash_index_t cache_hash(unsigned long *key)	236	static hash_index_t cache_hash(unsigned long *key)
233	{	237	{
234	return *key & (CACHE_BUCKETS - 1);	238	return *key & (CACHE_BUCKETS - 1);
235	}	239	}
236		240
237	static int cache_compare(unsigned long key, hash_count_t keys, link_t item)	241	static int cache_compare(unsigned long key, hash_count_t keys, link_t item)
238	{	242	{
239	block_t *b = hash_table_get_instance(item, block_t, hash_link);	243	block_t *b = hash_table_get_instance(item, block_t, hash_link);
240	return b->boff == *key;	244	return b->boff == *key;
241	}	245	}
242		246
243	static void cache_remove_callback(link_t *item)	247	static void cache_remove_callback(link_t *item)
244	{	248	{
245	}	249	}
246		250
247	static hash_table_operations_t cache_ops = {	251	static hash_table_operations_t cache_ops = {
248	.hash = cache_hash,	252	.hash = cache_hash,
249	.compare = cache_compare,	253	.compare = cache_compare,
250	.remove_callback = cache_remove_callback	254	.remove_callback = cache_remove_callback
251	};	255	};
252		256
253	int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks)	257	int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks,
-		258	enum cache_mode mode)
254	{	259	{
255	devcon_t *devcon = devcon_search(dev_handle);	260	devcon_t *devcon = devcon_search(dev_handle);
256	cache_t *cache;	261	cache_t *cache;
257	if (!devcon)	262	if (!devcon)
258	return ENOENT;	263	return ENOENT;
259	if (devcon->cache)	264	if (devcon->cache)
260	return EEXIST;	265	return EEXIST;
261	cache = malloc(sizeof(cache_t));	266	cache = malloc(sizeof(cache_t));
262	if (!cache)	267	if (!cache)
263	return ENOMEM;	268	return ENOMEM;
264		269
265	futex_initialize(&cache->lock, 1);	270	fibril_mutex_initialize(&cache->lock);
266	list_initialize(&cache->free_head);	271	list_initialize(&cache->free_head);
267	cache->block_size = size;	272	cache->block_size = size;
268	cache->block_count = blocks;	273	cache->block_count = blocks;
-		274	cache->mode = mode;
269		275
270	if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,	276	if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
271	&cache_ops)) {	277	&cache_ops)) {
272	free(cache);	278	free(cache);
273	return ENOMEM;	279	return ENOMEM;
274	}	280	}
275		281
276	devcon->cache = cache;	282	devcon->cache = cache;
277	return EOK;	283	return EOK;
278	}	284	}
279		285
280	static bool cache_can_grow(cache_t *cache)	286	static bool cache_can_grow(cache_t *cache)
281	{	287	{
282	return true;	288	return true;
283	}	289	}
284		290
285	static void block_initialize(block_t *b)	291	static void block_initialize(block_t *b)
286	{	292	{
287	futex_initialize(&b->lock, 1);	293	fibril_mutex_initialize(&b->lock);
288	b->refcnt = 1;	294	b->refcnt = 1;
289	b->dirty = false;	295	b->dirty = false;
290	rwlock_initialize(&b->contents_lock);	296	fibril_rwlock_initialize(&b->contents_lock);
291	link_initialize(&b->free_link);	297	link_initialize(&b->free_link);
292	link_initialize(&b->hash_link);	298	link_initialize(&b->hash_link);
293	}	299	}
294		300
295	/** Instantiate a block in memory and get a reference to it.	301	/** Instantiate a block in memory and get a reference to it.
296	*	302	*
297	* @param dev_handle Device handle of the block device.	303	* @param dev_handle Device handle of the block device.
298	* @param boff Block offset.	304	* @param boff Block offset.
299	* @param flags If BLOCK_FLAGS_NOREAD is specified, block_get()	305	* @param flags If BLOCK_FLAGS_NOREAD is specified, block_get()
300	* will not read the contents of the block from the	306	* will not read the contents of the block from the
301	* device.	307	* device.
302	*	308	*
303	* @return Block structure.	309	* @return Block structure.
304	*/	310	*/
305	block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags)	311	block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags)
306	{	312	{
307	devcon_t *devcon;	313	devcon_t *devcon;
308	cache_t *cache;	314	cache_t *cache;
309	block_t *b;	315	block_t *b;
310	link_t *l;	316	link_t *l;
311	unsigned long key = boff;	317	unsigned long key = boff;
312		318
313	devcon = devcon_search(dev_handle);	319	devcon = devcon_search(dev_handle);
314		320
315	assert(devcon);	321	assert(devcon);
316	assert(devcon->cache);	322	assert(devcon->cache);
317		323
318	cache = devcon->cache;	324	cache = devcon->cache;
319	futex_down(&cache->lock);	325	fibril_mutex_lock(&cache->lock);
320	l = hash_table_find(&cache->block_hash, &key);	326	l = hash_table_find(&cache->block_hash, &key);
321	if (l) {	327	if (l) {
322	/*	328	/*
323	* We found the block in the cache.	329	* We found the block in the cache.
324	*/	330	*/
325	b = hash_table_get_instance(l, block_t, hash_link);	331	b = hash_table_get_instance(l, block_t, hash_link);
326	futex_down(&b->lock);	332	fibril_mutex_lock(&b->lock);
327	if (b->refcnt++ == 0)	333	if (b->refcnt++ == 0)
328	list_remove(&b->free_link);	334	list_remove(&b->free_link);
329	futex_up(&b->lock);	335	fibril_mutex_unlock(&b->lock);
330	futex_up(&cache->lock);	336	fibril_mutex_unlock(&cache->lock);
331	} else {	337	} else {
332	/*	338	/*
333	* The block was not found in the cache.	339	* The block was not found in the cache.
334	*/	340	*/
335	int rc;	341	int rc;
336	off_t bufpos = 0;	342	off_t bufpos = 0;
337	size_t buflen = 0;	343	size_t buflen = 0;
338	off_t pos = boff * cache->block_size;	344	off_t pos = boff * cache->block_size;
339	bool sync = false;	345	bool sync = false;
340		346
341	if (cache_can_grow(cache)) {	347	if (cache_can_grow(cache)) {
342	/*	348	/*
343	* We can grow the cache by allocating new blocks.	349	* We can grow the cache by allocating new blocks.
344	* Should the allocation fail, we fail over and try to	350	* Should the allocation fail, we fail over and try to
345	* recycle a block from the cache.	351	* recycle a block from the cache.
346	*/	352	*/
347	b = malloc(sizeof(block_t));	353	b = malloc(sizeof(block_t));
348	if (!b)	354	if (!b)
349	goto recycle;	355	goto recycle;
350	b->data = malloc(cache->block_size);	356	b->data = malloc(cache->block_size);
351	if (!b->data) {	357	if (!b->data) {
352	free(b);	358	free(b);
353	goto recycle;	359	goto recycle;
354	}	360	}
355	} else {	361	} else {
356	/*	362	/*
357	* Try to recycle a block from the free list.	363	* Try to recycle a block from the free list.
358	*/	364	*/
359	unsigned long temp_key;	365	unsigned long temp_key;
360	recycle:	366	recycle:
361	assert(!list_empty(&cache->free_head));	367	assert(!list_empty(&cache->free_head));
362	l = cache->free_head.next;	368	l = cache->free_head.next;
363	list_remove(l);	369	list_remove(l);
364	b = hash_table_get_instance(l, block_t, hash_link);	370	b = hash_table_get_instance(l, block_t, hash_link);
365	sync = b->dirty;	371	sync = b->dirty;
366	temp_key = b->boff;	372	temp_key = b->boff;
367	hash_table_remove(&cache->block_hash, &temp_key, 1);	373	hash_table_remove(&cache->block_hash, &temp_key, 1);
368	}	374	}
369		375
370	block_initialize(b);	376	block_initialize(b);
371	b->dev_handle = dev_handle;	377	b->dev_handle = dev_handle;
372	b->size = cache->block_size;	378	b->size = cache->block_size;
373	b->boff = boff;	379	b->boff = boff;
374	hash_table_insert(&cache->block_hash, &key, &b->hash_link);	380	hash_table_insert(&cache->block_hash, &key, &b->hash_link);
375		381
376	/*	382	/*
377	* Lock the block before releasing the cache lock. Thus we don't	383	* Lock the block before releasing the cache lock. Thus we don't
378	* kill concurent operations on the cache while doing I/O on the	384	* kill concurent operations on the cache while doing I/O on the
379	* block.	385	* block.
380	*/	386	*/
381	futex_down(&b->lock);	387	fibril_mutex_lock(&b->lock);
382	futex_up(&cache->lock);	388	fibril_mutex_unlock(&cache->lock);
383		389
384	if (sync) {	390	if (sync) {
385	/*	391	/*
386	* The block is dirty and needs to be written back to	392	* The block is dirty and needs to be written back to
387	* the device before we can read in the new contents.	393	* the device before we can read in the new contents.
388	*/	394	*/
389	abort(); /* TODO: block_write() */	395	abort(); /* TODO: block_write() */
390	}	396	}
391	if (!(flags & BLOCK_FLAGS_NOREAD)) {	397	if (!(flags & BLOCK_FLAGS_NOREAD)) {
392	/*	398	/*
393	* The block contains old or no data. We need to read	399	* The block contains old or no data. We need to read
394	* the new contents from the device.	400	* the new contents from the device.
395	*/	401	*/
396	rc = block_read(dev_handle, &bufpos, &buflen, &pos,	402	rc = block_read(dev_handle, &bufpos, &buflen, &pos,
397	b->data, cache->block_size, cache->block_size);	403	b->data, cache->block_size, cache->block_size);
398	assert(rc == EOK);	404	assert(rc == EOK);
399	}	405	}
400		406
401	futex_up(&b->lock);	407	fibril_mutex_unlock(&b->lock);
402	}	408	}
403	return b;	409	return b;
404	}	410	}
405		411
406	/** Release a reference to a block.	412	/** Release a reference to a block.
407	*	413	*
408	* If the last reference is dropped, the block is put on the free list.	414	* If the last reference is dropped, the block is put on the free list.
409	*	415	*
410	* @param block Block of which a reference is to be released.	416	* @param block Block of which a reference is to be released.
411	*/	417	*/
412	void block_put(block_t *block)	418	void block_put(block_t *block)
413	{	419	{
414	devcon_t *devcon = devcon_search(block->dev_handle);	420	devcon_t *devcon = devcon_search(block->dev_handle);
415	cache_t *cache;	421	cache_t *cache;
-		422	int rc;
416		423
417	assert(devcon);	424	assert(devcon);
418	assert(devcon->cache);	425	assert(devcon->cache);
419		426
420	cache = devcon->cache;	427	cache = devcon->cache;
421	futex_down(&cache->lock);	428	fibril_mutex_lock(&cache->lock);
422	futex_down(&block->lock);	429	fibril_mutex_lock(&block->lock);
423	if (!--block->refcnt) {	430	if (!--block->refcnt) {
424	/*	431	/*
425	* Last reference to the block was dropped, put the block on the	432	* Last reference to the block was dropped, put the block on the
426	* free list.	433	* free list.
427	*/	434	*/
428	list_append(&block->free_link, &cache->free_head);	435	list_append(&block->free_link, &cache->free_head);
-		436	if (cache->mode != CACHE_MODE_WB && block->dirty) {
-		437	rc = write_block(devcon, block->boff, block->size,
-		438	block->data);
-		439	assert(rc == EOK);
-		440
-		441	block->dirty = false;
-		442	}
429	}	443	}
430	futex_up(&block->lock);	444	fibril_mutex_unlock(&block->lock);
431	futex_up(&cache->lock);	445	fibril_mutex_unlock(&cache->lock);
432	}	446	}
433		447
434	/** Read data from a block device.	448	/** Read data from a block device.
435	*	449	*
436	* @param dev_handle Device handle of the block device.	450	* @param dev_handle Device handle of the block device.
437	* @param bufpos Pointer to the first unread valid offset within the	451	* @param bufpos Pointer to the first unread valid offset within the
438	* communication buffer.	452	* communication buffer.
439	* @param buflen Pointer to the number of unread bytes that are ready in	453	* @param buflen Pointer to the number of unread bytes that are ready in
440	* the communication buffer.	454	* the communication buffer.
441	* @param pos Device position to be read.	455	* @param pos Device position to be read.
442	* @param dst Destination buffer.	456	* @param dst Destination buffer.
443	* @param size Size of the destination buffer.	457	* @param size Size of the destination buffer.
444	* @param block_size Block size to be used for the transfer.	458	* @param block_size Block size to be used for the transfer.
445	*	459	*
446	* @return EOK on success or a negative return code on failure.	460	* @return EOK on success or a negative return code on failure.
447	*/	461	*/
448	int	462	int
449	block_read(int dev_handle, off_t bufpos, size_t buflen, off_t pos, void dst,	463	block_read(dev_handle_t dev_handle, off_t bufpos, size_t buflen, off_t *pos,
450	size_t size, size_t block_size)	464	void *dst, size_t size, size_t block_size)
451	{	465	{
452	off_t offset = 0;	466	off_t offset = 0;
453	size_t left = size;	467	size_t left = size;
454	devcon_t *devcon = devcon_search(dev_handle);	468	devcon_t *devcon = devcon_search(dev_handle);
455	assert(devcon);	469	assert(devcon);
456		470
457	while (left > 0) {	471	while (left > 0) {
458	size_t rd;	472	size_t rd;
459		473
460	if (bufpos + left < buflen)	474	if (bufpos + left < buflen)
461	rd = left;	475	rd = left;
462	else	476	else
463	rd = buflen - bufpos;	477	rd = buflen - bufpos;
464		478
465	if (rd > 0) {	479	if (rd > 0) {
466	/*	480	/*
467	* Copy the contents of the communication buffer to the	481	* Copy the contents of the communication buffer to the
468	* destination buffer.	482	* destination buffer.
469	*/	483	*/
470	memcpy(dst + offset, devcon->com_area + *bufpos, rd);	484	memcpy(dst + offset, devcon->com_area + *bufpos, rd);
471	offset += rd;	485	offset += rd;
472	*bufpos += rd;	486	*bufpos += rd;
473	*pos += rd;	487	*pos += rd;
474	left -= rd;	488	left -= rd;
475	}	489	}
476		490
477	if (bufpos == buflen) {	491	if (bufpos == (off_t) buflen) {
478	/* Refill the communication buffer with a new block. */	492	/* Refill the communication buffer with a new block. */
479	ipcarg_t retval;	493	ipcarg_t retval;
480	int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK,	494	int rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK,
481	*pos / block_size, block_size, &retval);	495	*pos / block_size, block_size, &retval);
482	if ((rc != EOK) \|\| (retval != EOK))	496	if ((rc != EOK) \|\| (retval != EOK))
483	return (rc != EOK ? rc : retval);	497	return (rc != EOK ? rc : (int) retval);

Subversion Repositories HelenOS

(root)/branches/network/uspace/lib/libblock/libblock.c @ 4718 – Rev 4153 → 4581