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

     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,
+static int read_block(devcon_t *devcon, bn_t boff, size_t block_size);
-    const void *src);
+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;
         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);
+    rc = read_block(devcon, 0, size);
     if (rc != EOK) {
             free(bb_buf);
         return rc;
+    }
+    memcpy(bb_buf, devcon->com_area, size);
     devcon->bb_buf = bb_buf;
     devcon->bb_off = off;
     devcon->bb_size = size;
     return EOK;
     } 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.
         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);
+            rc = read_block(devcon, b->boff, cache->block_size);
             assert(rc == EOK);
+            memcpy(b->data, devcon->com_area, cache->block_size);
+        }
         fibril_mutex_unlock(&b->lock);
+    }
     return b;
          * 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,
+            memcpy(devcon->com_area, block->data, block->size);
-                block->data);
+            rc = write_block(devcon, block->boff, block->size);
             assert(rc == EOK);
             block->dirty = false;
+        }
+    }
     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
  *          communication buffer.
  * @param buflen    Pointer to the number of unread bytes that are ready in
  * @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,
+int block_seqread(dev_handle_t dev_handle, off_t *bufpos, size_t *buflen,
-    void *dst, size_t size, size_t block_size)
+    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);
             left -= rd;
+        }
         if (*bufpos == (off_t) *buflen) {
             /* Refill the communication buffer with a new block. */
-            ipcarg_t retval;
+            int rc;
-            int rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK,
-                *pos / block_size, block_size, &retval);
+            rc = read_block(devcon, *pos / block_size, block_size);
-            if ((rc != EOK) || (retval != EOK))
+            if (rc != EOK)
-                return (rc != EOK ? rc : (int) retval);
+                return rc;
             *bufpos = 0;
             *buflen = block_size;
+        }
+    }
     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,
+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,
+    rc = async_req_2_1(devcon->dev_phone, BD_WRITE_BLOCK, boff, block_size,
-        boff, block_size, &retval);
+        &retval);
     if ((rc != EOK) || (retval != EOK))
         return (rc != EOK ? rc : (int) retval);
     return EOK;
+}

Subversion Repositories HelenOS

(root)//trunk/uspace/lib/libblock/libblock.c – Rev 4572 → 4583