davrcvpg.c

Flash file system

Intel reserves the right to use and/or include Your name in 
public relations activities and marketing material and may 
request You to submit endorsements for the Software.  If You 
wish to discuss participation in this program, please send a 
fax to 916-356-2803 attn: "Software Marketing" with contact 
information and an Intel representative will contact You.

Revised: 02/16/01
***************************************************************************/ 


/*### Include Files
//#########################*/

#include "dav.h"
#if (DIRECT_ACCESS_VOLUME == TRUE)

/*### Local Declarations
//#########################*/

/*### Local Functions
//#########################*/

/*### Global Declarations
//#########################*/

/*### Global Functions
//#########################*/

/*########################################################################
  ### RCVRPAGE_SetupForPageReclaimRestart
  ###
  ### DESCRIPTION:
  ###   This function will setup the page reclaim state machine
  ###   to re-enter the state machine at the ReadNextObject state.
  ###
  ### PARAMETERS:
  ###   none.
  ###
  ### RETURNS:
  ###   ERR_NONE  - When operation is successful.
  ###
*/
ERR_CODE RCVRPAGE_SetupForPageReclaimRestart(BOOLEAN restart)
{
   int        in_block;
   UINT32      obj_lo_addr, obj_hi_addr;
   ERR_CODE status = ERR_NONE;
   BOOLEAN invalid_page_exist = FALSE;    
   MemMap.FreeBlk.BaseAddr = Block2Handle(0);
   
   /* Search through the header table until an object is    */
   /*  found that lies within the FROM block. (FROM object) */
   HDR_InitSearchInfo(&SearchInfo, &SearchHeader);
   do
   {
      status = GetNextHeader(&SearchInfo, HDR_ByNextObject, 0, restart);
      if ((status != ERR_NONE) && (status != ERR_NO_MORE_ENTRIES) && 
          (status != ERR_PARAM))
      {
         return(status);
      }

      if (!status)
      {
         if ((HDR_GetAlignmentAttr((SearchInfo.HeaderPtr->Attr16)) ==
                                                     HDR_HA_AlignPage) &&
                   (HDR_GetAbsorbedAttr(SearchInfo.HeaderPtr->Attr16) == 
                                                           HDR_HA_Exists))
         {

            /* If there is an invalid page object, */
            /* restore the invalid page object size for PLR. */
            if (!(HDR_GetHdrState(SearchInfo.HeaderPtr->Attr16) == 
                                                     HDR_HA_STATE_Valid))
            {
               ReclaimState.InvalidObjectSize =
                  PAGE_TO_BYTES(SearchInfo.HeaderPtr->LoSize);

               /* Initialize number of objects that will be modified so that */
               /* it begins to count right after the invalid page object. */
               ReclaimState.CurrentObject2Modify = 0;

               invalid_page_exist = TRUE; 
            }
            else
            {
               if (invalid_page_exist == FALSE)
               {
                 ReclaimState.CurrentObject2Modify = 0;
 
               }
               else
               {
                 /* Increase number of objects that will be modified */ 
                 ReclaimState.CurrentObject2Modify++;
               }
            }  
            obj_hi_addr = SearchInfo.CurrObj.ObjectAddress + 
                                        SearchInfo.CurrObj.ObjectSize - 1;
            in_block = IsInBlock(SearchInfo.CurrObj.ObjectAddress, 
                                     obj_hi_addr, RecoverState.FROMBlock);
            
            if (in_block == -1)
            {
               if (HDR_GetHdrState((SearchInfo.HeaderPtr->Attr16)) ==
                                                           HDR_HA_STATE_Valid)
               {
                  MemMap.FreeBlk.BaseAddr += SearchInfo.CurrObj.ObjectSize;
               }
            }
            else
            {
               if (in_block == 0)
               {
                  if (HDR_GetHdrState((SearchInfo.HeaderPtr->Attr16)) ==
                                                              HDR_HA_STATE_Valid)
                  {
                     obj_lo_addr = SearchInfo.CurrObj.ObjectAddress;
                     GetInBlockHiLoAddress(&obj_lo_addr, &obj_hi_addr, 
                                                RecoverState.FROMBlock);
                  
                     /* Add in the amount of the object that is before the  */
                     /*  FROM Block.                                        */
                     MemMap.FreeBlk.BaseAddr += obj_lo_addr - 
                                          SearchInfo.CurrObj.ObjectAddress;

/* E.5.0.600 Begin */
                     if((SearchInfo.HeaderPtr->ObjectType) != FDI_HT_ReclaimTable)
                     {
/* E.5.0.595 Begin */
                        if((SearchInfo.CurrObj.ObjectAddress == 
                               Block2Handle(RecoverState.FROMBlock)) &&
                           (ReclaimState.CurrentObject2Modify != 0))
                        {
                           ReclaimState.CurrentObject2Modify--;
                           /* Read the current object entry. */
                           status = OTTTBL_ReadTable(ReclaimState.OTTTblBaseAddr, 
                                              ReclaimState.CurrentObject2Modify, 
                                              &ReclaimState.OTTTblEntry, restart);
                           if(status != ERR_NONE)
                           {
                              return status;
                           }    

                           if ((ReclaimState.OTTTblEntry.objsize == DWORDMAX) &&
                               (ReclaimState.OTTTblEntry.status == WORDMAX))
                           {
                              ReclaimState.OTTTblEntry.objsize = 
                                        SearchInfo.CurrObj.ObjectSize;
      
                              /* Write the current object entry. */
                              status = OTTTBL_WriteTable(ReclaimState.OTTTblBaseAddr, 
                                                ReclaimState.CurrentObject2Modify, 
                                                  &ReclaimState.OTTTblEntry, restart);
                              if(status != ERR_NONE)
                              {
                                 return status;
                              }   

                              /* Mark the current object status 
                                 to OTTTBL_MASK_OTTEntryValid. */    
                              OTTTBL_MarkOTTEntryValid(ReclaimState.OTTTblEntry.status);
                              status = OTTTBL_WriteTable(ReclaimState.OTTTblBaseAddr, 
                                                ReclaimState.CurrentObject2Modify, 
                                                &ReclaimState.OTTTblEntry, restart);
                              if(status != ERR_NONE)
                              {
                                 return status;
                              }
                              ReclaimState.CurrentObject2Modify++;
                           }
                        }
/* E.5.0.595 End */    
                     }
/* E.5.0.600 End */		 
                  }
               }
               break;
            }
         }
      }
      
   } while (!status);

   
   
   /* We will always read the header of the FROM object, so */
   /*  do everything that would be done if we had just read */
   /*  the object.                                          */
   ReclaimState.NextState = (UINT16)RECLAIM_ST_ReadNextObj;
   ReclaimState.SingleSkipRead = TRUE;
   
   /* Base address of the reclaim block never moves, only   */
   /*  the BytesUsed field does.                            */
   MemMap.RecBlk.BaseAddr = FDI_ReclaimBlockAddress;
   
   if ((RecoverState.TOBlock == RecoverState.FROMBlock) &&
                    (Handle2Block(MemMap.FreeBlk.BaseAddr) == 
                                            RecoverState.TOBlock))
   {
      MemMap.RecBlk.BytesUsed = MemMap.FreeBlk.BaseAddr - 
                                Block2Handle(RecoverState.TOBlock);
      MemMap.FreeBlk.BaseAddr = Block2Handle(RecoverState.TOBlock);
   }
   else
   {
      MemMap.RecBlk.BytesUsed = 0;                                           
   }

   MemMap.FreeBlk.BytesFree = 
              Block2Handle(RecoverState.FROMBlock) - 
                                           MemMap.FreeBlk.BaseAddr;

   return ERR_NONE;
}

#endif /* DIRECT_ACCESS_VOLUME */