src/core/xferbuf.c - ipxe - Git at Google

 /*
  * Copyright (C) 2012 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 (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  *
  * You can also choose to distribute this program under the terms of
  * the Unmodified Binary Distribution Licence (as given in the file
  * COPYING.UBDL), provided that you have satisfied its requirements.
  */

 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <ipxe/xfer.h>
 #include <ipxe/iobuf.h>
 #include <ipxe/umalloc.h>
 #include <ipxe/profile.h>
 #include <ipxe/xferbuf.h>

 /** @file
  *
  * Data transfer buffer
  *
  */

 /** Data delivery profiler */
 static struct profiler xferbuf_deliver_profiler __profiler =
 	{ .name = "xferbuf.deliver" };

 /** Data write profiler */
 static struct profiler xferbuf_write_profiler __profiler =
 	{ .name = "xferbuf.write" };

 /** Data read profiler */
 static struct profiler xferbuf_read_profiler __profiler =
 	{ .name = "xferbuf.read" };

 /**
  * Free data transfer buffer
  *
  * @v xferbuf		Data transfer buffer
  */
 void xferbuf_free ( struct xfer_buffer *xferbuf ) {

 	xferbuf->op->realloc ( xferbuf, 0 );
 	xferbuf->len = 0;
 	xferbuf->pos = 0;
 }

 /**
  * Ensure that data transfer buffer is large enough for the specified size
  *
  * @v xferbuf		Data transfer buffer
  * @v len		Required minimum size
  * @ret rc		Return status code
  */
 static int xferbuf_ensure_size ( struct xfer_buffer *xferbuf, size_t len ) {
 	int rc;

 	/* If buffer is already large enough, do nothing */
 	if ( len <= xferbuf->len )
 		return 0;

 	/* Extend buffer */
 	if ( ( rc = xferbuf->op->realloc ( xferbuf, len ) ) != 0 ) {
 		DBGC ( xferbuf, "XFERBUF %p could not extend buffer to "
 		       "%zd bytes: %s\n", xferbuf, len, strerror ( rc ) );
 		return rc;
 	}
 	xferbuf->len = len;

 	return 0;
 }

 /**
  * Write to data transfer buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v offset		Starting offset
  * @v data		Data to write
  * @v len		Length of data
  */
 int xferbuf_write ( struct xfer_buffer *xferbuf, size_t offset,
 		    const void *data, size_t len ) {
 	size_t max_len;
 	int rc;

 	/* Check for overflow */
 	max_len = ( offset + len );
 	if ( max_len < offset )
 		return -EOVERFLOW;

 	/* Ensure buffer is large enough to contain this write */
 	if ( ( rc = xferbuf_ensure_size ( xferbuf, max_len ) ) != 0 )
 		return rc;

 	/* Copy data to buffer */
 	profile_start ( &xferbuf_write_profiler );
 	xferbuf->op->write ( xferbuf, offset, data, len );
 	profile_stop ( &xferbuf_write_profiler );

 	return 0;
 }

 /**
  * Read from data transfer buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v offset		Starting offset
  * @v data		Data to write
  * @v len		Length of data
  */
 int xferbuf_read ( struct xfer_buffer *xferbuf, size_t offset,
 		   void *data, size_t len ) {

 	/* Check that read is within buffer range */
 	if ( ( offset > xferbuf->len ) ||
 	     ( len > ( xferbuf->len - offset ) ) )
 		return -ENOENT;

 	/* Copy data from buffer */
 	profile_start ( &xferbuf_read_profiler );
 	xferbuf->op->read ( xferbuf, offset, data, len );
 	profile_stop ( &xferbuf_read_profiler );

 	return 0;
 }

 /**
  * Add received data to data transfer buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v iobuf		I/O buffer
  * @v meta		Data transfer metadata
  * @ret rc		Return status code
  */
 int xferbuf_deliver ( struct xfer_buffer *xferbuf, struct io_buffer *iobuf,
 		      struct xfer_metadata *meta ) {
 	size_t len = iob_len ( iobuf );
 	size_t pos;
 	int rc;

 	/* Start profiling */
 	profile_start ( &xferbuf_deliver_profiler );

 	/* Calculate new buffer position */
 	pos = xferbuf->pos;
 	if ( meta->flags & XFER_FL_ABS_OFFSET )
 		pos = 0;
 	pos += meta->offset;

 	/* Write data to buffer */
 	if ( ( rc = xferbuf_write ( xferbuf, pos, iobuf->data, len ) ) != 0 )
 		goto done;

 	/* Update current buffer position */
 	xferbuf->pos = ( pos + len );

  done:
 	free_iob ( iobuf );
 	profile_stop ( &xferbuf_deliver_profiler );
 	return rc;
 }

 /**
  * Reallocate malloc()-based data buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v len		New length (or zero to free buffer)
  * @ret rc		Return status code
  */
 static int xferbuf_malloc_realloc ( struct xfer_buffer *xferbuf, size_t len ) {
 	void *new_data;

 	new_data = realloc ( xferbuf->data, len );
 	if ( ! new_data )
 		return -ENOSPC;
 	xferbuf->data = new_data;
 	return 0;
 }

 /**
  * Write data to malloc()-based data buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v offset		Starting offset
  * @v data		Data to copy
  * @v len		Length of data
  */
 static void xferbuf_malloc_write ( struct xfer_buffer *xferbuf, size_t offset,
 				   const void *data, size_t len ) {

 	memcpy ( ( xferbuf->data + offset ), data, len );
 }

 /**
  * Read data from malloc()-based data buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v offset		Starting offset
  * @v data		Data to read
  * @v len		Length of data
  */
 static void xferbuf_malloc_read ( struct xfer_buffer *xferbuf, size_t offset,
 				  void *data, size_t len ) {

 	memcpy ( data, ( xferbuf->data + offset ), len );
 }

 /** malloc()-based data buffer operations */
 struct xfer_buffer_operations xferbuf_malloc_operations = {
 	.realloc = xferbuf_malloc_realloc,
 	.write = xferbuf_malloc_write,
 	.read = xferbuf_malloc_read,
 };

 /**
  * Reallocate umalloc()-based data buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v len		New length (or zero to free buffer)
  * @ret rc		Return status code
  */
 static int xferbuf_umalloc_realloc ( struct xfer_buffer *xferbuf, size_t len ) {
 	userptr_t *udata = xferbuf->data;
 	userptr_t new_udata;

 	new_udata = urealloc ( *udata, len );
 	if ( ! new_udata )
 		return -ENOSPC;
 	*udata = new_udata;
 	return 0;
 }

 /**
  * Write data to umalloc()-based data buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v offset		Starting offset
  * @v data		Data to copy
  * @v len		Length of data
  */
 static void xferbuf_umalloc_write ( struct xfer_buffer *xferbuf, size_t offset,
 				    const void *data, size_t len ) {
 	userptr_t *udata = xferbuf->data;

 	copy_to_user ( *udata, offset, data, len );
 }

 /**
  * Read data from umalloc()-based data buffer
  *
  * @v xferbuf		Data transfer buffer
  * @v offset		Starting offset
  * @v data		Data to read
  * @v len		Length of data
  */
 static void xferbuf_umalloc_read ( struct xfer_buffer *xferbuf, size_t offset,
 				   void *data, size_t len ) {
 	userptr_t *udata = xferbuf->data;

 	copy_from_user ( data, *udata, offset, len );
 }

 /** umalloc()-based data buffer operations */
 struct xfer_buffer_operations xferbuf_umalloc_operations = {
 	.realloc = xferbuf_umalloc_realloc,
 	.write = xferbuf_umalloc_write,
 	.read = xferbuf_umalloc_read,
 };

 /**
  * Get underlying data transfer buffer
  *
  * @v interface		Data transfer interface
  * @ret xferbuf		Data transfer buffer, or NULL on error
  *
  * This call will check that the xfer_buffer() handler belongs to the
  * destination interface which also provides xfer_deliver() for this
  * interface.
  *
  * This is done to prevent accidental accesses to a data transfer
  * buffer which may be located behind a non-transparent datapath via a
  * series of pass-through interfaces.
  */
 struct xfer_buffer * xfer_buffer ( struct interface *intf ) {
 	struct interface *dest;
 	xfer_buffer_TYPE ( void * ) *op =
 		intf_get_dest_op ( intf, xfer_buffer, &dest );
 	void *object = intf_object ( dest );
 	struct interface *xfer_deliver_dest;
 	struct xfer_buffer *xferbuf;

 	/* Check that this operation is provided by the same interface
 	 * which handles xfer_deliver().
 	 */
 	( void ) intf_get_dest_op ( intf, xfer_deliver, &xfer_deliver_dest );

 	if ( op && ( dest == xfer_deliver_dest ) ) {
 		xferbuf = op ( object );
 	} else {
 		/* Default is to not have a data transfer buffer */
 		xferbuf = NULL;
 	}

 	intf_put ( xfer_deliver_dest );
 	intf_put ( dest );
 	return xferbuf;
 }
	/*
	* Copyright (C) 2012 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 (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA
	* 02110-1301, USA.
	*
	* You can also choose to distribute this program under the terms of
	* the Unmodified Binary Distribution Licence (as given in the file
	* COPYING.UBDL), provided that you have satisfied its requirements.
	*/

	FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>
	#include <ipxe/xfer.h>
	#include <ipxe/iobuf.h>
	#include <ipxe/umalloc.h>
	#include <ipxe/profile.h>
	#include <ipxe/xferbuf.h>

	/** @file
	*
	* Data transfer buffer
	*
	*/

	/** Data delivery profiler */
	static struct profiler xferbuf_deliver_profiler __profiler =
	{ .name = "xferbuf.deliver" };

	/** Data write profiler */
	static struct profiler xferbuf_write_profiler __profiler =
	{ .name = "xferbuf.write" };

	/** Data read profiler */
	static struct profiler xferbuf_read_profiler __profiler =
	{ .name = "xferbuf.read" };

	/**
	* Free data transfer buffer
	*
	* @v xferbuf Data transfer buffer
	*/
	void xferbuf_free ( struct xfer_buffer *xferbuf ) {

	xferbuf->op->realloc ( xferbuf, 0 );
	xferbuf->len = 0;
	xferbuf->pos = 0;
	}

	/**
	* Ensure that data transfer buffer is large enough for the specified size
	*
	* @v xferbuf Data transfer buffer
	* @v len Required minimum size
	* @ret rc Return status code
	*/
	static int xferbuf_ensure_size ( struct xfer_buffer *xferbuf, size_t len ) {
	int rc;

	/* If buffer is already large enough, do nothing */
	if ( len <= xferbuf->len )
	return 0;

	/* Extend buffer */
	if ( ( rc = xferbuf->op->realloc ( xferbuf, len ) ) != 0 ) {
	DBGC ( xferbuf, "XFERBUF %p could not extend buffer to "
	"%zd bytes: %s\n", xferbuf, len, strerror ( rc ) );
	return rc;
	}
	xferbuf->len = len;

	return 0;
	}

	/**
	* Write to data transfer buffer
	*
	* @v xferbuf Data transfer buffer
	* @v offset Starting offset
	* @v data Data to write
	* @v len Length of data
	*/
	int xferbuf_write ( struct xfer_buffer *xferbuf, size_t offset,
	const void *data, size_t len ) {
	size_t max_len;
	int rc;

	/* Check for overflow */
	max_len = ( offset + len );
	if ( max_len < offset )
	return -EOVERFLOW;

	/* Ensure buffer is large enough to contain this write */
	if ( ( rc = xferbuf_ensure_size ( xferbuf, max_len ) ) != 0 )
	return rc;

	/* Copy data to buffer */
	profile_start ( &xferbuf_write_profiler );
	xferbuf->op->write ( xferbuf, offset, data, len );
	profile_stop ( &xferbuf_write_profiler );

	return 0;
	}

	/**
	* Read from data transfer buffer
	*
	* @v xferbuf Data transfer buffer
	* @v offset Starting offset
	* @v data Data to write
	* @v len Length of data
	*/
	int xferbuf_read ( struct xfer_buffer *xferbuf, size_t offset,
	void *data, size_t len ) {

	/* Check that read is within buffer range */
	if ( ( offset > xferbuf->len ) \|\|
	( len > ( xferbuf->len - offset ) ) )
	return -ENOENT;

	/* Copy data from buffer */
	profile_start ( &xferbuf_read_profiler );
	xferbuf->op->read ( xferbuf, offset, data, len );
	profile_stop ( &xferbuf_read_profiler );

	return 0;
	}

	/**
	* Add received data to data transfer buffer
	*
	* @v xferbuf Data transfer buffer
	* @v iobuf I/O buffer
	* @v meta Data transfer metadata
	* @ret rc Return status code
	*/
	int xferbuf_deliver ( struct xfer_buffer xferbuf, struct io_buffer iobuf,
	struct xfer_metadata *meta ) {
	size_t len = iob_len ( iobuf );
	size_t pos;
	int rc;

	/* Start profiling */
	profile_start ( &xferbuf_deliver_profiler );

	/* Calculate new buffer position */
	pos = xferbuf->pos;
	if ( meta->flags & XFER_FL_ABS_OFFSET )
	pos = 0;
	pos += meta->offset;

	/* Write data to buffer */
	if ( ( rc = xferbuf_write ( xferbuf, pos, iobuf->data, len ) ) != 0 )
	goto done;

	/* Update current buffer position */
	xferbuf->pos = ( pos + len );

	done:
	free_iob ( iobuf );
	profile_stop ( &xferbuf_deliver_profiler );
	return rc;
	}

	/**
	* Reallocate malloc()-based data buffer
	*
	* @v xferbuf Data transfer buffer
	* @v len New length (or zero to free buffer)
	* @ret rc Return status code
	*/
	static int xferbuf_malloc_realloc ( struct xfer_buffer *xferbuf, size_t len ) {
	void *new_data;

	new_data = realloc ( xferbuf->data, len );
	if ( ! new_data )
	return -ENOSPC;
	xferbuf->data = new_data;
	return 0;
	}

	/**
	* Write data to malloc()-based data buffer
	*
	* @v xferbuf Data transfer buffer
	* @v offset Starting offset
	* @v data Data to copy
	* @v len Length of data
	*/
	static void xferbuf_malloc_write ( struct xfer_buffer *xferbuf, size_t offset,
	const void *data, size_t len ) {

	memcpy ( ( xferbuf->data + offset ), data, len );
	}

	/**
	* Read data from malloc()-based data buffer
	*
	* @v xferbuf Data transfer buffer
	* @v offset Starting offset
	* @v data Data to read
	* @v len Length of data
	*/
	static void xferbuf_malloc_read ( struct xfer_buffer *xferbuf, size_t offset,
	void *data, size_t len ) {

	memcpy ( data, ( xferbuf->data + offset ), len );
	}

	/** malloc()-based data buffer operations */
	struct xfer_buffer_operations xferbuf_malloc_operations = {
	.realloc = xferbuf_malloc_realloc,
	.write = xferbuf_malloc_write,
	.read = xferbuf_malloc_read,
	};

	/**
	* Reallocate umalloc()-based data buffer
	*
	* @v xferbuf Data transfer buffer
	* @v len New length (or zero to free buffer)
	* @ret rc Return status code
	*/
	static int xferbuf_umalloc_realloc ( struct xfer_buffer *xferbuf, size_t len ) {
	userptr_t *udata = xferbuf->data;
	userptr_t new_udata;

	new_udata = urealloc ( *udata, len );
	if ( ! new_udata )
	return -ENOSPC;
	*udata = new_udata;
	return 0;
	}

	/**
	* Write data to umalloc()-based data buffer
	*
	* @v xferbuf Data transfer buffer
	* @v offset Starting offset
	* @v data Data to copy
	* @v len Length of data
	*/
	static void xferbuf_umalloc_write ( struct xfer_buffer *xferbuf, size_t offset,
	const void *data, size_t len ) {
	userptr_t *udata = xferbuf->data;

	copy_to_user ( *udata, offset, data, len );
	}

	/**
	* Read data from umalloc()-based data buffer
	*
	* @v xferbuf Data transfer buffer
	* @v offset Starting offset
	* @v data Data to read
	* @v len Length of data
	*/
	static void xferbuf_umalloc_read ( struct xfer_buffer *xferbuf, size_t offset,
	void *data, size_t len ) {
	userptr_t *udata = xferbuf->data;

	copy_from_user ( data, *udata, offset, len );
	}

	/** umalloc()-based data buffer operations */
	struct xfer_buffer_operations xferbuf_umalloc_operations = {
	.realloc = xferbuf_umalloc_realloc,
	.write = xferbuf_umalloc_write,
	.read = xferbuf_umalloc_read,
	};

	/**
	* Get underlying data transfer buffer
	*
	* @v interface Data transfer interface
	* @ret xferbuf Data transfer buffer, or NULL on error
	*
	* This call will check that the xfer_buffer() handler belongs to the
	* destination interface which also provides xfer_deliver() for this
	* interface.
	*
	* This is done to prevent accidental accesses to a data transfer
	* buffer which may be located behind a non-transparent datapath via a
	* series of pass-through interfaces.
	*/
	struct xfer_buffer * xfer_buffer ( struct interface *intf ) {
	struct interface *dest;
	xfer_buffer_TYPE ( void * ) *op =
	intf_get_dest_op ( intf, xfer_buffer, &dest );
	void *object = intf_object ( dest );
	struct interface *xfer_deliver_dest;
	struct xfer_buffer *xferbuf;

	/* Check that this operation is provided by the same interface
	* which handles xfer_deliver().
	*/
	( void ) intf_get_dest_op ( intf, xfer_deliver, &xfer_deliver_dest );

	if ( op && ( dest == xfer_deliver_dest ) ) {
	xferbuf = op ( object );
	} else {
	/* Default is to not have a data transfer buffer */
	xferbuf = NULL;
	}

	intf_put ( xfer_deliver_dest );
	intf_put ( dest );
	return xferbuf;
	}