46,13 → 46,13 |
#include <ipc/ipc.h> |
#include <as.h> |
#include <assert.h> |
#include <futex.h> |
#include <fibril_sync.h> |
#include <adt/list.h> |
#include <adt/hash_table.h> |
#include <mem.h> |
|
/** Lock protecting the device connection list */ |
static futex_t dcl_lock = FUTEX_INITIALIZER; |
static FIBRIL_MUTEX_INITIALIZE(dcl_lock); |
/** Device connection list head. */ |
static LIST_INITIALIZE(dcl_head); |
|
60,11 → 60,13 |
#define CACHE_BUCKETS (1 << CACHE_BUCKETS_LOG2) |
|
typedef struct { |
futex_t lock; |
fibril_mutex_t lock; |
size_t block_size; /**< Block size. */ |
unsigned block_count; /**< Total number of blocks. */ |
unsigned blocks_cached; /**< Number of cached blocks. */ |
hash_table_t block_hash; |
link_t free_head; |
enum cache_mode mode; |
} cache_t; |
|
typedef struct { |
71,6 → 73,7 |
link_t link; |
dev_handle_t dev_handle; |
int dev_phone; |
fibril_mutex_t com_area_lock; |
void *com_area; |
size_t com_size; |
void *bb_buf; |
79,19 → 82,22 |
cache_t *cache; |
} devcon_t; |
|
static int read_block(devcon_t *devcon, bn_t boff, size_t block_size); |
static int write_block(devcon_t *devcon, bn_t boff, size_t block_size); |
|
static devcon_t *devcon_search(dev_handle_t dev_handle) |
{ |
link_t *cur; |
|
futex_down(&dcl_lock); |
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) { |
futex_up(&dcl_lock); |
fibril_mutex_unlock(&dcl_lock); |
return devcon; |
} |
} |
futex_up(&dcl_lock); |
fibril_mutex_unlock(&dcl_lock); |
return NULL; |
} |
|
108,6 → 114,7 |
link_initialize(&devcon->link); |
devcon->dev_handle = dev_handle; |
devcon->dev_phone = dev_phone; |
fibril_mutex_initialize(&devcon->com_area_lock); |
devcon->com_area = com_area; |
devcon->com_size = com_size; |
devcon->bb_buf = NULL; |
115,25 → 122,25 |
devcon->bb_size = 0; |
devcon->cache = NULL; |
|
futex_down(&dcl_lock); |
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) { |
futex_up(&dcl_lock); |
fibril_mutex_unlock(&dcl_lock); |
free(devcon); |
return EEXIST; |
} |
} |
list_append(&devcon->link, &dcl_head); |
futex_up(&dcl_lock); |
fibril_mutex_unlock(&dcl_lock); |
return EOK; |
} |
|
static void devcon_remove(devcon_t *devcon) |
{ |
futex_down(&dcl_lock); |
fibril_mutex_lock(&dcl_lock); |
list_remove(&devcon->link); |
futex_up(&dcl_lock); |
fibril_mutex_unlock(&dcl_lock); |
} |
|
int block_init(dev_handle_t dev_handle, size_t com_size) |
207,14 → 214,16 |
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); |
fibril_mutex_lock(&devcon->com_area_lock); |
rc = read_block(devcon, 0, size); |
if (rc != EOK) { |
fibril_mutex_unlock(&devcon->com_area_lock); |
free(bb_buf); |
return rc; |
} |
memcpy(bb_buf, devcon->com_area, size); |
fibril_mutex_unlock(&devcon->com_area_lock); |
|
devcon->bb_buf = bb_buf; |
devcon->bb_off = off; |
devcon->bb_size = size; |
250,7 → 259,8 |
.remove_callback = cache_remove_callback |
}; |
|
int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks) |
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; |
262,10 → 272,12 |
if (!cache) |
return ENOMEM; |
|
futex_initialize(&cache->lock, 1); |
fibril_mutex_initialize(&cache->lock); |
list_initialize(&cache->free_head); |
cache->block_size = size; |
cache->block_count = blocks; |
cache->blocks_cached = 0; |
cache->mode = mode; |
|
if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1, |
&cache_ops)) { |
277,17 → 289,23 |
return EOK; |
} |
|
#define CACHE_LO_WATERMARK 10 |
#define CACHE_HI_WATERMARK 20 |
static bool cache_can_grow(cache_t *cache) |
{ |
if (cache->blocks_cached < CACHE_LO_WATERMARK) |
return true; |
if (!list_empty(&cache->free_head)) |
return false; |
return true; |
} |
|
static void block_initialize(block_t *b) |
{ |
futex_initialize(&b->lock, 1); |
fibril_mutex_initialize(&b->lock); |
b->refcnt = 1; |
b->dirty = false; |
rwlock_initialize(&b->contents_lock); |
fibril_rwlock_initialize(&b->contents_lock); |
link_initialize(&b->free_link); |
link_initialize(&b->hash_link); |
} |
309,6 → 327,7 |
block_t *b; |
link_t *l; |
unsigned long key = boff; |
bn_t oboff; |
|
devcon = devcon_search(dev_handle); |
|
316,7 → 335,7 |
assert(devcon->cache); |
|
cache = devcon->cache; |
futex_down(&cache->lock); |
fibril_mutex_lock(&cache->lock); |
l = hash_table_find(&cache->block_hash, &key); |
if (l) { |
/* |
323,19 → 342,16 |
* We found the block in the cache. |
*/ |
b = hash_table_get_instance(l, block_t, hash_link); |
futex_down(&b->lock); |
fibril_mutex_lock(&b->lock); |
if (b->refcnt++ == 0) |
list_remove(&b->free_link); |
futex_up(&b->lock); |
futex_up(&cache->lock); |
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)) { |
352,6 → 368,7 |
free(b); |
goto recycle; |
} |
cache->blocks_cached++; |
} else { |
/* |
* Try to recycle a block from the free list. |
361,8 → 378,9 |
assert(!list_empty(&cache->free_head)); |
l = cache->free_head.next; |
list_remove(l); |
b = hash_table_get_instance(l, block_t, hash_link); |
b = list_get_instance(l, block_t, free_link); |
sync = b->dirty; |
oboff = b->boff; |
temp_key = b->boff; |
hash_table_remove(&cache->block_hash, &temp_key, 1); |
} |
378,8 → 396,8 |
* kill concurent operations on the cache while doing I/O on the |
* block. |
*/ |
futex_down(&b->lock); |
futex_up(&cache->lock); |
fibril_mutex_lock(&b->lock); |
fibril_mutex_unlock(&cache->lock); |
|
if (sync) { |
/* |
386,7 → 404,11 |
* 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() */ |
fibril_mutex_lock(&devcon->com_area_lock); |
memcpy(devcon->com_area, b->data, b->size); |
rc = write_block(devcon, oboff, cache->block_size); |
assert(rc == EOK); |
fibril_mutex_unlock(&devcon->com_area_lock); |
} |
if (!(flags & BLOCK_FLAGS_NOREAD)) { |
/* |
393,12 → 415,14 |
* 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); |
fibril_mutex_lock(&devcon->com_area_lock); |
rc = read_block(devcon, b->boff, cache->block_size); |
assert(rc == EOK); |
memcpy(b->data, devcon->com_area, cache->block_size); |
fibril_mutex_unlock(&devcon->com_area_lock); |
} |
|
futex_up(&b->lock); |
fibril_mutex_unlock(&b->lock); |
} |
return b; |
} |
413,25 → 437,62 |
{ |
devcon_t *devcon = devcon_search(block->dev_handle); |
cache_t *cache; |
int rc; |
|
assert(devcon); |
assert(devcon->cache); |
|
cache = devcon->cache; |
futex_down(&cache->lock); |
futex_down(&block->lock); |
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. |
* Last reference to the block was dropped. Either free the |
* block or put it on the free list. |
*/ |
if (cache->blocks_cached > CACHE_HI_WATERMARK) { |
/* |
* Currently there are too many cached blocks. |
*/ |
if (block->dirty) { |
fibril_mutex_lock(&devcon->com_area_lock); |
memcpy(devcon->com_area, block->data, |
block->size); |
rc = write_block(devcon, block->boff, |
block->size); |
assert(rc == EOK); |
fibril_mutex_unlock(&devcon->com_area_lock); |
} |
/* |
* Take the block out of the cache and free it. |
*/ |
unsigned long key = block->boff; |
hash_table_remove(&cache->block_hash, &key, 1); |
free(block); |
free(block->data); |
cache->blocks_cached--; |
fibril_mutex_unlock(&cache->lock); |
return; |
} |
/* |
* Put the block on the free list. |
*/ |
list_append(&block->free_link, &cache->free_head); |
if (cache->mode != CACHE_MODE_WB && block->dirty) { |
fibril_mutex_lock(&devcon->com_area_lock); |
memcpy(devcon->com_area, block->data, block->size); |
rc = write_block(devcon, block->boff, block->size); |
assert(rc == EOK); |
fibril_mutex_unlock(&devcon->com_area_lock); |
|
block->dirty = false; |
} |
futex_up(&block->lock); |
futex_up(&cache->lock); |
} |
fibril_mutex_unlock(&block->lock); |
fibril_mutex_unlock(&cache->lock); |
} |
|
/** Read data from a block device. |
/** Read sequential 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 |
445,9 → 506,8 |
* |
* @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) |
int block_seqread(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; |
454,6 → 514,7 |
devcon_t *devcon = devcon_search(dev_handle); |
assert(devcon); |
|
fibril_mutex_lock(&devcon->com_area_lock); |
while (left > 0) { |
size_t rd; |
|
474,21 → 535,70 |
left -= rd; |
} |
|
if (*bufpos == *buflen) { |
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 : retval); |
int rc; |
|
rc = read_block(devcon, *pos / block_size, block_size); |
if (rc != EOK) { |
fibril_mutex_unlock(&devcon->com_area_lock); |
return rc; |
} |
|
*bufpos = 0; |
*buflen = block_size; |
} |
} |
fibril_mutex_unlock(&devcon->com_area_lock); |
|
return EOK; |
} |
|
/** Read block from block device. |
* |
* @param devcon Device connection. |
* @param boff Block index. |
* @param block_size Block size. |
* @param src Buffer for storing the data. |
* |
* @return EOK on success or negative error code on failure. |
*/ |
static int read_block(devcon_t *devcon, bn_t boff, size_t block_size) |
{ |
ipcarg_t retval; |
int rc; |
|
assert(devcon); |
rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK, boff, block_size, |
&retval); |
if ((rc != EOK) || (retval != EOK)) |
return (rc != EOK ? rc : (int) retval); |
|
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) |
{ |
ipcarg_t retval; |
int rc; |
|
assert(devcon); |
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; |
} |
|
/** @} |
*/ |