From e2dcd05b67c606e97f1d570123ba7510cc41bd16 Mon Sep 17 00:00:00 2001 From: Michael Brown Date: Thu, 11 Jan 2007 03:50:47 +0000 Subject: [PATCH] Update buffer-handling code to enable expandable buffers. --- src/arch/i386/core/load_buffer.c | 69 -------- src/core/buffer.c | 270 +++++++++++++++---------------- src/core/image.c | 1 - src/include/gpxe/buffer.h | 97 +++++------ src/include/load_buffer.h | 39 ----- src/proto/slam.c | 2 +- 6 files changed, 187 insertions(+), 291 deletions(-) delete mode 100644 src/arch/i386/core/load_buffer.c delete mode 100644 src/include/load_buffer.h diff --git a/src/arch/i386/core/load_buffer.c b/src/arch/i386/core/load_buffer.c deleted file mode 100644 index 3e34d2b5..00000000 --- a/src/arch/i386/core/load_buffer.c +++ /dev/null @@ -1,69 +0,0 @@ -#include "io.h" -#include "load_buffer.h" - -/* - * Initialise a buffer in an unused portion of memory, to be used for - * loading an image - * - */ - -#ifdef KEEP_IT_REAL - -/* - * Under KEEP_IT_REAL, always use 07c0:0000 as the load buffer. - * - */ - -int init_load_buffer ( struct buffer *buffer ) { - buffer->start = 0x7c00; - buffer->end = 0xa0000; - DBG ( "LOAD_BUFFER using [%x,%x)\n", buffer->start, buffer->end ); - init_buffer ( buffer ); - return 1; -} - -void trim_load_buffer ( struct buffer *buffer ) { - /* Nothing to do */ -} - -void done_load_buffer ( struct buffer *buffer ) { - /* Nothing to do */ -} - -#else /* KEEP_IT_REAL */ - -/* - * Without KEEP_IT_REAL, use all remaining heap space as the load buffer. - * - */ -int init_load_buffer ( struct buffer *buffer ) { - void *data; - size_t size; - - data = emalloc_all ( &size ); - if ( ! data ) - return 0; - - buffer->start = virt_to_phys ( data ); - buffer->end = buffer->start + size; - DBG ( "LOAD_BUFFER using [%x,%x)\n", buffer->start, buffer->end ); - init_buffer ( buffer ); - return 1; -} - -void trim_load_buffer ( struct buffer *buffer ) { - void *new_start; - - /* Shrink buffer */ - new_start = erealloc ( phys_to_virt ( buffer->start ), buffer->fill ); - DBG ( "LOAD_BUFFER shrunk from [%x,%x) to [%x,%x)\n", buffer->start, - buffer->end, virt_to_phys ( new_start ), buffer->end ); - buffer->start = virt_to_phys ( new_start ); -} - -void done_load_buffer ( struct buffer *buffer ) { - efree ( phys_to_virt ( buffer->start ) ); - DBG ( "LOAD_BUFFER freed [%x,%x)\n", buffer->start, buffer->end ); -} - -#endif diff --git a/src/core/buffer.c b/src/core/buffer.c index 81288ff5..be4c6055 100644 --- a/src/core/buffer.c +++ b/src/core/buffer.c @@ -1,3 +1,27 @@ +/* + * Copyright (C) 2007 Michael Brown . + * + * 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 +#include +#include +#include +#include +#include /** @file * @@ -7,27 +31,22 @@ * which is "filled" and the remainder of which is "free". The * "filled" and "free" spaces are not necessarily contiguous. * - * When a buffer is initialised via init_buffer(), 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. + * 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 starts with a "tail byte". If the - * tail byte is non-zero, this indicates that the free block is the - * tail of the buffer, i.e. occupies all the remaining space up to the - * end of the buffer. When the tail byte is non-zero, it indicates - * that a descriptor (a @c struct @c buffer_free_block) follows the - * tail byte. The descriptor describes the size of the free block and - * the address of the next free block. - * - * We cannot simply always start a free block 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. Using a "tail byte" solves this problem. + * 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 @@ -38,107 +57,76 @@ * */ -#include "stddef.h" -#include "string.h" -#include "io.h" -#include "errno.h" -#include -#include +/** + * 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; +}; /** - * Initialise a buffer. + * Get next free block within the buffer * - * @v buffer The buffer to be initialised - * @ret None - - * @err None - - * - * Set @c buffer->start and @c buffer->end before calling init_buffer(). - * init_buffer() will initialise the buffer to the state of being - * empty. + * @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(). */ -void init_buffer ( struct buffer *buffer ) { - char tail = 1; +static int get_next_free_block ( struct buffer *buffer, + struct buffer_free_block *block ) { - buffer->fill = 0; - if ( buffer->end != buffer->start ) - copy_to_phys ( buffer->start, &tail, sizeof ( tail ) ); + /* Check for end of buffer */ + if ( block->end >= buffer->len ) + return -ENOENT; - DBG ( "BUFFER [%x,%x) initialised\n", buffer->start, buffer->end ); -} - -/** - * Move to the next block in the free list - * - * @v block The current free block - * @v buffer The buffer - * @ret True Successfully moved to the next free block - * @ret False There are no more free blocks - * @ret block The next free block - * @err None - - * - * Move to the next block in the free block list, filling in @c block - * with the descriptor for this next block. If the next block is the - * tail block, @c block will be filled with the values calculated for - * the tail block, otherwise the descriptor will be read from the free - * block itself. - * - * If there are no more free blocks, next_free_block() returns False - * and leaves @c block with invalid contents. - * - * Set block->next = buffer->start + buffer->fill for the - * first call to next_free_block(). - */ -static inline int next_free_block ( struct buffer_free_block *block, - struct buffer *buffer ) { /* Move to next block */ block->start = block->next; - - /* If at end of buffer, return 0 */ - if ( block->start >= buffer->end ) - return 0; - - /* Set up ->next and ->end as for a tail block */ - block->next = block->end = buffer->end; - - /* Read tail marker from block */ - copy_from_phys ( &block->tail, block->start, sizeof ( block->tail ) ); - - /* If not a tail block, read whole block descriptor from block */ - if ( ! block->tail ) { - copy_from_phys ( block, block->start, sizeof ( *block ) ); + 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 1; + return 0; } /** - * Store a free block descriptor + * Write free block descriptor back to buffer * - * @v block The free block descriptor to store - * @ret None - - * @err None - - * - * Writes a free block descriptor back to a free block. If the block - * is a tail block, only the tail marker will be written, otherwise - * the whole block descriptor will be written. + * @v buffer Data buffer + * @v block Free block descriptor */ -static inline void store_free_block ( struct buffer_free_block *block ) { - copy_to_phys ( block->start, block, - ( block->tail ? - sizeof ( block->tail ) : sizeof ( *block ) ) ); +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. + * Write data into a buffer * - * @v buffer The buffer into which to write the data - * @v data The data to be written + * @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 True Data was successfully written - * @ret False Data was not written - * @err ENOMEM Buffer is too small to contain the data + * @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, @@ -166,29 +154,37 @@ static inline void store_free_block ( struct buffer_free_block *block ) { * */ int fill_buffer ( struct buffer *buffer, const void *data, - off_t offset, size_t len ) { + size_t offset, size_t len ) { struct buffer_free_block block, before, after; - physaddr_t data_start, data_end; + size_t data_start = offset; + size_t data_end = ( data_start + len ); + int rc; - /* Calculate start and end addresses of data */ - data_start = buffer->start + offset; - data_end = data_start + len; - DBG ( "BUFFER [%x,%x) writing portion [%x,%x)\n", - buffer->start, buffer->end, data_start, data_end ); + 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 buffer bounds */ - if ( data_end > buffer->end ) { - DBG ( "BUFFER [%x,%x) too small for data!\n", - buffer->start, buffer->end ); - errno = ENOMEM; - return 0; + /* 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->end; - block.next = buffer->start + buffer->fill; - while ( next_free_block ( &block, buffer ) ) { + 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 ) ); @@ -206,33 +202,35 @@ int fill_buffer ( struct buffer *buffer, const void *data, /* 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.start ) { - before.tail = 0; - assert ( ( before.end - before.start ) >= - sizeof ( struct buffer_free_block ) ); - store_free_block ( &before ); + 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 { - buffer->fill = before.next - buffer->start; + /* Write back 'before' block */ + store_free_block ( buffer, &before ); } - /* Write back 'after' block, if any */ - if ( after.start < buffer->end ) { - assert ( after.tail || - ( ( after.end - after.start ) >= - sizeof ( struct buffer_free_block ) ) ); - store_free_block ( &after ); + /* 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 ); } - - DBG ( "BUFFER [%x,%x) before [%x,%x) after [%x,%x)\n", - buffer->start, buffer->end, before.start, before.end, - after.start, after.end ); - + /* Copy data into buffer */ - copy_to_phys ( data_start, data, len ); + copy_to_phys ( ( buffer->addr + data_start ), data, len ); - DBG ( "BUFFER [%x,%x) full up to %x\n", - buffer->start, buffer->end, buffer->start + buffer->fill ); - - return 1; + return 0; } diff --git a/src/core/image.c b/src/core/image.c index ccf7b95e..965af5aa 100644 --- a/src/core/image.c +++ b/src/core/image.c @@ -1,6 +1,5 @@ #include "dev.h" #include -#include "load_buffer.h" #include "image.h" #include diff --git a/src/include/gpxe/buffer.h b/src/include/gpxe/buffer.h index dba10b88..e35e0b53 100644 --- a/src/include/gpxe/buffer.h +++ b/src/include/gpxe/buffer.h @@ -1,8 +1,8 @@ #ifndef _GPXE_BUFFER_H #define _GPXE_BUFFER_H -#include "compiler.h" /* for doxygen */ -#include "stdint.h" +#include +#include /** @file * @@ -15,14 +15,8 @@ * Some protocols do not provide a mechanism for us to know the size * of the file before we happen to receive a particular block * (e.g. the final block in an MTFTP transfer). In addition, some - * protocols (all the multicast protocols plus any TCP-based protocol) - * can, in theory, provide the data in any order. - * - * Rather than requiring each protocol to implement its own equivalent - * of "dd" to arrange the data into well-sized pieces before handing - * off to the image loader, we provide these generic buffer functions - * which assemble a file into a single contiguous block. The whole - * block is then passed to the image loader. + * protocols (e.g. the multicast protocols) can, in theory, provide + * the data in any order. * * Example usage: * @@ -33,65 +27,78 @@ * off_t offset; * size_t len; * - * // We have an area of memory [buf_start,buf_end) into which we want - * // to load a file, where buf_start and buf_end are physical addresses. + * // We have an area of memory [buf_start,buf_start+len) into which to + * // load a file, where buf_start is a physical addresse. + * memset ( &buffer, 0, sizeof ( buffer ) ); * buffer->start = buf_start; - * buffer->end = buf_end; - * init_buffer ( &buffer ); + * buffer->len = len; * ... * while ( get_file_block ( ... ) ) { * // Downloaded block is stored in [data,data+len), and represents * // the portion of the file at offsets [offset,offset+len) - * if ( ! fill_buffer ( &buffer, data, offset, len ) ) { + * if ( fill_buffer ( &buffer, data, offset, len ) != 0 ) { * // An error occurred - * return 0; * } * ... * } * ... * // The whole file is now present at [buf_start,buf_start+filesize), * // where buf_start is a physical address. The struct buffer can simply - * // be discarded; there is no done_buffer() call. + * // be discarded. * * @endcode * - * For a description of the internal operation, see buffer.c. - * */ /** - * A buffer + * A data buffer * - * #start and #end denote the real boundaries of the buffer, and are - * physical addresses. #fill denotes the offset to the first free - * block in the buffer. (If the buffer is full, #fill will equal - * #end-#start.) + * A buffer looks something like this: + * + * @code + * + * XXXXXXXXXXXXXXXXX.........XXX..........XXXXXXX........XXXXXX......... + * + * ^ + * | + * start + * + * <----- fill ----> + * + * <------------------------ free ----------------------------> + * + * <------------------------------ len --------------------------------> + * + * @endcode + * + * #start and #len denote the real boundaries of the buffer. #fill + * denotes the offset to the first free block in the buffer. (If the + * buffer is full, #fill, #free and #len will all be equal.) * */ struct buffer { - physaddr_t start; /**< Start of buffer in memory */ - physaddr_t end; /**< End of buffer in memory */ - off_t fill; /**< Offset to first gap in buffer */ + /** Physical start address of buffer */ + physaddr_t addr; + /** Total length of buffer */ + size_t len; + /** Offset to first free block within buffer */ + size_t fill; + /** Offset to last free block within buffer */ + size_t free; + /** Expand data buffer + * + * @v buffer Data buffer + * @v new_len New length + * @ret rc Return status code + * + * Expand the data buffer to accommodate more data. This + * method is optional; if it is @c NULL then the buffer will + * not be expandable. + */ + int ( * expand ) ( struct buffer *buffer, size_t new_len ); }; -/** - * A free block descriptor. - * - * See buffer.c for a full description of the fields. - * - */ -struct buffer_free_block { - char tail; /**< Tail byte marker */ - char reserved[3]; /**< Padding */ - physaddr_t start; /**< Address of this free block */ - physaddr_t next; /**< Address of next free block */ - physaddr_t end; /**< End of this block */ -} __attribute__ (( packed )); - -/* Functions in buffer.c */ - -extern void init_buffer ( struct buffer *buffer ); extern int fill_buffer ( struct buffer *buffer, const void *data, - off_t offset, size_t len ); + size_t offset, size_t len ); #endif /* _GPXE_BUFFER_H */ diff --git a/src/include/load_buffer.h b/src/include/load_buffer.h deleted file mode 100644 index b13c4e2a..00000000 --- a/src/include/load_buffer.h +++ /dev/null @@ -1,39 +0,0 @@ -#ifndef LOAD_BUFFER_H -#define LOAD_BUFFER_H - -#include - -/* - * These functions are architecture-dependent, but the interface must - * be identical between architectures. - * - */ - -/* - * Initialise a buffer suitable for loading an image. Pass in a - * pointer to an uninitialised struct buffer. - * - * Note that this function may (for example) allocate all remaining - * allocatable memory, so it must be called *after* any other code - * that might want to allocate memory (e.g. device driver - * initialisation). - * - */ -extern int init_load_buffer ( struct buffer *buffer ); - -/* - * Cut a load buffer down to size once the image has been loaded. - * This will shrink the buffer down to the size of the data contained - * within the buffer, freeing up unused memory if applicable. - * - */ -extern void trim_load_buffer ( struct buffer *buffer ); - -/* - * Finish using a load buffer, once the image has been moved into its - * target location in memory. - * - */ -extern void done_load_buffer ( struct buffer *buffer ); - -#endif /* LOAD_BUFFER_H */ diff --git a/src/proto/slam.c b/src/proto/slam.c index c55bf307..171b6d24 100644 --- a/src/proto/slam.c +++ b/src/proto/slam.c @@ -314,7 +314,7 @@ static unsigned char *reinit_slam_state( return 0; } bitmap_len = (state.total_packets + 1 + 7)/8; - state.image = phys_to_virt ( state.buffer->start ); + state.image = phys_to_virt ( state.buffer->addr ); /* We don't use the buffer routines properly yet; fake it */ state.buffer->fill = total_bytes; state.bitmap = state.image + total_bytes;