davhdr.c

Flash file system

   FDI_MemUsage.PageOverhead.Invalid = 0;
   FDI_MemUsage.PageOverhead.Absorbed = 0;
   FDI_MemUsage.PageOverhead.ReclaimReserves = 0;
   
   FDI_MemUsage.ParaOverhead.Valid = 0;
   FDI_MemUsage.ParaOverhead.Invalid = 0;
   FDI_MemUsage.ParaOverhead.Absorbed = 0;
   
   FDI_MemUsage.ParaOverhead.ReclaimReserves = 
                                    ALLOC_CalcParaSystemReserves();

   /* Scan the entire header table and setup tracking variables. */
   HDR_InitSearchInfo((&srch_info), &srch_header);
   while((status = GetNextHeaderHandle((&srch_info), GNH_SP_Normal, restart)) 
                                                     == ERR_NONE)
   { 
      header_size = HDR_CalcHeaderSize(srch_info.HeaderPtr);
      if (HDR_GetAbsorbedAttr((srch_info.HeaderPtr->Attr16)) 
                                                   == HDR_HA_Exists)
      {
         /* Header is not absorbed */
         obj_size = srch_info.CurrObj.ObjectSize;
         switch (HDR_GetStatusAttr(srch_info.HeaderPtr->Attr16))
         {
            case HDR_HA_WriteInProgress:
            case HDR_HA_Valid:
               if (HDR_GetAlignmentAttr(srch_info.HeaderPtr->Attr16) == 
                                                          HDR_HA_AlignPage)
               {  
                  page_entry = TRUE;
                  FDI_MemUsage.PageSpace.Valid += obj_size;
                  FDI_MemUsage.PageOverhead.Valid += header_size;
                  
                  /* Add to reserves if needed. */
                  if (HDR_GetReservesAttr(srch_info.HeaderPtr->Attr8) == 
                                                           HDR_HA_UseReserves)

                  {
                     /* A reliable Allocate */
                     if (obj_size > FDI_MemUsage.PageSpace.Reserves) 
                     {                       
                        FDI_MemUsage.PageSpace.Reserves = obj_size;
                     }
                     
                     if (header_size > FDI_MemUsage.ParaSpace.Reserves)
                     {
                        FDI_MemUsage.ParaSpace.Reserves = header_size;
                     }
                  }
               }
               else
               {
                  /* Add to valid paragraphs */
                  FDI_MemUsage.ParaSpace.Valid += obj_size;
                  FDI_MemUsage.ParaOverhead.Valid += header_size;
                  
                  /* Add to reserves if needed */
                  if (HDR_GetReservesAttr(srch_info.HeaderPtr->Attr8) == 
                                         HDR_HA_UseReserves)
                  {
                     if ((obj_size + header_size) > FDI_MemUsage.ParaSpace.Reserves) 
                     {
                        FDI_MemUsage.ParaSpace.Reserves = obj_size + header_size;
                     }
                  }
               }
            break;

            case HDR_HA_Invalid:
               if (HDR_GetAlignmentAttr(srch_info.HeaderPtr->Attr16) == 
                                                          HDR_HA_AlignPage)
               {
                  /* Add to invalid pages */
                  page_entry = TRUE;
                  FDI_MemUsage.PageSpace.Invalid += obj_size;
                  FDI_MemUsage.PageOverhead.Invalid += header_size;
               }
               else
               {
                  /* Add to invalid paragraphs */
                  FDI_MemUsage.ParaSpace.Invalid += obj_size;
                  FDI_MemUsage.ParaOverhead.Invalid += header_size;
               }
            break;
 
            default:
            {};
         }
      }
      else
      {
         /* Header is Absorbed (Should always be page space) */
         FDI_MemUsage.PageOverhead.Absorbed += header_size; 

         
      }
      /* Fix any Bad headers that are found */
      if (HDR_GetStatusAttr(srch_info.HeaderPtr->Attr16) ==
                                                 HDR_HA_Bad)
      {
         status = HDR_RepairHeader(&srch_info);
         if (status)
         {
            return(status);
         }
      }
      /* Never sure when the last handle will be hit so continue      */
      /* storing the handle value off until there are no more entries */
      /* found.                                                       */
      FDI_LastHeaderEntry  = srch_info.CurrObj.HeaderAddress;
   } /* end while */

   if ((status != ERR_NO_MORE_ENTRIES) && (status != ERR_PARAM))
   {
      return(status);
   }

   /*##################################################################*/
   /*### By this point all valid, invalid, and absorbed headers should */
   /*### be accounted for in FDI_Memusage.  All that remains is to     */
   /*### repair any headers at the end of the table and calculate the  */
   /*### amounts of free  and reserved memory.                         */
   /*##################################################################*/

   /* Repair the last header if it is needed. */
   if (status == ERR_PARAM)
   {
      /* Repair Last header */
      status = HDR_RepairHeader(&srch_info);
      if (status)
      {
         return(status);
      }
      /* Add Header to Statistics */
      header_size = HDR_CalcHeaderSize(srch_info.HeaderPtr);
      FDI_MemUsage.PageOverhead.Absorbed += header_size; 

      FDI_LastHeaderEntry  = srch_info.CurrObj.HeaderAddress;
      srch_info.CurrObj.HeaderAddress -= ParagraphAlign(header_size);
   }

   /* Need to account for the page reclaim table in */
   /* overhead if there are page entries            */
   if (page_entry)
   {
      FDI_MemUsage.PageOverhead.ReclaimReserves = 
                                      ALLOC_CalcPageSystemReserves();
   }

   /* The handle points to the next paragraph boundary of the next */
   /* header, which happens to point to empty flash space.         */
   FDI_NextFreeHeaderEntry = srch_info.CurrObj.HeaderAddress;
   
   return ERR_NONE;
}

/*#################################################################
  ### HDR_CalcHeaderSize
  ### 
  ### DESCRIPTION:
  ###   This function will return the the size of the header entry.
  ###   This includes the size of the name, aligned to a paragraph
  ###   boundary and the fixed header size.
  ###
  ###   The HDR_CalcHdrSize macro does the same thing only with
  ###   the name size as a parameter.
  ### 
  ### PARAMETERS:   
  ###   header_ptr - IN:  Header must have a valid name size field.
  ###                OUT: Not used.
  ### 
  ### RETURNS:
  ###   The size of the header in bytes, is returned.
  ###*/
UINT16 HDR_CalcHeaderSize(const HDR_Header *header_ptr)
{
  return (UINT16)HDR_CalcHdrSize((header_ptr->NameSize));
}


/*#################################################################
  ### HDR_GetObjectSize
  ### 
  ### DESCRIPTION:
  ###   This function will load "size" with the LoSize
  ###   and HiSize fields of the header pointed to by "header_ptr".
  ### 
  ### PARAMETERS: 
  ###   header_ptr  - IN:  the header from which to read size fields.
  ###                 OUT: not used.
  ###   size_ptr    - IN:  not used.
  ###                 OUT: Size of the object that is stored in 
  ###                      the header's HiSize and LoSize fields.
  ### 
  ### RETURNS:
  ###   None.
  ###*/
void HDR_GetObjectSize(const HDR_Header *header_ptr, UINT32_PTR size_ptr)
{
   *size_ptr = ((UINT32)HDR_GetSizeAttr(header_ptr->Attr8) << 16) +
                                        (UINT32)(header_ptr->LoSize);
   
   /* Convert the paragraph/page counts to bytes. */
   if (HDR_GetAlignmentAttr((header_ptr->Attr16)) == HDR_HA_AlignPara)
   {
      *size_ptr *= FDI_ParagraphLength;                 
   }
   else
   {
      *size_ptr *= FDI_PageSize;  
   }
}

/*#################################################################
  ### HDR_SetObjectSize
  ### 
  ### DESCRIPTION:
  ###   This function will take "size" and load it into the LoSize
  ###   and HiSize fields of the header pointed to by "header_ptr".
  ###
  ### PARAMETERS:
  ###   header_ptr  - IN:  Not used.
  ###                 OUT: Header's LoSize and HiSize fields will
  ###                      be loaded with the specified size.
  ###   size        - Size of the object to be stored into header.
  ###
  ### RETURNS:
  ###   None.
  ###*/
void HDR_SetObjectSize(HDR_HeaderPtr header_ptr, UINT32 size)
{                  
   
   header_ptr->Attr8 = (UINT8)HDR_SetSizeAttr((header_ptr->Attr8), 
                                               (size >> 16));
   header_ptr->LoSize = (UINT16)size;
}


/*#################################################################
  ### HDR_ObjectInfo2Header
  ###
  ### DESCRIPTION:
  ###   This function copies all the information from obj_info 
  ###   structure to the appropriate fields in the header structure.
  ###
  ### PARAMETERS:
  ###   header_ptr -   IN:  Must point to a valid header structure.
  ###                  OUT: Object information translated properly.
  ###
  ###   obj_info_ptr - IN:  Object info structure with all valid 
  ###                        object information.
  ###                  OUT: unchanged.
  ###
  ### RETURNS:
  ###   none.
  ###*/
void HDR_ObjectInfo2Header(HDR_HeaderPtr        header_ptr, 
                           const FDI_ObjectInfo *obj_info_ptr)
{
   UINT32 ii;

   /* All is well on the memory space front, so create the header. */
   /* Set up Power Loss Recovery Options                           */
   HDR_InitHeaderAttr16((header_ptr->Attr16));
   HDR_InitHeaderAttr8((header_ptr->Attr8));
   switch (obj_info_ptr->RecoveryLevel)
   {                                          
      case FDI_PLR_Level0:
         /* Highest level of recovery w/reserves */
         header_ptr->Attr8 = HDR_SetReliableAttr((header_ptr->Attr8),
                                                 HDR_HA_Reliable);
         header_ptr->Attr8 = HDR_SetReservesAttr((header_ptr->Attr8),
                                                 HDR_HA_UseReserves);
         header_ptr->Attr16 = HDR_SetStatusAttr((header_ptr->Attr16),
                                                HDR_HA_WriteInProgress);
      break;

      case FDI_PLR_Level1:
         /* Highest level of recovery without reserves */
         header_ptr->Attr8 = HDR_SetReliableAttr((header_ptr->Attr8),
                                                 HDR_HA_Reliable);
         header_ptr->Attr8 = HDR_SetReservesAttr((header_ptr->Attr8),
                                                 HDR_HA_NoReserves);
         header_ptr->Attr16 = HDR_SetStatusAttr((header_ptr->Attr16),
                                                HDR_HA_WriteInProgress);
      break;

      case FDI_PLR_Level2:
         /* Lowest level of recovery.  Delete on Update */
         header_ptr->Attr8 = HDR_SetReliableAttr((header_ptr->Attr8),
                                                 HDR_HA_NonReliable);
         header_ptr->Attr8 = HDR_SetReservesAttr((header_ptr->Attr8),
                                                 HDR_HA_NoReserves);
         header_ptr->Attr16 = HDR_SetStatusAttr((header_ptr->Attr16),
                                                HDR_HA_Valid);
      break;

      default:
      {};
   }
   
   /* Translate page or paragraph alignment to the header entry. */
   if (obj_info_ptr->Alignment == FDI_ALIGN_Page)
   {
      header_ptr->Attr16 = HDR_SetAlignmentAttr((header_ptr->Attr16), HDR_HA_AlignPage);
   }
   else
   {
      header_ptr->Attr16 = HDR_SetAlignmentAttr((header_ptr->Attr16), HDR_HA_AlignPara);
   }
   
   /* Calculate the size of the header and place it in the */
   /*  proper fields.                                      */
   HDR_SetObjectSize(header_ptr, (obj_info_ptr->ObjectSize));
   header_ptr->Attr16 = HDR_SetAbsorbedAttr((header_ptr->Attr16), HDR_HA_Exists);
   header_ptr->Attr16 = 
      HDR_SetPrivilegeAttr((header_ptr->Attr16), obj_info_ptr->PrivilegeLevel);
   
   header_ptr->SecurityKey = obj_info_ptr->SecurityKey;
   header_ptr->ObjectType  = obj_info_ptr->ObjectType;
   header_ptr->NameSize = obj_info_ptr->NameSize;

   /* Copy the name to the header_ptr */
   for (ii = 0; ii < obj_info_ptr->NameSize; ii++)
   {
      header_ptr->Name[ii] = obj_info_ptr->Name[ii];
   }
}
    

/*#################################################################
  ### HDR_SearchInfo2ObjectInfo
  ###
  ### DESCRIPTION:
  ###   This function copies all the information from search_info 
  ###   structure to the appropriate fields in the obj_info structure.
  ###
  ### PARAMETERS:
  ###   obj_info_ptr -    IN:  Object info structure with all valid 
  ###                           header information.
  ###                     OUT: Will contain translated search info
  ###                           and header information.
  ###
  ###   search_info_ptr - IN:  Must contain a pointer to a valid
  ###                           search info structure that contains
  ###                           physical object information to be
  ###                           translated.
  ###                     OUT: unchanged.
  ###
  ### RETURNS:
  ###   none.
  ###*/
void HDR_SearchInfo2ObjectInfo(FDI_ObjectInfoPtr    obj_info_ptr,
                               const HDR_SearchInfo *search_info_ptr)
{
   UINT32 ii;

   /* Copy the name field from the header to the search info struct. */
   obj_info_ptr->NameSize = search_info_ptr->HeaderPtr->NameSize;
   for (ii = 0; ii < obj_info_ptr->NameSize; ii++)
   {
      obj_info_ptr->Name[ii] = search_info_ptr->HeaderPtr->Name[ii];
   }
   
   obj_info_ptr->ObjectType = search_info_ptr->HeaderPtr->ObjectType;
   obj_info_ptr->SecurityKey = search_info_ptr->HeaderPtr->SecurityKey;
   obj_info_ptr->ObjectAddress = search_info_ptr->CurrObj.ObjectAddress;
   
   /* Translate the object alignment. */
   if (HDR_GetAlignmentAttr((search_info_ptr->HeaderPtr->Attr16)) == 
                                                       HDR_HA_AlignPage)
   {                                                   
      obj_info_ptr->Alignment = FDI_ALIGN_Page;
      obj_info_ptr->ObjectSize = 
            search_info_ptr->CurrObj.ObjectSize / FDI_PageSize;
   }
   else
   {                                                   
      obj_info_ptr->Alignment = FDI_ALIGN_Paragraph;
      obj_info_ptr->ObjectSize = 
            search_info_ptr->CurrObj.ObjectSize / FDI_ParagraphLength;
   }
   
   /* Translate the privilege level by shifting it down. */
   obj_info_ptr->PrivilegeLevel = 
             HDR_GetPrivilegeAttr((search_info_ptr->HeaderPtr->Attr16));
    
   /* Translate the reliable attributes to the equivalent PLR_Level */
   /*   Level0:  Reserves = on,  Confidence = on                   */
   /*   Level1:  Reserves = off, Confidence = on                   */
   /*   Level2:  Reserves = off, Confidence = off                  */
   if (HDR_GetReliableAttr((search_info_ptr->HeaderPtr->Attr8)) == 
                                                     HDR_HA_Reliable)
   {
      /* Must be level 0 or 1  */
      if (HDR_GetReservesAttr((search_info_ptr->HeaderPtr->Attr8)) == 
                                                  HDR_HA_UseReserves)
      {