davsearch.c

来自「FDI Intel开发的FLASH文件系统,功能很强大」· C语言 代码 · 共 1,358 行 · 第 1/4 页

/* Copyright (c) 1995-2004 Intel Corporation */
/* Intel Confidential                        */

/* ###########################################################################
###  DAV
###
###  Module: davsearch.c - Low Level Header Search Module
###
###  $Workfile: davsearch.c $
###  $Revision: 8 $
### 
###  $NoKeywords: $
########################################################################### */

/*                                                               
 *****************************************************************
 * NOTICE OF LICENSE AGREEMENT                                    
 *                                                                
 * This code is provided by Intel Corp., and the use is governed  
 * under the terms of a license agreement. See license agreement  
 * for complete terms of license.                                 
 *                                                                
 * YOU MAY ONLY USE THE SOFTWARE WITH INTEL FLASH PRODUCTS.  YOUR 
 * USE OF THE SOFTWARE WITH ANY OTHER FLASH PRODUCTS IS EXPRESSLY 
 * PROHIBITED UNLESS AND UNTIL YOU APPLY FOR, AND ARE GRANTED IN  
 * INTEL'S SOLE DISCRETION, A SEPARATE WRITTEN SOFTWARE LICENSE   
 * FROM INTEL LICENSING ANY SUCH USE.                             
 *****************************************************************
 */
 
/*### Include Files
#########################*/
#include "DavLib.h"

#if (DIRECT_ACCESS_VOLUME == TRUE)

#include "davsearch.h"
#include "davext.h"

/*### Local Declarations
#########################*/
static ERR_CODE IsFound(SEARCH_SearchInfoPtr    aSrchInfoPtr, 
                        SEARCH_SearchMethodEnum aCompareMethod,
                        SEARCH_CompareInfoPtr   aCompareInfoPtr,
                        UINT8*                  aFoundValPtr,
                        BOOLEAN                 restart);

/*### Global Declarations
#########################*/
SEARCH_SearchInfo FDI_SearchInfo;
HDR_Header        FDI_SearchHeader;

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

#define ExitOnError(status) \
   if (status != ERR_NONE) \
   {  return status;  }


/*#################################################################
  ### IsFound
  ###
  ### DESCRIPTION:
  ###   This function is used to locate an object based on the 
  ###   method of searching.  By adding a comparison to this
  ###   function and the SEARCH_SearchMethod enum, the GetNextHeader 
  ###   function can be extended without modifying the rest 
  ###   of the search code.
  ###
  ### PARAMETERS:
  ###   aSrchInfoPtr  - Structure containing search information.
  ###      IN:  - Must contain valid object information in order
  ###              to carry out the requested search.
  ###           - HeaderPtr points to a valid header for temporary 
  ###              use.
  ###
  ###      OUT: - On a search by SEARCH_ByName or SEARCH_ByNameType
  ###
  ###   aCompareMethod  - Search for the next object with the
  ###                     desired qualities.
  ###   compare_value  -  Value to use to compare search depending 
  ###                     on the type of search.
  ###
  ### RETURNS:
  ###   TRUE  - If object info matches the requested method.
  ###   FALSE - If not!
  ###*/
static ERR_CODE IsFound(SEARCH_SearchInfoPtr    aSrchInfoPtr, 
                        SEARCH_SearchMethodEnum aCompareMethod,
                        SEARCH_CompareInfoPtr   aCompareInfoPtr,
                        UINT8*                  aFoundValPtr,
                        BOOLEAN                 restart)
{
UINT32   ii;
UINT8    found = 0;
ERR_CODE status = ERR_NONE;
BOOLEAN  objHeaderRead = FALSE;
FDI_HT_ObjectTypeEnum type;

   /* first, does the header point to anything?  if not, this is not a match */
   if (FHDR_GetAbsorbStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) != HDR_ABSORBED)
   {
      /* if this header represents a WIP or valid object in either page or para space */
      if(
          (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_VALID) ||
          (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_WRITE_IN_PROGRESS)
        )
      {
         /* Read in the full object header (with or without name */
         /* depending on if the object is a page space object)   */
         if(OHDR_ReadObjectHeader(FHDR_CalcObjectHandle(
                       &(aSrchInfoPtr->HeaderPtr->FHdr)),
                       &(aSrchInfoPtr->HeaderPtr->OHdr),
                       FHDR_IsPageObject(&(aSrchInfoPtr->HeaderPtr->FHdr))) == ERR_NONE)
         {
            objHeaderRead = TRUE;
         }
      }

      switch (aCompareMethod)
      {
         case SEARCH_ByPartialAllocFixedHdrComplete:
            /*
             * We want to find a header where the object data was not written, however,
             * the header was marked as valid.
             */
            if (FHDR_IsParaObject(&(aSrchInfoPtr->HeaderPtr->FHdr)))
            {
               if (
                  ((UINT32)FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) == aCompareInfoPtr->CompareValue) &&
                  ((UINT32)FHDR_GetHeaderIndexOffset(&(aSrchInfoPtr->HeaderPtr->FHdr)) == aCompareInfoPtr->CompareValue2)
                  )
               {
                  /* Our key values match, however, is this the correct state? */
                  if(
                    (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_WRITE_IN_PROGRESS) &&
                    (FHDR_GetHeaderStatus(&(aSrchInfoPtr->HeaderPtr->FHdr))     == HDR_HEADER_VALID)
                    )
                  {
                     found = 1;
                  }
               }
            }
            else
            {
               type = (aCompareInfoPtr->CompareValue > FDI_HT_NormalObject) ? FDI_HT_NormalObject : aCompareInfoPtr->CompareValue;
               /* for a partially allocated page object, only match the type to the type in the fixed header */
               if (
                  (FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) == type) &&
                  ((UINT32)FHDR_GetHeaderIndexOffset(&(aSrchInfoPtr->HeaderPtr->FHdr)) == aCompareInfoPtr->CompareValue2)
                  )
               {
                  /* Our key values match, however, is this the correct state? */
                  if(
                    (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_WRITE_IN_PROGRESS) &&
                    (FHDR_GetHeaderStatus(&(aSrchInfoPtr->HeaderPtr->FHdr))     == HDR_HEADER_VALID)
                    )
                  {
                     found = 1;
                  }
               }
            }
            break;

         case SEARCH_ByValidType:
            if (
                (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_VALID)
               )
            {
               if (FHDR_IsParaObject(&(aSrchInfoPtr->HeaderPtr->FHdr)))
               {
                  if((UINT32)FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) == aCompareInfoPtr->CompareValue)
                  {
                     found = 1;
                  }
               }
               else
               {
                  if (objHeaderRead)
                  {
                     if (aSrchInfoPtr->HeaderPtr->OHdr.Type == aCompareInfoPtr->CompareValue)
                     {
                        found = 1;
                     }
                  }
               }
            }
         break;
      
         case SEARCH_ByFreeOrWIPType:
            if (
                (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_EMPTY) ||
                (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_WRITE_IN_PROGRESS)
               )
            {
               if (FHDR_IsParaObject(&(aSrchInfoPtr->HeaderPtr->FHdr)))
               {
                  if((UINT32)FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) == aCompareInfoPtr->CompareValue)
                  {
                     found = 1;
                  }
               }
               else
               {
                  if (objHeaderRead)
                  {
                     if (aSrchInfoPtr->HeaderPtr->OHdr.Type == aCompareInfoPtr->CompareValue)
                     {
                        found = 1;
                     }
                  }
               }
            }
         break;
      
         case SEARCH_ByTypeOnly:
            if (FHDR_IsParaObject(&(aSrchInfoPtr->HeaderPtr->FHdr)))
            {
               if((UINT32)FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) == aCompareInfoPtr->CompareValue)
               {
                  found = 1;
               }
            }
            else
            {
               if (objHeaderRead)
               {
                  if (aSrchInfoPtr->HeaderPtr->OHdr.Type == aCompareInfoPtr->CompareValue)
                  {
                     found = 1;
                  }
               }
            }
         break;
      
         case SEARCH_ByHeaderAddress:
            if (aSrchInfoPtr->CurrObj.HeaderAddress == aCompareInfoPtr->CompareValue)
            {
               found = 1;
            }
         break;
      
         case SEARCH_ByNextObject:
            found = 1;
         break;

         case SEARCH_ByNextWriteInProgressObject:
            if (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_WRITE_IN_PROGRESS)
            {
               found = 1;
            }
         break;
      
         case SEARCH_ByNextInvalidPageObject:
            if ((FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_INVALID) &&
                (FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) != FDI_HT_RecoveredHeader) &&
                (FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) != FDI_HT_NormalObject))
            {
               found = 1;
            }
         break;
      
         case SEARCH_ByNextValidObject:
            if ((FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_VALID) &&
                (FHDR_GetHeaderStatus(&(aSrchInfoPtr->HeaderPtr->FHdr))     == HDR_HEADER_VALID))
            {
               if (FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) == FDI_HT_NormalObject)
               {
                  found = 1;
               }
               else
               {
                  found = 1;
               }
            }
         break;
      
         case SEARCH_ByNextPageObject:
            if (
                (FHDR_GetHeaderStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_HEADER_VALID) &&
                (FHDR_IsPageObject(&(aSrchInfoPtr->HeaderPtr->FHdr)))
               )

            {
               found = 1;
            }
         break;
      
         case SEARCH_ByNextValidPageObject:
            
            if (
                (FHDR_GetHeaderStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_HEADER_VALID) &&
                (FHDR_IsPageObject(&(aSrchInfoPtr->HeaderPtr->FHdr))) &&
                (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_VALID)
               )
            {
               found = 1;
            }
         break;
      
         case SEARCH_ByNameType:
            /* Check for matching type and non-invalid object before */
            /*  checking the name.                                   */
            if (FHDR_IsParaObject(&(aSrchInfoPtr->HeaderPtr->FHdr)))
            {
               if (
                  (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) != HDR_ALLOC_INVALID) &&
                  ((UINT32)FHDR_GetType(&(aSrchInfoPtr->HeaderPtr->FHdr)) == aCompareInfoPtr->CompareValue)
                  )
               {
                  found = 1;
                  break;  /* no name for para objects, so don't try to match */
               }
            }
            else
            {
               if (objHeaderRead)
               {
                  if (
                     (FHDR_GetAllocationStatus(&(aSrchInfoPtr->HeaderPtr->FHdr)) == HDR_ALLOC_INVALID) ||
                     (aSrchInfoPtr->HeaderPtr->OHdr.Type != aCompareInfoPtr->CompareValue)
                     )
                  {
                     found = 0;
                     break;  /* don't bother checking the name; this isn't a match */
                  }
               }
               else
               {
                  found = 0;
                  /* don't bother checking the name; this object doesn't have an object header */
                  break;
               }
            }
         /*lint -fallthrough*/      
         case SEARCH_ByName:
            /* If the name lengths don't match obviously the names themselves */
            /*  cannot match.  This prevents the problem of a name with       */
            /*   aaaa matching with a name of aaaaa.                          */