LXR 6.1/​cpukit/​libblock/​src/​sparse-disk.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:15

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /**
  * @file
  *
  * @ingroup rtems_sparse_disk
  *
  * @brief Sparse disk block device implementation.
  */
 
 /*
  * Copyright (c) 2012 embedded brains GmbH & Co. KG
  *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * 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 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 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 DAMAGE.
  */
 
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 
 #include <rtems.h>
 #include <rtems/blkdev.h>
 #include <rtems/fatal.h>
 
 #include "rtems/sparse-disk.h"
 
 /*
  * Allocate RAM for sparse disk
  */
 static rtems_sparse_disk *sparse_disk_allocate(
   const uint32_t          media_block_size,
   const rtems_blkdev_bnum blocks_with_buffer )
 {
   size_t const key_table_size = blocks_with_buffer
                                 * sizeof( rtems_sparse_disk_key );
   size_t const data_size      = blocks_with_buffer * media_block_size;
   size_t const alloc_size     = sizeof( rtems_sparse_disk )
                                 + key_table_size + data_size;
 
   rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
     alloc_size );
 
   return sd;
 }
 
 /*
  * Initialize sparse disk data
  */
 static rtems_status_code sparse_disk_initialize( rtems_sparse_disk *sd,
   const uint32_t                                                    media_block_size,
   const rtems_blkdev_bnum                                           blocks_with_buffer,
   const rtems_sparse_disk_delete_handler                            sparse_disk_delete,
   const uint8_t                                                     fill_pattern )
 {
   rtems_blkdev_bnum i;
 
   if ( NULL == sd )
     return RTEMS_INVALID_ADDRESS;
 
   uint8_t     *data           = (uint8_t *) sd;
   size_t const key_table_size = blocks_with_buffer
                                 * sizeof( rtems_sparse_disk_key );
   size_t const data_size      = blocks_with_buffer * media_block_size;
 
   memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
 
   sd->fill_pattern = fill_pattern;
   memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
           sd->fill_pattern,
           data_size );
 
   sd->delete_handler = sparse_disk_delete;
 
   rtems_mutex_init( &sd->mutex, "Sparse Disk" );
 
   data                  += sizeof( rtems_sparse_disk );
 
   sd->blocks_with_buffer = blocks_with_buffer;
   sd->key_table          = (rtems_sparse_disk_key *) data;
 
   data                  += key_table_size;
 
   for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
     sd->key_table[i].data = data;
   }
 
   sd->media_block_size = media_block_size;
   return RTEMS_SUCCESSFUL;
 }
 
 /*
  * Block comparison
  */
 static int sparse_disk_compare( const void *aa, const void *bb )
 {
   const rtems_sparse_disk_key *a = aa;
   const rtems_sparse_disk_key *b = bb;
 
   if ( a->block < b->block ) {
     return -1;
   } else if ( a->block == b->block ) {
     return 0;
   } else {
     return 1;
   }
 }
 
 static rtems_sparse_disk_key *sparse_disk_find_block(
   const rtems_sparse_disk *sparse_disk,
   rtems_blkdev_bnum        block
 )
 {
   rtems_sparse_disk_key key = { .block = block };
 
   return bsearch(
     &key,
     sparse_disk->key_table,
     sparse_disk->used_count,
     sizeof( rtems_sparse_disk_key ),
     sparse_disk_compare
   );
 }
 
 static rtems_sparse_disk_key *sparse_disk_get_new_block(
   rtems_sparse_disk      *sparse_disk,
   const rtems_blkdev_bnum block
 )
 {
   rtems_sparse_disk_key *key;
 
   if ( sparse_disk->used_count >= sparse_disk->blocks_with_buffer ) {
     return NULL;
   }
 
   key = &sparse_disk->key_table[ sparse_disk->used_count ];
   key->block = block;
   ++sparse_disk->used_count;
   qsort(
     sparse_disk->key_table,
     sparse_disk->used_count,
     sizeof( rtems_sparse_disk_key ),
     sparse_disk_compare
   );
   return sparse_disk_find_block( sparse_disk, block );
 }
 
 static int sparse_disk_read_block(
   const rtems_sparse_disk *sparse_disk,
   const rtems_blkdev_bnum  block,
   uint8_t                 *buffer,
   const size_t             buffer_size )
 {
   size_t                 bytes_to_copy = sparse_disk->media_block_size;
   rtems_sparse_disk_key *key;
 
   if ( buffer_size < bytes_to_copy )
     bytes_to_copy = buffer_size;
 
   key = sparse_disk_find_block( sparse_disk, block );
 
   if ( NULL != key )
     memcpy( buffer, key->data, bytes_to_copy );
   else
     memset( buffer, sparse_disk->fill_pattern, buffer_size );
 
   return bytes_to_copy;
 }
 
 static int sparse_disk_write_block(
   rtems_sparse_disk      *sparse_disk,
   const rtems_blkdev_bnum block,
   const uint8_t          *buffer,
   const size_t            buffer_size )
 {
   size_t                 bytes_to_copy = sparse_disk->media_block_size;
   bool                   block_needs_writing = false;
   rtems_sparse_disk_key *key;
   size_t                 i;
 
   if ( buffer_size < bytes_to_copy )
     bytes_to_copy = buffer_size;
 
   /* we only need to write the block if it is different from the fill pattern.
    * If the read method does not find a block it will deliver the fill pattern anyway.
    */
 
   key = sparse_disk_find_block( sparse_disk, block );
 
   if ( NULL == key ) {
     for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
       if ( buffer[i] != sparse_disk->fill_pattern )
         block_needs_writing = true;
     }
 
     if ( block_needs_writing ) {
       key = sparse_disk_get_new_block( sparse_disk, block );
     }
   }
 
   if ( NULL != key )
     memcpy( key->data, buffer, bytes_to_copy );
   else if ( block_needs_writing )
     return -1;
 
   return bytes_to_copy;
 }
 
 /*
  * Read/write handling
  */
 static int sparse_disk_read_write(
   rtems_sparse_disk    *sparse_disk,
   rtems_blkdev_request *req,
   const bool            read )
 {
   int                     rv = 0;
   uint32_t                req_buffer;
   rtems_blkdev_sg_buffer *scatter_gather;
   rtems_blkdev_bnum       block;
   uint8_t                *buff;
   size_t                  buff_size;
   unsigned int            bytes_handled;
 
   rtems_mutex_lock( &sparse_disk->mutex );
 
   for ( req_buffer = 0;
         ( 0 <= rv ) && ( req_buffer < req->bufnum );
         ++req_buffer ) {
     scatter_gather = &req->bufs[req_buffer];
 
     bytes_handled  = 0;
     buff           = (uint8_t *) scatter_gather->buffer;
     block          = scatter_gather->block;
     buff_size      = scatter_gather->length;
 
     while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
       if ( read )
         rv = sparse_disk_read_block( sparse_disk,
                                      block,
                                      &buff[bytes_handled],
                                      buff_size );
       else
         rv = sparse_disk_write_block( sparse_disk,
                                       block,
                                       &buff[bytes_handled],
                                       buff_size );
 
       ++block;
       bytes_handled += rv;
       buff_size     -= rv;
     }
   }
 
   rtems_mutex_unlock( &sparse_disk->mutex );
 
   if ( 0 > rv )
     rtems_blkdev_request_done( req, RTEMS_IO_ERROR );
   else
     rtems_blkdev_request_done( req, RTEMS_SUCCESSFUL );
 
   return 0;
 }
 
 /*
  * ioctl handler to be passed to the block device handler
  */
 static int sparse_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp )
 {
   rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
 
   if ( RTEMS_BLKIO_REQUEST == req ) {
     rtems_blkdev_request *r = argp;
 
     switch ( r->req ) {
       case RTEMS_BLKDEV_REQ_READ:
       case RTEMS_BLKDEV_REQ_WRITE:
         return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
       default:
         break;
     }
   } else if ( RTEMS_BLKIO_DELETED == req ) {
     rtems_mutex_destroy( &sd->mutex );
 
     if ( NULL != sd->delete_handler )
       ( *sd->delete_handler )( sd );
 
     return 0;
   } else {
     return rtems_blkdev_ioctl( dd, req, argp );
   }
 
   errno = EINVAL;
   return -1;
 }
 
 void rtems_sparse_disk_free( rtems_sparse_disk *sd )
 {
   free( sd );
 }
 
 rtems_status_code rtems_sparse_disk_create_and_register(
   const char       *device_file_name,
   uint32_t          media_block_size,
   rtems_blkdev_bnum blocks_with_buffer,
   rtems_blkdev_bnum media_block_count,
   uint8_t           fill_pattern )
 {
   rtems_status_code  sc          = RTEMS_SUCCESSFUL;
   rtems_sparse_disk *sparse_disk = sparse_disk_allocate(
     media_block_size,
     blocks_with_buffer
   );
 
   if ( sparse_disk != NULL ) {
     sc = rtems_sparse_disk_register(
       device_file_name,
       sparse_disk,
       media_block_size,
       blocks_with_buffer,
       media_block_count,
       fill_pattern,
       rtems_sparse_disk_free
     );
   } else {
     sc = RTEMS_NO_MEMORY;
   }
 
   return sc;
 }
 
 rtems_status_code rtems_sparse_disk_register(
   const char                      *device_file_name,
   rtems_sparse_disk               *sparse_disk,
   uint32_t                         media_block_size,
   rtems_blkdev_bnum                blocks_with_buffer,
   rtems_blkdev_bnum                media_block_count,
   uint8_t                          fill_pattern,
   rtems_sparse_disk_delete_handler sparse_disk_delete )
 {
   rtems_status_code sc;
 
   if ( blocks_with_buffer <= media_block_count ) {
     sc = sparse_disk_initialize(
       sparse_disk,
       media_block_size,
       blocks_with_buffer,
       sparse_disk_delete,
       fill_pattern
     );
 
     if ( RTEMS_SUCCESSFUL == sc ) {
       sc = rtems_blkdev_create(
         device_file_name,
         media_block_size,
         media_block_count,
         sparse_disk_ioctl,
         sparse_disk
       );
     }
   } else {
     sc = RTEMS_INVALID_NUMBER;
   }
 
   return sc;
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team