ra8_io_blockdev_vsource.c

Go to the documentation of this file.

 
#include "ra8_io_blockdev_vsource.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_io_blockdev.h"
#include "ra8_vsource.h"

static const char* const s_tag = "ra8_io_blockdev_vsource";

typedef enum : uint32_t {
  k_ra8_io_bd_vsource_one_block = 1, 
} ra8_io_bd_vsource_const_t;

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_bd_read_sector(ra8_io_blockdev_vsource_ctx_t* ctx,
                                                      uint32_t                       lba)
{
  return ra8_io_blockdev_read(ctx->bd, lba, (uint32_t)k_ra8_io_bd_vsource_one_block, ctx->scratch);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_bd_copy_slice(ra8_io_blockdev_vsource_ctx_t* ctx,
                                                     uint32_t                       lba,
                                                     uint32_t                       in_block,
                                                     uint32_t                       n,
                                                     uint8_t*                       dst)
{
  const ra8_err_t err = internal_bd_read_sector(ctx, lba);
  if (err != k_ra8_ok) {
    return err;
  }
  (void)memcpy(dst, &ctx->scratch[in_block], (size_t)n);
  return k_ra8_ok;
}

typedef struct {
  uint64_t cur;    
  uint8_t* out;    
  uint32_t remain; 
} ra8_io_bd_vsource_cursor_t;

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_bd_read_head(ra8_io_blockdev_vsource_ctx_t* ctx,
                                                    ra8_io_bd_vsource_cursor_t*    cur,
                                                    uint64_t                       block_bytes)
{
  const uint32_t head_in_block = (uint32_t)(cur->cur % block_bytes);
  if (head_in_block == 0U) {
    return k_ra8_ok;
  }
  uint32_t head_n = (uint32_t)(block_bytes - (uint64_t)head_in_block);
  if (head_n > cur->remain) {
    head_n = cur->remain;
  }
  const ra8_err_t err = internal_bd_copy_slice(ctx,
                                               (uint32_t)(cur->cur / block_bytes),
                                               head_in_block,
                                               head_n,
                                               cur->out);
  if (err != k_ra8_ok) {
    return err;
  }
  cur->cur += (uint64_t)head_n;
  cur->out += head_n;
  cur->remain -= head_n;
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_bd_read_middle(ra8_io_blockdev_vsource_ctx_t* ctx,
                                                      ra8_io_bd_vsource_cursor_t*    cur,
                                                      uint64_t                       block_bytes)
{
  const uint32_t mid_blocks = (uint32_t)((uint64_t)cur->remain / block_bytes);
  if (mid_blocks == 0U) {
    return k_ra8_ok;
  }
  const ra8_err_t err =
    ra8_io_blockdev_read(ctx->bd, (uint32_t)(cur->cur / block_bytes), mid_blocks, cur->out);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint32_t mid_bytes = (uint32_t)((uint64_t)mid_blocks * block_bytes);
  cur->cur += (uint64_t)mid_bytes;
  cur->out += mid_bytes;
  cur->remain -= mid_bytes;
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_bd_read_tail(ra8_io_blockdev_vsource_ctx_t* ctx,
                                                    ra8_io_bd_vsource_cursor_t*    cur,
                                                    uint64_t                       block_bytes)
{
  if (cur->remain == 0U) {
    return k_ra8_ok;
  }
  return internal_bd_copy_slice(ctx, (uint32_t)(cur->cur / block_bytes), 0U, cur->remain, cur->out);
}
 
ra8_err_t ra8_io_blockdev_vsource_init(ra8_io_blockdev_vsource_ctx_t* ctx,
                                       const ra8_io_blockdev_t*       bd)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(bd, s_tag, "bd must not be nullptr");
  ctx->bd = bd;
  (void)memset(ctx->scratch, 0, sizeof(ctx->scratch));
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_blockdev_vsource_read(void* ctx, uint64_t offset, uint8_t* buf, uint32_t len)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  ra8_io_blockdev_vsource_ctx_t* c = (ra8_io_blockdev_vsource_ctx_t*)ctx;
 
  const uint64_t block_bytes = (uint64_t)k_ra8_io_block_size_bytes;
  if (offset > (UINT64_MAX - (uint64_t)len)) {
    return k_ra8_err_out_of_range;
  }
 
  ra8_io_bd_vsource_cursor_t cur = {.cur = offset, .out = buf, .remain = len};
 
  /* Unaligned head: the byte offset does not start on a sector boundary. */
  ra8_err_t err = internal_bd_read_head(c, &cur, block_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
 
  /* Aligned middle: whole sectors copied straight into the caller buffer. */
  err = internal_bd_read_middle(c, &cur, block_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
 
  /* Unaligned tail: a partial final sector. */
  return internal_bd_read_tail(c, &cur, block_bytes);
}