read_pos
extern ssize_t read_pos(int fd, off_t pos, void* buffer, size_t count);
extern ssize_t read_pos(int fd, off_t pos, void *buffer, size_t count);
if (read_pos(volume->Device(), newBlockNumber << volume->BlockShift(),
if (read_pos(volume->Device(), offset << blockShift, buffer,
if (read_pos(fd, 0, buffer, sizeof(buffer)) != sizeof(buffer))
read_pos(fVolume->Device(), fRootBlock * fVolume->BlockSize(), &header,
if (read_pos(fd, BTRFS_SUPER_BLOCK_OFFSET, superBlock,
if (read_pos(fd, EXFAT_SUPER_BLOCK_OFFSET, superBlock,
for (uint32 i = 0; read_pos(fd, rootDirectoryOffset + i * entrySize,
size_t read = read_pos(fJournalVolume->Device(),
size_t bytesRead = read_pos(fJournalVolume->Device(), superblockPos,
size_t bytesRead = read_pos(fJournalVolume->Device(), superblockPos
if (read_pos(fd, EXT2_SUPER_BLOCK_OFFSET, superBlock,
if (read_pos(device->si_fd, 0, bootSector, 512) != 512) {
if (read_pos(fd, 0, buf, 512) != 512)
int32 bytesRead = read_pos(fd, rootDirPos, rootDirBuffer, rootDirBytes);
= read_pos(volume->pm_dev->si_fd, position, reinterpret_cast<void*>(fatBuffer), bytesPerSec);
bytes_read = read_pos(volume->pm_dev->si_fd, position,
retval = read_pos(volume->fdOfSession, offset, (void*)buffer,
error = read_pos(deviceFD, offset, (void *)&buffer, ISO_PVD_SIZE);
ssize_t bytesRead = read_pos(fFD, pos, buffer, size);
if (read_pos(fd, 0, (void*)&boot, 512) != 512) {
if (read_pos(device, offset, superBlock, size) != (int32)size)
ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize);
ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize);
ssize_t bytesRead = read_pos(device, address, chunk.Data(),
ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize);
= read_pos(device, address, chunk.Data(), blockSize);
length += read_pos(fd, pos, buffer + length, remainingLength);
length = read_pos(fd, pos, buffer, *_length);
read_pos(fd, indirectOffset,
read_pos(fd, indirectOffset,
read_pos(fd, indirectOffset,
read_pos(fd, indirectOffset,
read_pos(fd, indirectOffset,
read_pos(fd, indirectOffset,
if (read_pos(fd, offset, (void*)&fNode, sizeof(fNode)) != sizeof(fNode)) {
if (read_pos(fd, SBLOCK_UFS2, superBlock,
ret = read_pos(fd, bnum * bsize, data, num_blocks * bsize);
ret = read_pos(fd, (bnum * bsize) + sum, data, CHUNK);
ret = read_pos(fd, (bnum * bsize) + sum, data,
if (read_pos(volume->Device(), readPos, path[i].blockData, len)
if (read_pos(volume->Device(), readPos, path[i].blockData, len)
if (read_pos(volume->Device(), readPos, fSingleDirBlock, len)
if (read_pos(fInode->GetVolume()->Device(), readPos, blockBuffer, len)
if (read_pos(fInode->GetVolume()->Device(), readPos, fBlockBuffer, len)
if (read_pos(volume->Device(), readPos, node, len) != len) {
if (read_pos(volume->Device(), readPos, block, len)
if (read_pos(volume->Device(), readPos, block, len)
if (read_pos(GetVolume()->Device(), readPos, block, lengthOfBlock)
if (read_pos(fVolume->Device(), readPos, fBuffer, len) != len) {
if (read_pos(fInode->GetVolume()->Device(), readPos, fLeafBuffer, len) != len) {
if (read_pos(fInode->GetVolume()->Device(), readPos, buffer, lengthToRead)
if (read_pos(fInode->GetVolume()->Device(), readPos, blockBuffer, len)
if (read_pos(fInode->GetVolume()->Device(), readPos, blockBuffer, len)
if (read_pos(fInode->GetVolume()->Device(), readPos, buffer, len) != len) {
if (read_pos(fInode->GetVolume()->Device(), readPos, buffer, lengthToRead)
if (read_pos(fInode->GetVolume()->Device(), readPos, fSymlinkBuffer, len)
if(read_pos(fd, 0, buf, 512) != 512)
ssize_t bytesRead = read_pos(fd, sector * 512, buffer, sizeof(buffer));
ssize_t bytesRead = read_pos(fd, (off_t)cookie * rdb.BlockSize(),
if (read_pos(fd, 0, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer))
ssize_t bytesRead = read_pos(fd, (off_t)block * descriptor.BlockSize(),
ssize_t bytesRead = read_pos(fd, 0, buffer, sizeof(buffer));
ssize_t bytesRead = read_pos(fd, offset, data, size);
ssize_t bytesRead = read_pos(fDeviceFD, fSessionOffset + offset,
bytesRead = read_pos(fDeviceFD, fSessionOffset + offset
if (read_pos(fDeviceFD, partitionOffset, &partitionTable,
if (read_pos(fd, fromOffset, buffer, size) != size) {
ssize_t bytesRead = read_pos(fd, 0, buffer, sizeof(buffer));
read_pos(fd, offset + 512, &bootblock, sizeof(bootblock));
read_pos(fd, offset, &bootblock, kBootCodeSize);
ssize_t bytesRead = read_pos(fromAttrFD, offset, kBuffer, size);
ssize_t bytesRead = read_pos(attrFD, pos, buffer, readBytes);
ssize_t result = read_pos(fFD, i, values->data,
ssize_t result = read_pos(fd, 0, buffer, st.st_size);
ssize_t length = read_pos(fd, 0, &image->elf_header, sizeof(EhdrType));
length = read_pos(fd, elfHeader.e_phoff, programHeaders, size);
length = read_pos(fd, header.p_offset,
ssize_t length = read_pos(fd, elfHeader.e_shoff, sectionHeaders, size);
length = read_pos(fd, sectionHeaders[i].sh_offset, symbolTable,
length = read_pos(fd, stringHeader->sh_offset, stringTable, size);
if (read_pos(volume.Device(), block * volume.BlockSize(), data, volume.BlockSize()) == volume.BlockSize())
ssize_t bytesRead = read_pos(fDevice, block * fNode.BlockSize() + blockOffset,
if (read_pos(volume.Device(), block * volume.BlockSize(), data, volume.BlockSize()) == volume.BlockSize())
if (read_pos(fDevice, next * fNode.BlockSize(), fBlock.BlockData(), fNode.BlockSize()) < B_OK)
if (read_pos(fDevice, 0, &fType, sizeof(int32)) < B_OK)
if (read_pos(fDevice, fBlock * fNode.BlockSize(), fData, fNode.BlockSize()) < B_OK)
if (read_pos(fDevice, offset * blockSize, buffer, blockSize) < B_OK)
if (read_pos(volume.Device(), volume.ToOffset(run), this, sizeof(bfs_inode))
if (read_pos(volume.Device(), volume.ToOffset(id), this, sizeof(bfs_inode))
if (read_pos(fVolume.Device(), fVolume.ToOffset(run), buffer + bytesRead,
if (read_pos(fVolume.Device(), block << BlockShift(), fBlock, BlockSize())
if (read_pos(fDevice, 512, &fSuperBlock, sizeof(disk_super_block)) < B_OK)
if (read_pos(fDevice, 0, &fSuperBlock, sizeof(disk_super_block)) < B_OK)
ssize_t bytesRead = read_pos(fVolume.Device(),
if (read_pos(fVolume.Device(), fVolume.BlockToOffset(num),
if (read_pos(fDevice, offset * blockSize, buffer, blockSize) < B_OK)
if (read_pos(fDevice, 1024, &header, sizeof(header)) < B_OK)
ssize_t result = read_pos(fFD, this->offset + position, buffer, bufferSize);
return read_pos(fd, offset, buffer, bufferSize);
ssize_t bytesRead = read_pos(cache->fd, blockNumber * blockSize,
length = read_pos(fd, elfHeader->e_shoff, sectionHeaders, size);
= read_pos(fd, sectionHeaders[i].sh_offset, symbolTable, size);
length = read_pos(fd, stringHeader->sh_offset, stringTable, size);
ssize_t bytesRead = read_pos(device->FD(), offset, buffer, sizeof(buffer));
if (read_pos(device, blockNumber << superBlock.BlockShift(),
if (read_pos(device, blockNumber << superBlock.BlockShift(),
if (read_pos(device, 512, &superBlock, sizeof(disk_super_block)) < (ssize_t)sizeof(disk_super_block)) {
ssize_t bytesRead = read_pos(info.fd, position, buffer, *numBytes);
return read_pos(fHandle, pos, buffer, bufferSize);
return read_pos(fd, pos, buffer, count);
#define pread(_fd, _buf, _count, _pos) read_pos(_fd, _pos, _buf, _count)