/*- * Copyright (c) 2016 Landon Fuller <landonf@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer, * without modification. * 2. Redistributions in binary form must reproduce at minimum a disclaimer * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any * redistribution must be conditioned upon including a substantially * similar Disclaimer requirement for further binary redistribution. * * NO WARRANTY * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGES. */ #include <sys/cdefs.h> #ifdef _KERNEL #include <sys/param.h> #include <sys/malloc.h> #include <sys/systm.h> #else /* !_KERNEL */ #include <errno.h> #include <stdint.h> #include <stdlib.h> #include <string.h> #endif /* _KERNEL */ #include "bhnd_nvram_private.h" #include "bhnd_nvram_io.h" #include "bhnd_nvram_iovar.h" /** * Buffer-backed NVRAM I/O context. * * iobuf instances are gauranteed to provide persistent references to its * backing contigious buffer via bhnd_nvram_io_read_ptr() and * bhnd_nvram_io_write_ptr(). */ struct bhnd_nvram_iobuf { struct bhnd_nvram_io io; /**< common I/O instance state */ void *buf; /**< backing buffer. if inline-allocated, will be a reference to data[]. */ size_t size; /**< size of @p buf */ size_t capacity; /**< capacity of @p buf */ uint8_t data[]; /**< inline buffer allocation */ }; BHND_NVRAM_IOPS_DEFN(iobuf) /** * Allocate and return a new I/O context with an uninitialized * buffer of @p size and @p capacity. * * The caller is responsible for deallocating the returned I/O context via * bhnd_nvram_io_free(). * * If @p capacity is less than @p size, a capacity of @p size will be used. * * @param size The initial size of the I/O context. * @param capacity The total capacity of the I/O context buffer; * the returned I/O context may be resized up to * @p capacity via bhnd_nvram_io_setsize(). * * @retval bhnd_nvram_iobuf success. * @retval NULL allocation failed. * @retval NULL the requested @p capacity is less than * @p size. */ struct bhnd_nvram_io * bhnd_nvram_iobuf_empty(size_t size, size_t capacity) { struct bhnd_nvram_iobuf *iobuf; size_t iosz; bool inline_alloc; /* Sanity check the capacity */ if (size > capacity) return (NULL); /* Would sizeof(iobuf)+capacity overflow? */ if (SIZE_MAX - sizeof(*iobuf) < capacity) { inline_alloc = false; iosz = sizeof(*iobuf); } else { inline_alloc = true; iosz = sizeof(*iobuf) + capacity; } /* Allocate I/O context */ iobuf = bhnd_nv_malloc(iosz); if (iobuf == NULL) return (NULL); iobuf->io.iops = &bhnd_nvram_iobuf_ops; iobuf->buf = NULL; iobuf->size = size; iobuf->capacity = capacity; /* Either allocate our backing buffer, or initialize the * backing buffer with a reference to our inline allocation. */ if (inline_alloc) iobuf->buf = &iobuf->data; else iobuf->buf = bhnd_nv_malloc(iobuf->capacity); if (iobuf->buf == NULL) { bhnd_nv_free(iobuf); return (NULL); } return (&iobuf->io); } /** * Allocate and return a new I/O context, copying @p size from @p buffer. * * The caller is responsible for deallocating the returned I/O context via * bhnd_nvram_io_free(). * * @param buffer The buffer data be copied by the returned I/O context. * @param size The size of @p buffer, in bytes. * * @retval bhnd_nvram_io success. * @retval NULL allocation failed. */ struct bhnd_nvram_io * bhnd_nvram_iobuf_new(const void *buffer, size_t size) { struct bhnd_nvram_io *io; struct bhnd_nvram_iobuf *iobuf; /* Allocate the iobuf */ if ((io = bhnd_nvram_iobuf_empty(size, size)) == NULL) return (NULL); /* Copy the input to our new iobuf instance */ iobuf = (struct bhnd_nvram_iobuf *)io; memcpy(iobuf->buf, buffer, iobuf->size); return (io); } /** * Allocate and return a new I/O context providing an in-memory copy * of the data mapped by @p src. * * The caller is responsible for deallocating the returned I/O context via * bhnd_nvram_io_free(). * * @param src The I/O context to be copied. * * @retval bhnd_nvram_io success. * @retval NULL allocation failed. * @retval NULL copying @p src failed. */ struct bhnd_nvram_io * bhnd_nvram_iobuf_copy(struct bhnd_nvram_io *src) { return (bhnd_nvram_iobuf_copy_range(src, 0x0, bhnd_nvram_io_getsize(src))); } /** * Allocate and return a new I/O context providing an in-memory copy * of @p size bytes mapped at @p offset by @p src. * * The caller is responsible for deallocating the returned I/O context via * bhnd_nvram_io_free(). * * @param src The I/O context to be copied. * @param offset The offset of the bytes to be copied from @p src. * @param size The number of bytes to copy at @p offset from @p src. * * @retval bhnd_nvram_io success. * @retval NULL allocation failed. * @retval NULL copying @p src failed. */ struct bhnd_nvram_io * bhnd_nvram_iobuf_copy_range(struct bhnd_nvram_io *src, size_t offset, size_t size) { struct bhnd_nvram_io *io; struct bhnd_nvram_iobuf *iobuf; int error; /* Check if offset+size would overflow */ if (SIZE_MAX - size < offset) return (NULL); /* Allocate the iobuf instance */ if ((io = bhnd_nvram_iobuf_empty(size, size)) == NULL) return (NULL); /* Copy the input I/O context */ iobuf = (struct bhnd_nvram_iobuf *)io; if ((error = bhnd_nvram_io_read(src, offset, iobuf->buf, size))) { bhnd_nvram_io_free(&iobuf->io); return (NULL); } return (io); } static void bhnd_nvram_iobuf_free(struct bhnd_nvram_io *io) { struct bhnd_nvram_iobuf *iobuf = (struct bhnd_nvram_iobuf *)io; /* Free the backing buffer if it wasn't allocated inline */ if (iobuf->buf != &iobuf->data) bhnd_nv_free(iobuf->buf); bhnd_nv_free(iobuf); } static size_t bhnd_nvram_iobuf_getsize(struct bhnd_nvram_io *io) { struct bhnd_nvram_iobuf *iobuf = (struct bhnd_nvram_iobuf *)io; return (iobuf->size); } static int bhnd_nvram_iobuf_setsize(struct bhnd_nvram_io *io, size_t size) { struct bhnd_nvram_iobuf *iobuf = (struct bhnd_nvram_iobuf *)io; /* Can't exceed the actual capacity */ if (size > iobuf->capacity) return (ENXIO); iobuf->size = size; return (0); } /* Common iobuf_(read|write)_ptr implementation */ static int bhnd_nvram_iobuf_ptr(struct bhnd_nvram_iobuf *iobuf, size_t offset, void **ptr, size_t nbytes, size_t *navail) { size_t avail; /* Verify offset+nbytes fall within the buffer range */ if (offset > iobuf->size) return (ENXIO); avail = iobuf->size - offset; if (avail < nbytes) return (ENXIO); /* Valid I/O range, provide a pointer to the buffer and the * total count of available bytes */ *ptr = ((uint8_t *)iobuf->buf) + offset; if (navail != NULL) *navail = avail; return (0); } static int bhnd_nvram_iobuf_read_ptr(struct bhnd_nvram_io *io, size_t offset, const void **ptr, size_t nbytes, size_t *navail) { struct bhnd_nvram_iobuf *iobuf; void *ioptr; int error; iobuf = (struct bhnd_nvram_iobuf *) io; /* Return a pointer into our backing buffer */ error = bhnd_nvram_iobuf_ptr(iobuf, offset, &ioptr, nbytes, navail); if (error) return (error); *ptr = ioptr; return (0); } static int bhnd_nvram_iobuf_write_ptr(struct bhnd_nvram_io *io, size_t offset, void **ptr, size_t nbytes, size_t *navail) { struct bhnd_nvram_iobuf *iobuf; iobuf = (struct bhnd_nvram_iobuf *) io; /* Return a pointer into our backing buffer */ return (bhnd_nvram_iobuf_ptr(iobuf, offset, ptr, nbytes, navail)); } static int bhnd_nvram_iobuf_read(struct bhnd_nvram_io *io, size_t offset, void *buffer, size_t nbytes) { const void *ptr; int error; /* Try to fetch a direct pointer for at least nbytes */ if ((error = bhnd_nvram_io_read_ptr(io, offset, &ptr, nbytes, NULL))) return (error); /* Copy out the requested data */ memcpy(buffer, ptr, nbytes); return (0); } static int bhnd_nvram_iobuf_write(struct bhnd_nvram_io *io, size_t offset, void *buffer, size_t nbytes) { void *ptr; int error; /* Try to fetch a direct pointer for at least nbytes */ if ((error = bhnd_nvram_io_write_ptr(io, offset, &ptr, nbytes, NULL))) return (error); /* Copy in the provided data */ memcpy(ptr, buffer, nbytes); return (0); }
