Subversion Repositories or1k

/*

 *  Object Handler

 *

 *

 *  COPYRIGHT (c) 1989-1999.

 *  On-Line Applications Research Corporation (OAR).

 *

 *  The license and distribution terms for this file may be

 *  found in the file LICENSE in this distribution or at

 *  http://www.OARcorp.com/rtems/license.html.

 *

 *  $Id: objectextendinformation.c,v 1.2 2001-09-27 11:59:34 chris Exp $

 */

#include <rtems/system.h>

#include <rtems/score/address.h>

#include <rtems/score/chain.h>

#include <rtems/score/object.h>

#if defined(RTEMS_MULTIPROCESSING)

#include <rtems/score/objectmp.h>

#endif

#include <rtems/score/thread.h>

#include <rtems/score/wkspace.h>

#include <rtems/score/sysstate.h>

#include <rtems/score/isr.h>

/*PAGE

 *

 *  _Objects_Extend_information

 *

 *  This routine extends all object information related data structures.

 *

 *  Input parameters:

 *    information     - object information table

 *

 *  Output parameters:  NONE

 */

void _Objects_Extend_information(

  Objects_Information *information

)

{

  Objects_Control  *the_object;

  void             *name_area;

  Chain_Control     Inactive;

  unsigned32        block_count;

  unsigned32        block;

  unsigned32        index_base;

  unsigned32        minimum_index;

  unsigned32        index;

  /*

   *  Search for a free block of indexes. The block variable ends up set

   *  to block_count + 1 if the table needs to be extended.

   */

  minimum_index = _Objects_Get_index( information->minimum_id );

  index_base    = minimum_index;

  block         = 0;

  if ( information->maximum < minimum_index )

    block_count = 0;

  else {

    block_count = information->maximum / information->allocation_size;

    for ( ; block < block_count; block++ ) {

      if ( information->object_blocks[ block ] == NULL )

        break;

      else

        index_base += information->allocation_size;

    }

  }

  /*

   *  If the index_base is the maximum we need to grow the tables.

   */

  if (index_base >= information->maximum ) {

    ISR_Level         level;

    void            **object_blocks;

    Objects_Name     *name_table;

    unsigned32       *inactive_per_block;

    Objects_Control **local_table;

    unsigned32        maximum;

    void             *old_tables;

    /*

     *  Growing the tables means allocating a new area, doing a copy and

     *  updating the information table.

     *

     *  If the maximum is minimum we do not have a table to copy. First

     *  time through.

     *

     *  The allocation has :

     *

     *      void            *objects[block_count];

     *      unsigned32       inactive_count[block_count];

     *      Objects_Name    *name_table[block_count];

     *      Objects_Control *local_table[maximum];

     *

     *  This is the order in memory. Watch changing the order. See the memcpy

     *  below.

     */

    /*

     *  Up the block count and maximum

     */

    block_count++;

    maximum = information->maximum + information->allocation_size;

    /*

     *  Allocate the tables and break it up.

     */

    if ( information->auto_extend ) {

      object_blocks = (void**)

        _Workspace_Allocate(

          block_count *

             (sizeof(void *) + sizeof(unsigned32) + sizeof(Objects_Name *)) +

          ((maximum + minimum_index) * sizeof(Objects_Control *))

          );

      if ( !object_blocks )

        return;

    }

    else {

      object_blocks = (void**)

        _Workspace_Allocate_or_fatal_error(

          block_count *

             (sizeof(void *) + sizeof(unsigned32) + sizeof(Objects_Name *)) +

          ((maximum + minimum_index) * sizeof(Objects_Control *))

        );

    }

    /*

     *  Break the block into the various sections.

     *

     */

    inactive_per_block = (unsigned32 *) _Addresses_Add_offset(

        object_blocks, block_count * sizeof(void*) );

    name_table = (Objects_Name *) _Addresses_Add_offset(

        inactive_per_block, block_count * sizeof(unsigned32) );

    local_table = (Objects_Control **) _Addresses_Add_offset(

        name_table, block_count * sizeof(Objects_Name *) );

    /*

     *  Take the block count down. Saves all the (block_count - 1)

     *  in the copies.

     */

    block_count--;

    if ( information->maximum > minimum_index ) {

      /*

       *  Copy each section of the table over. This has to be performed as

       *  separate parts as size of each block has changed.

       */

      memcpy( object_blocks,

              information->object_blocks,

              block_count * sizeof(void*) );

      memcpy( inactive_per_block,

              information->inactive_per_block,

              block_count * sizeof(unsigned32) );

      memcpy( name_table,

              information->name_table,

              block_count * sizeof(Objects_Name *) );

      memcpy( local_table,

              information->local_table,

              (information->maximum + minimum_index) * sizeof(Objects_Control *) );

    }

    else {

      /*

       *  Deal with the special case of the 0 to minimum_index

       */

      for ( index = 0; index < minimum_index; index++ ) {

        local_table[ index ] = NULL;

      }

    }

    /*

     *  Initialise the new entries in the table.

     */

    object_blocks[block_count] = NULL;

    inactive_per_block[block_count] = 0;

    name_table[block_count] = NULL;

    for ( index=index_base ;

          index < ( information->allocation_size + index_base );

          index++ ) {

      local_table[ index ] = NULL;

    }

    _ISR_Disable( level );

    old_tables = information->object_blocks;

    information->object_blocks = object_blocks;

    information->inactive_per_block = inactive_per_block;

    information->name_table = name_table;

    information->local_table = local_table;

    information->maximum = maximum;

    information->maximum_id =

      _Objects_Build_id(

        information->the_class, _Objects_Local_node, information->maximum

      );

    _ISR_Enable( level );

    if ( old_tables )

      _Workspace_Free( old_tables );

    block_count++;

  }

  /*

   *  Allocate the name table, and the objects

   */

  if ( information->auto_extend ) {

    information->object_blocks[ block ] =

      _Workspace_Allocate(

        (information->allocation_size * information->name_length) +

        (information->allocation_size * information->size)

      );

    if ( !information->object_blocks[ block ] )

      return;

  }

  else {

    information->object_blocks[ block ] =

      _Workspace_Allocate_or_fatal_error(

        (information->allocation_size * information->name_length) +

        (information->allocation_size * information->size)

      );

  }

  name_area = (Objects_Name *) _Addresses_Add_offset(

    information->object_blocks[ block ],

    (information->allocation_size * information->size)

  );

  information->name_table[ block ] = name_area;

  /*

   *  Initialize objects .. add to a local chain first.

   */

  _Chain_Initialize(

    &Inactive,

    information->object_blocks[ block ],

    information->allocation_size,

    information->size

  );

  /*

   *  Move from the local chain, initialise, then append to the inactive chain

   */

  index = index_base;

  while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {

    the_object->id =

      _Objects_Build_id(

        information->the_class, _Objects_Local_node, index

      );

    the_object->name = (void *) name_area;

    name_area = _Addresses_Add_offset( name_area, information->name_length );

    _Chain_Append( &information->Inactive, &the_object->Node );

    index++;

  }

  information->inactive_per_block[ block ] = information->allocation_size;

  information->inactive += information->allocation_size;

}