Changes in uspace/lib/libblock/libblock.c [d68e4d5:0da4e41] in mainline

File:

• uspace/lib/libblock/libblock.c (modified) (32 diffs)

uspace/lib/libblock/libblock.c

@@ -50 +50 @@
 #include <adt/list.h>
 #include <adt/hash_table.h>
+#include <macros.h>
 #include <mem.h>
 
@@ -62 +63 @@
 typedef struct {
         fibril_mutex_t lock;
-        size_t block_size;              /**< Block size. */
+        size_t lblock_size;             /**< Logical block size. */
         unsigned block_count;           /**< Total number of blocks. */
         unsigned blocks_cached;         /**< Number of cached blocks. */
@@ -74 +75 @@
         dev_handle_t dev_handle;
         int dev_phone;
-        fibril_mutex_t com_area_lock;
-        void *com_area;
-        size_t com_size;
+        fibril_mutex_t comm_area_lock;
+        void *comm_area;
+        size_t comm_size;
         void *bb_buf;
-        off_t bb_off;
-        size_t bb_size;
+        bn_t bb_addr;
+        size_t pblock_size;             /**< Physical block size. */
         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 int read_blocks(devcon_t *devcon, bn_t ba, size_t cnt);
+static int write_blocks(devcon_t *devcon, bn_t ba, size_t cnt);
+static int get_block_size(int dev_phone, size_t *bsize);
 
 static devcon_t *devcon_search(dev_handle_t dev_handle)
@@ -102 +104 @@
 }
 
-static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
-   size_t com_size)
+static int devcon_add(dev_handle_t dev_handle, int dev_phone, size_t bsize,
+    void *comm_area, size_t comm_size)
 {
         link_t *cur;
         devcon_t *devcon;
+
+        if (comm_size < bsize)
+                return EINVAL;
 
         devcon = malloc(sizeof(devcon_t));
@@ -115 +120 @@
         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;
+        fibril_mutex_initialize(&devcon->comm_area_lock);
+        devcon->comm_area = comm_area;
+        devcon->comm_size = comm_size;
         devcon->bb_buf = NULL;
-        devcon->bb_off = 0;
-        devcon->bb_size = 0;
+        devcon->bb_addr = 0;
+        devcon->pblock_size = bsize;
         devcon->cache = NULL;
 
@@ -144 +149 @@
 }
 
-int block_init(dev_handle_t dev_handle, size_t com_size)
+int block_init(dev_handle_t dev_handle, size_t comm_size)
 {
         int rc;
         int dev_phone;
-        void *com_area;
-        
-        com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
+        void *comm_area;
+        size_t bsize;
+
+        comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE,
             MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
-        if (!com_area) {
+        if (!comm_area) {
                 return ENOMEM;
         }
@@ -158 +164 @@
         dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING);
         if (dev_phone < 0) {
-                munmap(com_area, com_size);
+                munmap(comm_area, comm_size);
                 return dev_phone;
         }
 
-        rc = ipc_share_out_start(dev_phone, com_area,
+        rc = async_share_out_start(dev_phone, comm_area,
             AS_AREA_READ | AS_AREA_WRITE);
         if (rc != EOK) {
-                munmap(com_area, com_size);
+                munmap(comm_area, comm_size);
                 ipc_hangup(dev_phone);
                 return rc;
         }
-        
-        rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
+
+        if (get_block_size(dev_phone, &bsize) != EOK) {
+                munmap(comm_area, comm_size);
+                ipc_hangup(dev_phone);
+                return rc;
+        }
+        
+        rc = devcon_add(dev_handle, dev_phone, bsize, comm_area, comm_size);
         if (rc != EOK) {
-                munmap(com_area, com_size);
+                munmap(comm_area, comm_size);
                 ipc_hangup(dev_phone);
                 return rc;
@@ -195 +207 @@
         }
 
-        munmap(devcon->com_area, devcon->com_size);
+        munmap(devcon->comm_area, devcon->comm_size);
         ipc_hangup(devcon->dev_phone);
 
@@ -201 +213 @@
 }
 
-int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
+int block_bb_read(dev_handle_t dev_handle, bn_t ba)
 {
         void *bb_buf;
@@ -211 +223 @@
         if (devcon->bb_buf)
                 return EEXIST;
-        bb_buf = malloc(size);
+        bb_buf = malloc(devcon->pblock_size);
         if (!bb_buf)
                 return ENOMEM;
-        
-        fibril_mutex_lock(&devcon->com_area_lock);
-        rc = read_block(devcon, 0, size);
+
+        fibril_mutex_lock(&devcon->comm_area_lock);
+        rc = read_blocks(devcon, 0, 1);
         if (rc != EOK) {
-                fibril_mutex_unlock(&devcon->com_area_lock);
+                fibril_mutex_unlock(&devcon->comm_area_lock);
                 free(bb_buf);
                 return rc;
         }
-        memcpy(bb_buf, devcon->com_area, size);
-        fibril_mutex_unlock(&devcon->com_area_lock);
+        memcpy(bb_buf, devcon->comm_area, devcon->pblock_size);
+        fibril_mutex_unlock(&devcon->comm_area_lock);
 
         devcon->bb_buf = bb_buf;
-        devcon->bb_off = off;
-        devcon->bb_size = size;
+        devcon->bb_addr = ba;
 
         return EOK;
@@ -275 +286 @@
         fibril_mutex_initialize(&cache->lock);
         list_initialize(&cache->free_head);
-        cache->block_size = size;
+        cache->lblock_size = size;
         cache->block_count = blocks;
         cache->blocks_cached = 0;
         cache->mode = mode;
+
+        /* No block size translation a.t.m. */
+        assert(cache->lblock_size == devcon->pblock_size);
 
         if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
@@ -306 +320 @@
         b->refcnt = 1;
         b->dirty = false;
+        b->toxic = false;
         fibril_rwlock_initialize(&b->contents_lock);
         link_initialize(&b->free_link);
@@ -313 +328 @@
 /** Instantiate a block in memory and get a reference to it.
  *
+ * @param block                 Pointer to where the function will store the
+ *                              block pointer on success.
  * @param dev_handle            Device handle of the block device.
  * @param boff                  Block offset.
@@ -319 +336 @@
  *                              device.
  *
- * @return                      Block structure.
- */
-block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags)
+ * @return                      EOK on success or a negative error code.
+ */
+int block_get(block_t **block, dev_handle_t dev_handle, bn_t boff, int flags)
 {
         devcon_t *devcon;
@@ -328 +345 @@
         link_t *l;
         unsigned long key = boff;
-        bn_t oboff;
+        int rc;
         
         devcon = devcon_search(dev_handle);
@@ -336 +353 @@
         
         cache = devcon->cache;
+
+retry:
+        rc = EOK;
+        b = NULL;
+
         fibril_mutex_lock(&cache->lock);
         l = hash_table_find(&cache->block_hash, &key);
@@ -346 +368 @@
                 if (b->refcnt++ == 0)
                         list_remove(&b->free_link);
+                if (b->toxic)
+                        rc = EIO;
                 fibril_mutex_unlock(&b->lock);
                 fibril_mutex_unlock(&cache->lock);
@@ -352 +376 @@
                  * The block was not found in the cache.
                  */
-                int rc;
-                bool sync = false;
-
                 if (cache_can_grow(cache)) {
                         /*
@@ -364 +385 @@
                         if (!b)
                                 goto recycle;
-                        b->data = malloc(cache->block_size);
+                        b->data = malloc(cache->lblock_size);
                         if (!b->data) {
                                 free(b);
@@ -376 +397 @@
                         unsigned long temp_key;
 recycle:
-                        assert(!list_empty(&cache->free_head));
+                        if (list_empty(&cache->free_head)) {
+                                fibril_mutex_unlock(&cache->lock);
+                                rc = ENOMEM;
+                                goto out;
+                        }
                         l = cache->free_head.next;
-                        list_remove(l);
                         b = list_get_instance(l, block_t, free_link);
-                        sync = b->dirty;
-                        oboff = b->boff;
+
+                        fibril_mutex_lock(&b->lock);
+                        if (b->dirty) {
+                                /*
+                                 * The block needs to be written back to the
+                                 * device before it changes identity. Do this
+                                 * while not holding the cache lock so that
+                                 * concurrency is not impeded. Also move the
+                                 * block to the end of the free list so that we
+                                 * do not slow down other instances of
+                                 * block_get() draining the free list.
+                                 */
+                                list_remove(&b->free_link);
+                                list_append(&b->free_link, &cache->free_head);
+                                fibril_mutex_unlock(&cache->lock);
+                                fibril_mutex_lock(&devcon->comm_area_lock);
+                                memcpy(devcon->comm_area, b->data, b->size);
+                                rc = write_blocks(devcon, b->boff, 1);
+                                fibril_mutex_unlock(&devcon->comm_area_lock);
+                                if (rc != EOK) {
+                                        /*
+                                         * We did not manage to write the block
+                                         * to the device. Keep it around for
+                                         * another try. Hopefully, we will grab
+                                         * another block next time.
+                                         */
+                                        fibril_mutex_unlock(&b->lock);
+                                        goto retry;
+                                }
+                                b->dirty = false;
+                                if (!fibril_mutex_trylock(&cache->lock)) {
+                                        /*
+                                         * Somebody is probably racing with us.
+                                         * Unlock the block and retry.
+                                         */
+                                        fibril_mutex_unlock(&b->lock);
+                                        goto retry;
+                                }
+
+                        }
+                        fibril_mutex_unlock(&b->lock);
+
+                        /*
+                         * Unlink the block from the free list and the hash
+                         * table.
+                         */
+                        list_remove(&b->free_link);
                         temp_key = b->boff;
                         hash_table_remove(&cache->block_hash, &temp_key, 1);
@@ -388 +457 @@
                 block_initialize(b);
                 b->dev_handle = dev_handle;
-                b->size = cache->block_size;
+                b->size = cache->lblock_size;
                 b->boff = boff;
                 hash_table_insert(&cache->block_hash, &key, &b->hash_link);
@@ -394 +463 @@
                 /*
                  * 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.
+                 * kill concurrent 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.
-                         */
-                        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)) {
                         /*
@@ -416 +474 @@
                          * the new contents from the device.
                          */
-                        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);
-                }
+                        fibril_mutex_lock(&devcon->comm_area_lock);
+                        rc = read_blocks(devcon, b->boff, 1);
+                        memcpy(b->data, devcon->comm_area, cache->lblock_size);
+                        fibril_mutex_unlock(&devcon->comm_area_lock);
+                        if (rc != EOK) 
+                                b->toxic = true;
+                } else
+                        rc = EOK;
 
                 fibril_mutex_unlock(&b->lock);
         }
-        return b;
+out:
+        if ((rc != EOK) && b) {
+                assert(b->toxic);
+                (void) block_put(b);
+                b = NULL;
+        }
+        *block = b;
+        return rc;
 }
 
@@ -433 +500 @@
  *
  * @param block         Block of which a reference is to be released.
- */
-void block_put(block_t *block)
+ *
+ * @return              EOK on success or a negative error code.
+ */
+int block_put(block_t *block)
 {
         devcon_t *devcon = devcon_search(block->dev_handle);
         cache_t *cache;
-        int rc;
+        unsigned blocks_cached;
+        enum cache_mode mode;
+        int rc = EOK;
 
         assert(devcon);
@@ -444 +515 @@
 
         cache = devcon->cache;
+
+retry:
+        fibril_mutex_lock(&cache->lock);
+        blocks_cached = cache->blocks_cached;
+        mode = cache->mode;
+        fibril_mutex_unlock(&cache->lock);
+
+        /*
+         * Determine whether to sync the block. Syncing the block is best done
+         * when not holding the cache lock as it does not impede concurrency.
+         * Since the situation may have changed when we unlocked the cache, the
+         * blocks_cached and mode variables are mere hints. We will recheck the
+         * conditions later when the cache lock is held again.
+         */
+        fibril_mutex_lock(&block->lock);
+        if (block->toxic)
+                block->dirty = false;   /* will not write back toxic block */
+        if (block->dirty && (block->refcnt == 1) &&
+            (blocks_cached > CACHE_HI_WATERMARK || mode != CACHE_MODE_WB)) {
+                fibril_mutex_lock(&devcon->comm_area_lock);
+                memcpy(devcon->comm_area, block->data, block->size);
+                rc = write_blocks(devcon, block->boff, 1);
+                fibril_mutex_unlock(&devcon->comm_area_lock);
+                block->dirty = false;
+        }
+        fibril_mutex_unlock(&block->lock);
+
         fibril_mutex_lock(&cache->lock);
         fibril_mutex_lock(&block->lock);
@@ -449 +547 @@
                 /*
                  * Last reference to the block was dropped. Either free the
-                 * block or put it on the free list.
+                 * block or put it on the free list. In case of an I/O error,
+                 * free the block.
                  */
-                if (cache->blocks_cached > CACHE_HI_WATERMARK) {
+                if ((cache->blocks_cached > CACHE_HI_WATERMARK) ||
+                    (rc != EOK)) {
                         /*
-                         * Currently there are too many cached blocks.
+                         * Currently there are too many cached blocks or there
+                         * was an I/O error when writing the block back to the
+                         * device.
                          */
                         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);
+                                /*
+                                 * We cannot sync the block while holding the
+                                 * cache lock. Release everything and retry.
+                                 */
+                                block->refcnt++;
+                                fibril_mutex_unlock(&block->lock);
+                                fibril_mutex_unlock(&cache->lock);
+                                goto retry;
                         }
                         /*
@@ -473 +576 @@
                         cache->blocks_cached--;
                         fibril_mutex_unlock(&cache->lock);
-                        return;
+                        return rc;
                 }
                 /*
                  * Put the block on the free list.
                  */
+                if (cache->mode != CACHE_MODE_WB && block->dirty) {
+                        /*
+                         * We cannot sync the block while holding the cache
+                         * lock. Release everything and retry.
+                         */
+                        block->refcnt++;
+                        fibril_mutex_unlock(&block->lock);
+                        fibril_mutex_unlock(&cache->lock);
+                        goto retry;
+                }
                 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;
-                }
         }
         fibril_mutex_unlock(&block->lock);
         fibril_mutex_unlock(&cache->lock);
+
+        return rc;
 }
 
@@ -508 +614 @@
  */
 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 *pos, void *dst, size_t size)
 {
         off_t offset = 0;
         size_t left = size;
-        devcon_t *devcon = devcon_search(dev_handle);
-        assert(devcon);
-        
-        fibril_mutex_lock(&devcon->com_area_lock);
+        size_t block_size;
+        devcon_t *devcon;
+
+        devcon = devcon_search(dev_handle);
+        assert(devcon);
+        block_size = devcon->pblock_size;
+        
+        fibril_mutex_lock(&devcon->comm_area_lock);
         while (left > 0) {
                 size_t rd;
@@ -529 +639 @@
                          * destination buffer.
                          */
-                        memcpy(dst + offset, devcon->com_area + *bufpos, rd);
+                        memcpy(dst + offset, devcon->comm_area + *bufpos, rd);
                         offset += rd;
                         *bufpos += rd;
@@ -540 +650 @@
                         int rc;
 
-                        rc = read_block(devcon, *pos / block_size, block_size);
+                        rc = read_blocks(devcon, *pos / block_size, 1);
                         if (rc != EOK) {
-                                fibril_mutex_unlock(&devcon->com_area_lock);
+                                fibril_mutex_unlock(&devcon->comm_area_lock);
                                 return rc;
                         }
@@ -550 +660 @@
                 }
         }
-        fibril_mutex_unlock(&devcon->com_area_lock);
+        fibril_mutex_unlock(&devcon->comm_area_lock);
         
         return EOK;
 }
 
-/** Read block from block device.
+/** Read blocks directly from device (bypass cache).
+ *
+ * @param dev_handle    Device handle of the block device.
+ * @param ba            Address of first block.
+ * @param cnt           Number of blocks.
+ * @param src           Buffer for storing the data.
+ *
+ * @return              EOK on success or negative error code on failure.
+ */
+int block_read_direct(dev_handle_t dev_handle, bn_t ba, size_t cnt, void *buf)
+{
+        devcon_t *devcon;
+        int rc;
+
+        devcon = devcon_search(dev_handle);
+        assert(devcon);
+        
+        fibril_mutex_lock(&devcon->comm_area_lock);
+
+        rc = read_blocks(devcon, ba, cnt);
+        if (rc == EOK)
+                memcpy(buf, devcon->comm_area, devcon->pblock_size * cnt);
+
+        fibril_mutex_unlock(&devcon->comm_area_lock);
+
+        return rc;
+}
+
+/** Write blocks directly to device (bypass cache).
+ *
+ * @param dev_handle    Device handle of the block device.
+ * @param ba            Address of first block.
+ * @param cnt           Number of blocks.
+ * @param src           The data to be written.
+ *
+ * @return              EOK on success or negative error code on failure.
+ */
+int block_write_direct(dev_handle_t dev_handle, bn_t ba, size_t cnt,
+    const void *data)
+{
+        devcon_t *devcon;
+        int rc;
+
+        devcon = devcon_search(dev_handle);
+        assert(devcon);
+        
+        fibril_mutex_lock(&devcon->comm_area_lock);
+
+        memcpy(devcon->comm_area, data, devcon->pblock_size * cnt);
+        rc = read_blocks(devcon, ba, cnt);
+
+        fibril_mutex_unlock(&devcon->comm_area_lock);
+
+        return rc;
+}
+
+/** Get device block size.
+ *
+ * @param dev_handle    Device handle of the block device.
+ * @param bsize         Output block size.
+ *
+ * @return              EOK on success or negative error code on failure.
+ */
+int block_get_bsize(dev_handle_t dev_handle, size_t *bsize)
+{
+        devcon_t *devcon;
+
+        devcon = devcon_search(dev_handle);
+        assert(devcon);
+        
+        return get_block_size(devcon->dev_phone, bsize);
+}
+
+/** Read blocks from block device.
  *
  * @param devcon        Device connection.
- * @param boff          Block index.
- * @param block_size    Block size.
+ * @param ba            Address of first block.
+ * @param cnt           Number of blocks.
  * @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;
+static int read_blocks(devcon_t *devcon, bn_t ba, size_t cnt)
+{
         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;
+        rc = async_req_3_0(devcon->dev_phone, BD_READ_BLOCKS, LOWER32(ba),
+            UPPER32(ba), cnt);
+        return rc;
 }
 
@@ -581 +760 @@
  *
  * @param devcon        Device connection.
- * @param boff          Block index.
- * @param block_size    Block size.
+ * @param ba            Address of first block.
+ * @param cnt           Number of blocks.
  * @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;
+static int write_blocks(devcon_t *devcon, bn_t ba, size_t cnt)
+{
         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;
+        rc = async_req_3_0(devcon->dev_phone, BD_WRITE_BLOCKS, LOWER32(ba),
+            UPPER32(ba), cnt);
+        return rc;
+}
+
+/** Get block size used by the device. */
+static int get_block_size(int dev_phone, size_t *bsize)
+{
+        ipcarg_t bs;
+        int rc;
+
+        rc = async_req_0_1(dev_phone, BD_GET_BLOCK_SIZE, &bs);
+        if (rc == EOK)
+                *bsize = (size_t) bs;
+
+        return rc;
 }