haiku.git

/*
 * Copyright 2008, Samuel Rodriguez Perez, samuelgaliza@gmail.com.
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "fs_freebsd.h"

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/disk.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>


// Read and write operations in FreeBSD only work on devices block by block.

ssize_t
haiku_freebsd_read(int fd, void *buf, size_t nbytes)
{
	struct stat st;
	if (fstat(fd, &st) != 0)
		return -1;

	if (S_ISREG(st.st_mode))
		return read(fd, buf, nbytes); // Is a file! Good :)

	uint sectorSize;
	if (ioctl(fd, DIOCGSECTORSIZE, &sectorSize) == -1)
		sectorSize = 512; // If fail, hardcode to 512 for now

	off_t cur = lseek(fd, 0, SEEK_CUR);
	if (cur == -1)
		perror("lseek 1");

	off_t seekDiff = (sectorSize - (cur % sectorSize)) % sectorSize;
	off_t nbytesDiff = (nbytes - seekDiff) % sectorSize;

	if (seekDiff == 0 && nbytesDiff == 0) {
		// Not needed but this saves malloc and free operations
		return read(fd, buf, nbytes);
	} else if (cur % sectorSize + nbytes <= sectorSize) {
		// Read complete in only a block
		char* tmpBlock = (char*)malloc(sectorSize);

		// Put at start of the block
		off_t sdCur = lseek(fd, -(cur % sectorSize), SEEK_CUR);
		if (sdCur == -1)
			perror("lseek oneblock");

		if (read(fd, tmpBlock, sectorSize) == -1)
			perror("read oneblock");

		memcpy((char*)buf, tmpBlock + cur % sectorSize, nbytes);

		// repos at byte offset of latest wrote block
		if (lseek(fd, -sectorSize + (cur % sectorSize) + nbytes, SEEK_CUR)
				== -1) {
			perror("lseek2 oneblock");
		}

		free(tmpBlock);

		return nbytes;
	} else {
		// Needs to write more than a block

		char* tmpBlock = (char*)malloc(sectorSize);

		// First block if seek isn't
		if (seekDiff > 0) {
			// read entire block at 0 pos
			if (lseek(fd, -(sectorSize - seekDiff), SEEK_CUR) == -1)
				perror("lseek seekDiff");

			off_t sdCur = lseek(fd,0,SEEK_CUR);
			if (sdCur == -1)
				perror("lseek2 seekDiff");

			if (read(fd, tmpBlock, sectorSize) == -1 )
				perror("read seekDiff");

			// alter content
			memcpy(buf, tmpBlock + (sectorSize - seekDiff), seekDiff);
		}

		// Blocks between
		if ((nbytes - seekDiff) >= sectorSize) {
			if (read(fd, ((char*)buf) + seekDiff, nbytes - seekDiff
					- nbytesDiff) == -1) {
				perror("read between");
			}
		}

		// Last block if overflow
		if (nbytesDiff > 0 ) {
			off_t sdCur = lseek(fd, 0, SEEK_CUR);
			if (sdCur == -1)
				perror("lseek last");

			if (read(fd, tmpBlock, sectorSize) == -1)
				perror("read last");

			memcpy(((char*)buf) + nbytes - nbytesDiff, tmpBlock, nbytesDiff);

			// repos at byte offset of latest wrote block
			if (lseek(fd, -(sectorSize - nbytesDiff), SEEK_CUR) == -1)
				perror("lseek2 last");
		}

		free(tmpBlock);

		return nbytes;
	}
}


ssize_t
haiku_freebsd_write(int fd, const void *buf, size_t nbytes)
{
	struct stat st;
	if (fstat(fd, &st) != 0)
		return -1;

	if (S_ISREG(st.st_mode))
		return write(fd, buf, nbytes); // Is a file! Good :)

	uint sectorSize;
	if (ioctl(fd, DIOCGSECTORSIZE, &sectorSize) == -1)
		sectorSize = 512; // If fail, hardcode do 512 for now

	off_t cur = lseek(fd, 0, SEEK_CUR);
	if (cur == -1)
		perror("lseek 1");

	off_t seekDiff = (sectorSize - (cur % sectorSize)) % sectorSize;
	off_t nbytesDiff = (nbytes - seekDiff) % sectorSize;

	if (seekDiff == 0 && nbytesDiff == 0) {
		// Not needed but this saves malloc and free operations
		return write(fd, buf, nbytes);
	} else if (cur % sectorSize + nbytes <= sectorSize) {
		// Write complete in only a block
		char* tmpBlock = (char*)malloc(sectorSize);

		// Put at start of the block
		off_t sdCur = lseek(fd, -(cur % sectorSize), SEEK_CUR);
		if (sdCur == -1)
			perror("lseek oneblock");

		if (pread(fd, tmpBlock, sectorSize, sdCur) == -1)
			perror("pread oneblock");

		memcpy(tmpBlock + cur % sectorSize, (char*)buf, nbytes);
		if (write(fd, tmpBlock, sectorSize) == -1)
			perror("write oneblock");

		// repos at byte offset of latest written block
		if (lseek(fd, -sectorSize + (cur % sectorSize) + nbytes, SEEK_CUR)
				== -1) {
			perror("lseek2 oneblock");
		}

		free(tmpBlock);

		return nbytes;
	} else {
		// Needs to write more than a block

		char* tmpBlock = (char*)malloc(sectorSize);

		// First block if seek isn't
		if (seekDiff > 0) {
			// read entire block at 0 pos
			if (lseek(fd, -(sectorSize - seekDiff), SEEK_CUR) == -1)
				perror("lseek seekDiff");

			off_t sdCur = lseek(fd, 0, SEEK_CUR);
			if (sdCur == -1)
				perror("lseek2 seekDiff");

			if (pread(fd, tmpBlock, sectorSize, sdCur) == -1)
				perror("pread seekDiff");

			// alter content
			memcpy(tmpBlock + (sectorSize - seekDiff), buf, seekDiff);
			if (write(fd, tmpBlock, sectorSize) == -1)
				perror("write seekDiff");
		}

		// Blocks between
		if ((nbytes - seekDiff) >= sectorSize) {
			if (write(fd, ((char*)buf) + seekDiff, nbytes - seekDiff
					- nbytesDiff) == -1) {
				perror("write between");
			}
		}

		// Last block if overflow
		if (nbytesDiff > 0) {
			off_t sdCur = lseek(fd, 0, SEEK_CUR);
			if (sdCur == -1)
				perror("lseek last");

			if (pread(fd, tmpBlock, sectorSize, sdCur) == -1)
				perror("pread last");

			memcpy(tmpBlock, ((char*)buf) + nbytes - nbytesDiff, nbytesDiff);
			if (write(fd, tmpBlock, sectorSize) == -1)
				perror("write last");

			// repos at byte offset of latest wrote block
			if (lseek(fd, -(sectorSize - nbytesDiff), SEEK_CUR) == -1)
				perror("lseek2 last");
		}

		free(tmpBlock);

		return nbytes;
	}
}


ssize_t
haiku_freebsd_readv(int fd, const struct iovec *vecs, size_t count)
{
	ssize_t bytesRead = 0;

	for (size_t i = 0; i < count; i++) {
		ssize_t currentRead = haiku_freebsd_read(fd, vecs[i].iov_base,
			vecs[i].iov_len);

		if (currentRead < 0)
			return bytesRead > 0 ? bytesRead : -1;

		bytesRead += currentRead;

		if ((size_t)currentRead != vecs[i].iov_len)
			break;
	}

	return bytesRead;
}


ssize_t
haiku_freebsd_writev(int fd, const struct iovec *vecs, size_t count)
{
	ssize_t bytesWritten = 0;

	for (size_t i = 0; i < count; i++) {
		ssize_t written = haiku_freebsd_write(fd, vecs[i].iov_base,
			vecs[i].iov_len);

		if (written < 0)
			return bytesWritten > 0 ? bytesWritten : -1;

		bytesWritten += written;

		if ((size_t)written != vecs[i].iov_len)
			break;
	}

	return bytesWritten;
}