/*
 * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <stddef.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <io.h>
#include <gpxe/buffer.h>

/** @file
 *
 * Buffer internals.
 *
 * A buffer consists of a single, contiguous area of memory, some of
 * which is "filled" and the remainder of which is "free".  The
 * "filled" and "free" spaces are not necessarily contiguous.
 *
 * At the start of a buffer's life, it consists of a single free
 * space.  As data is added to the buffer via fill_buffer(), this free
 * space decreases and can become fragmented.
 *
 * Each free block within a buffer (except the last) starts with a @c
 * struct @c buffer_free_block.  This describes the size of the free
 * block, and the offset to the next free block.
 *
 * We cannot simply start every free block (including the last) with a
 * descriptor, because it is conceivable that we will, at some point,
 * encounter a situation in which the final free block of a buffer is
 * too small to contain a descriptor.  Consider a protocol with a
 * blocksize of 512 downloading a 1025-byte file into a 1025-byte
 * buffer.  Suppose that the first two blocks are received; we have
 * now filled 1024 of the 1025 bytes in the buffer, and our only free
 * block consists of the 1025th byte.
 * 
 * Note that the rather convoluted way of manipulating the buffer
 * descriptors (using copy_{to,from}_phys rather than straightforward
 * pointers) is needed to cope with operation as a PXE stack, when we
 * may be running in real mode or 16-bit protected mode, and therefore
 * cannot directly access arbitrary areas of memory using simple
 * pointers.
 *
 */

/**
 * A free block descriptor
 *
 * This is the data structure that is found at the start of a free
 * block within a data buffer.
 */
struct buffer_free_block {
	/** Starting offset of the free block */
	size_t start;
	/** Ending offset of the free block */
	size_t end;
	/** Offset of next free block */
	size_t next;
};

/**
 * Get next free block within the buffer
 *
 * @v buffer		Data buffer
 * @v block		Previous free block descriptor
 * @ret block		Next free block descriptor
 * @ret rc		Return status code
 *
 * Set @c block->next=buffer->free before first call to
 * get_next_free_block().
 */
static int get_next_free_block ( struct buffer *buffer,
				 struct buffer_free_block *block ) {

	/* Check for end of buffer */
	if ( block->end >= buffer->len )
		return -ENOENT;

	/* Move to next block */
	block->start = block->next;
	if ( block->start >= buffer->free ) {
		/* Final block; no in-band descriptor */
		block->end = buffer->len;
	} else {
		/* Retrieve block descriptor */
		copy_from_phys ( block, ( buffer->addr + block->start ),
				 sizeof ( *block ) );
	}

	return 0;
}

/**
 * Write free block descriptor back to buffer
 *
 * @v buffer		Data buffer
 * @v block		Free block descriptor
 */
static void store_free_block ( struct buffer *buffer,
			       struct buffer_free_block *block ) {
	size_t free_block_size = ( block->end - block->start );

	assert ( free_block_size >= sizeof ( *block ) );
	copy_to_phys ( ( buffer->addr + block->start ), block,
		       sizeof ( *block ) );
}

/**
 * Write data into a buffer
 *
 * @v buffer		Data buffer
 * @v data		Data to be written
 * @v offset		Offset within the buffer at which to write the data
 * @v len		Length of data to be written
 * @ret rc		Return status code
 *
 * Writes a block of data into the buffer.  The block need not be
 * aligned to any particular boundary, or be of any particular size,
 * and it may overlap blocks already in the buffer (i.e. duplicate
 * calls to fill_buffer() are explicitly permitted).
 *
 * @c buffer->fill will be updated to indicate the fill level of the
 * buffer, i.e. the offset to the first gap within the buffer.  If the
 * filesize is known (e.g. as with the SLAM protocol), you can test
 * for end-of-file by checking for @c buffer->fill==filesize.  If the
 * filesize is not known, but there is a well-defined end-of-file test
 * (e.g. as with the TFTP protocol), you can read @c buffer->fill to
 * determine the final filesize.  If blocks are known to be delivered
 * in a strictly sequential order with no packet loss or duplication,
 * then you can pass in @c offset==buffer->fill.
 *
 * @b NOTE: It is the caller's responsibility to ensure that the
 * boundaries between data blocks are more than @c sizeof(struct @c
 * buffer_free_block) apart.  If this condition is not satisfied, data
 * corruption will occur.
 *
 * In practice this is not a problem.  Callers of fill_buffer() will
 * be download protocols such as TFTP, and very few protocols have a
 * block size smaller than @c sizeof(struct @c buffer_free_block).
 *
 */
int fill_buffer ( struct buffer *buffer, const void *data,
		  size_t offset, size_t len ) {
	struct buffer_free_block block, before, after;
	size_t data_start = offset;
	size_t data_end = ( data_start + len );
	int rc;

	DBGC ( buffer, "BUFFER %p [%lx,%lx) filling portion [%lx,%lx)\n",
	       buffer, buffer->addr, ( buffer->addr + buffer->len ),
	       ( buffer->addr + data_start ), ( buffer->addr + data_end ) );

	/* Check that block fits within buffer, expand if necessary */
	if ( data_end > buffer->len ) {
		if ( ! buffer->expand ) {
			DBGC ( buffer, "BUFFER %p not expandable\n", buffer );
			return -ENOBUFS;
		}
		if ( ( rc = buffer->expand ( buffer, data_end ) ) != 0 ) {
			DBGC ( buffer, "BUFFER %p could not expand :%s\n",
			       buffer, strerror ( rc ) );
			return rc;
		}
		DBGC ( buffer, "BUFFER %p expanded to [%lx,%lx)\n", buffer,
		       buffer->addr, ( buffer->addr + buffer->len ) );
		assert ( buffer->len >= data_end );
	}

	/* Find 'before' and 'after' blocks, if any */
	before.start = before.end = 0;
	after.start = after.end = buffer->len;
	block.next = buffer->fill;
	while ( get_next_free_block ( buffer, &block ) == 0 ) {
		if ( ( block.start < data_start ) &&
		     ( block.start >= before.start ) )
			memcpy ( &before, &block, sizeof ( before ) );
		if ( ( block.end > data_end ) &&
		     ( block.end <= after.end ) )
			memcpy ( &after, &block, sizeof ( after ) );
	}

	/* Truncate 'before' and 'after' blocks around data. */
	if ( data_start < before.end )
		before.end = data_start;
	if ( data_end > after.start )
		after.start = data_end;

	/* Link 'after' block to 'before' block */
	before.next = after.start;

	DBGC ( buffer, "BUFFER %p split before [%lx,%lx) after [%lx,%lx)\n",
	       buffer, ( buffer->addr + before.start ),
	       ( buffer->addr + before.end ), ( buffer->addr + after.start ),
	       ( buffer->addr + after.end ) );

	/* Write back 'before' block, if any */
	if ( before.end == 0 ) {
		/* No 'before' block: update buffer->fill */
		buffer->fill = after.start;
		DBGC ( buffer, "BUFFER %p full up to %lx\n", buffer,
		       ( buffer->addr + buffer->fill ) );
	} else {
		/* Write back 'before' block */
		store_free_block ( buffer, &before );
	}

	/* Write back 'after' block */
	if ( after.end == buffer->len ) {
		/* 'After' block is the final block: update buffer->free */
		buffer->free = after.start;
		DBGC ( buffer, "BUFFER %p free from %lx onwards\n", buffer,
		       ( buffer->addr + buffer->free ) );
	} else {
		/* Write back 'after' block */
		store_free_block ( buffer, &after );
	}

	/* Copy data into buffer */
	copy_to_phys ( ( buffer->addr + data_start ), data, len );

	return 0;
}