Esempio n. 1
0
//------------------------------------------------
// Discover device's minimum direct IO op size.
//
static uint64_t
discover_min_op_bytes(int fd, const char* name)
{
	uint8_t* buf = act_valloc(HI_IO_MIN_SIZE);

	if (! buf) {
		fprintf(stdout, "ERROR: IO min size buffer act_valloc()\n");
		return 0;
	}

	size_t read_sz = LO_IO_MIN_SIZE;

	while (read_sz <= HI_IO_MIN_SIZE) {
		if (pread_all(fd, (void*)buf, read_sz, 0)) {
			free(buf);
			return read_sz;
		}

		read_sz <<= 1; // LO_IO_MIN_SIZE and HI_IO_MIN_SIZE are powers of 2
	}

	fprintf(stdout, "ERROR: %s read failed at all sizes from %u to %u bytes\n",
			name, LO_IO_MIN_SIZE, HI_IO_MIN_SIZE);

	free(buf);

	return 0;
}
Esempio n. 2
0
/**
 * Read sector data from the offset.
 *
 * @fd file descriptor to read.
 * @offset offset in sectors.
 * @sect sectors data to be filled.
 *
 * RETURN:
 *   true in success, or false.
 */
bool sector_read(int fd, u64 offset, struct sector_data *sect)
{
	ASSERT(fd > 0);
	ASSERT_SECTOR_DATA(sect);

	return pread_all(fd, sect->data, sect->size, offset * sect->size);
}
Esempio n. 3
0
File: teepot.c Progetto: dkj/teepot
static int reread_data(Chunk *chunk, SpillControl *spillage) {
  assert(chunk->len > 0 && chunk->len <= CHUNK_SZ);
  chunk->data = malloc(chunk->len);
  if (NULL == chunk->data) {
    perror("reread_data");
    return -1;
  }
  if (0 != pread_all(chunk->spill->fd,
		     chunk->data, chunk->len, chunk->spill_offset)) {
    return -1;
  }
  spillage->alloced += CHUNK_SZ;
  if (spillage->alloced > spillage->max_alloced) {
    spillage->max_alloced = spillage->alloced;
  }

  if (verbosity > 2) {
    if (chunk->spill->is_tmp) {
      fprintf(stderr, "%.3f Re-read %zd bytes (%sB) from spill file #%d\n",
	      get_time(), chunk->len, human_size(chunk->len),
	      chunk->spill->is_tmp);
    } else {
      fprintf(stderr, "%.3f Re-read %zd bytes (%sB) from input file\n",
	      get_time(), chunk->len, human_size(chunk->len));
    }
  } 

  return 0;
}
Esempio n. 4
0
/**
 * Read to sector data in units of logical block.
 * Logical block size is 512 bytes.
 *
 * @fd file descriptor to write.
 * @offset_lb offset [logical block].
 * @sect sector data to be partially read.
 * @idx_lb start index [logical block].
 * @n_lb number of logical blocks to read.
 *
 * RETURN:
 *   true in success, or false.
 */
bool sector_read_lb(
	int fd,  u64 offset_lb, struct sector_data *sect,
	unsigned int idx_lb, unsigned int n_lb)
{
	const size_t count = n_lb * LOGICAL_BLOCK_SIZE;
	const off_t buf_off = idx_lb * LOGICAL_BLOCK_SIZE;
	const off_t file_off = offset_lb * LOGICAL_BLOCK_SIZE;

	ASSERT(fd > 0);
	ASSERT_SECTOR_DATA(sect);
	ASSERT(capacity_pb(sect->size, idx_lb + n_lb) == 1);

	return pread_all(fd, sect->data + buf_off, count, file_off);
}
Esempio n. 5
0
//------------------------------------------------
// Do one device read operation.
//
static uint64_t
read_from_device(device* dev, uint64_t offset, uint32_t size, uint8_t* buf)
{
	int fd = fd_get(dev);

	if (fd == -1) {
		return -1;
	}

	if (! pread_all(fd, buf, size, offset)) {
		close(fd);
		fprintf(stdout, "ERROR: reading %s: %d '%s'\n", dev->name, errno,
				act_strerror(errno));
		return -1;
	}

	uint64_t stop_ns = get_ns();

	fd_put(dev, fd);

	return stop_ns;
}