FreeBSD/Linux Kernel Cross Reference
sys/dev/bhnd/nvram/bhnd_nvram_iobuf.c

     /*-
      * 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>
    __FBSDID("$FreeBSD$");
    
    #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);
   }

Cache object: f93f115ce8f8790ccf974c9556c07f03