mirror of
https://github.com/FreeRTOS/FreeRTOS.git
synced 2025-08-24 19:31:03 +08:00
3a2f6646f0
* Use new version of CI-CD Actions, checkout@v3 instead of checkout@v2 on all jobs * Use cSpell spell check, and use ubuntu-20.04 for formatting check * Add in bot formatting action * Update freertos_demo.yml and freertos_plus_demo.yml files to increase github log readability * Add in a Qemu demo onto the workflows.
316 lines
11 KiB
C
316 lines
11 KiB
C
/* ----> DO NOT REMOVE THE FOLLOWING NOTICE <----
|
|
*
|
|
* Copyright (c) 2014-2015 Datalight, Inc.
|
|
* All Rights Reserved Worldwide.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; use version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but "AS-IS," WITHOUT ANY WARRANTY; without even the implied warranty
|
|
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
/* Businesses and individuals that for commercial or other reasons cannot
|
|
* comply with the terms of the GPLv2 license may obtain a commercial license
|
|
* before incorporating Reliance Edge into proprietary software for
|
|
* distribution in any form. Visit http://www.datalight.com/reliance-edge for
|
|
* more information.
|
|
*/
|
|
|
|
/** @file
|
|
* @brief Implements routines for the external imap.
|
|
*
|
|
* The external imap is used on volumes that are too big for the imap bitmap
|
|
* to be stored entirely in the metaroot, so instead the bitmap is stored in
|
|
* imap nodes on disk, and the metaroot bitmap is used to toggle between imap
|
|
* nodes.
|
|
*/
|
|
#include <redfs.h>
|
|
|
|
#if REDCONF_IMAP_EXTERNAL == 1
|
|
|
|
#include <redcore.h>
|
|
|
|
|
|
#if REDCONF_READ_ONLY == 0
|
|
static REDSTATUS ImapNodeBranch( uint32_t ulImapNode,
|
|
IMAPNODE ** ppImap );
|
|
static bool ImapNodeIsBranched( uint32_t ulImapNode );
|
|
#endif
|
|
|
|
|
|
/** @brief Get the allocation bit of a block from the imap as it exists in
|
|
* either metaroot.
|
|
*
|
|
* @param bMR The metaroot index: either 0 or 1.
|
|
* @param ulBlock The block number to query.
|
|
* @param pfAllocated On successful exit, populated with the allocation bit
|
|
* of the block.
|
|
*
|
|
* @return A negated ::REDSTATUS code indicating the operation result.
|
|
*
|
|
* @retval 0 Operation was successful.
|
|
* @retval -RED_EINVAL @p bMR is out of range; or @p ulBlock is out of range;
|
|
* or @p pfAllocated is `NULL`.
|
|
* @retval -RED_EIO A disk I/O error occurred.
|
|
*/
|
|
REDSTATUS RedImapEBlockGet( uint8_t bMR,
|
|
uint32_t ulBlock,
|
|
bool * pfAllocated )
|
|
{
|
|
REDSTATUS ret;
|
|
|
|
if( gpRedCoreVol->fImapInline ||
|
|
( bMR > 1U ) ||
|
|
( ulBlock < gpRedCoreVol->ulInodeTableStartBN ) ||
|
|
( ulBlock >= gpRedVolume->ulBlockCount ) ||
|
|
( pfAllocated == NULL ) )
|
|
{
|
|
REDERROR();
|
|
ret = -RED_EINVAL;
|
|
}
|
|
else
|
|
{
|
|
uint32_t ulOffset = ulBlock - gpRedCoreVol->ulInodeTableStartBN;
|
|
uint32_t ulImapNode = ulOffset / IMAPNODE_ENTRIES;
|
|
uint8_t bMRToRead = bMR;
|
|
IMAPNODE * pImap;
|
|
|
|
#if REDCONF_READ_ONLY == 0
|
|
|
|
/* If the imap node is not branched, then both copies of the imap are
|
|
* identical. If the old metaroot copy is requested, use the current
|
|
* copy instead, since it is more likely to be buffered.
|
|
*/
|
|
if( bMR == ( 1U - gpRedCoreVol->bCurMR ) )
|
|
{
|
|
if( !ImapNodeIsBranched( ulImapNode ) )
|
|
{
|
|
bMRToRead = 1U - bMR;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
ret = RedBufferGet( RedImapNodeBlock( bMRToRead, ulImapNode ), BFLAG_META_IMAP, CAST_VOID_PTR_PTR( &pImap ) );
|
|
|
|
if( ret == 0 )
|
|
{
|
|
*pfAllocated = RedBitGet( pImap->abEntries, ulOffset % IMAPNODE_ENTRIES );
|
|
|
|
RedBufferPut( pImap );
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
#if REDCONF_READ_ONLY == 0
|
|
|
|
/** @brief Set the allocation bit of a block in the working-state imap.
|
|
*
|
|
* @param ulBlock The block number to allocate or free.
|
|
* @param fAllocated Whether to allocate the block (true) or free it (false).
|
|
*
|
|
* @return A negated ::REDSTATUS code indicating the operation result.
|
|
*
|
|
* @retval 0 Operation was successful.
|
|
* @retval -RED_EINVAL @p ulBlock is out of range.
|
|
* @retval -RED_EIO A disk I/O error occurred.
|
|
*/
|
|
REDSTATUS RedImapEBlockSet( uint32_t ulBlock,
|
|
bool fAllocated )
|
|
{
|
|
REDSTATUS ret;
|
|
|
|
if( gpRedCoreVol->fImapInline ||
|
|
( ulBlock < gpRedCoreVol->ulInodeTableStartBN ) ||
|
|
( ulBlock >= gpRedVolume->ulBlockCount ) )
|
|
{
|
|
REDERROR();
|
|
ret = -RED_EINVAL;
|
|
}
|
|
else
|
|
{
|
|
uint32_t ulOffset = ulBlock - gpRedCoreVol->ulInodeTableStartBN;
|
|
uint32_t ulImapNode = ulOffset / IMAPNODE_ENTRIES;
|
|
IMAPNODE * pImap;
|
|
|
|
ret = ImapNodeBranch( ulImapNode, &pImap );
|
|
|
|
if( ret == 0 )
|
|
{
|
|
uint32_t ulImapEntry = ulOffset % IMAPNODE_ENTRIES;
|
|
|
|
if( RedBitGet( pImap->abEntries, ulImapEntry ) == fAllocated )
|
|
{
|
|
/* The driver shouldn't ever set a bit in the imap to its
|
|
* current value. That shouldn't ever be needed, and it
|
|
* indicates that the driver is doing unnecessary I/O, or
|
|
* that the imap is corrupt.
|
|
*/
|
|
CRITICAL_ERROR();
|
|
ret = -RED_EFUBAR;
|
|
}
|
|
else if( fAllocated )
|
|
{
|
|
RedBitSet( pImap->abEntries, ulImapEntry );
|
|
}
|
|
else
|
|
{
|
|
RedBitClear( pImap->abEntries, ulImapEntry );
|
|
}
|
|
|
|
RedBufferPut( pImap );
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/** @brief Branch an imap node and get a buffer for it.
|
|
*
|
|
* If the imap node is already branched, it can be overwritten in its current
|
|
* location, and this function just gets it buffered dirty. If the node is not
|
|
* already branched, the metaroot must be updated to toggle the imap node to
|
|
* its alternate location, thereby preserving the committed state copy of the
|
|
* imap node.
|
|
*
|
|
* @param ulImapNode The imap node to branch and buffer.
|
|
* @param ppImap On successful return, populated with the imap node
|
|
* buffer, which will be marked dirty.
|
|
*
|
|
* @return A negated ::REDSTATUS code indicating the operation result.
|
|
*
|
|
* @retval 0 Operation was successful.
|
|
* @retval -RED_EINVAL @p ulImapNode is out of range; or @p ppImap is `NULL`.
|
|
* @retval -RED_EIO A disk I/O error occurred.
|
|
*/
|
|
static REDSTATUS ImapNodeBranch( uint32_t ulImapNode,
|
|
IMAPNODE ** ppImap )
|
|
{
|
|
REDSTATUS ret;
|
|
|
|
if( ( ulImapNode >= gpRedCoreVol->ulImapNodeCount ) || ( ppImap == NULL ) )
|
|
{
|
|
REDERROR();
|
|
ret = -RED_EINVAL;
|
|
}
|
|
else if( ImapNodeIsBranched( ulImapNode ) )
|
|
{
|
|
/* Imap node is already branched, so just get it buffered dirty.
|
|
*/
|
|
ret = RedBufferGet( RedImapNodeBlock( gpRedCoreVol->bCurMR, ulImapNode ), BFLAG_META_IMAP | BFLAG_DIRTY, CAST_VOID_PTR_PTR( ppImap ) );
|
|
}
|
|
else
|
|
{
|
|
uint32_t ulBlockCurrent;
|
|
uint32_t ulBlockOld;
|
|
|
|
/* The metaroot currently points to the committed state imap node.
|
|
* Toggle the metaroot to point at the alternate, writeable location.
|
|
*/
|
|
if( RedBitGet( gpRedMR->abEntries, ulImapNode ) )
|
|
{
|
|
RedBitClear( gpRedMR->abEntries, ulImapNode );
|
|
}
|
|
else
|
|
{
|
|
RedBitSet( gpRedMR->abEntries, ulImapNode );
|
|
}
|
|
|
|
ulBlockCurrent = RedImapNodeBlock( gpRedCoreVol->bCurMR, ulImapNode );
|
|
ulBlockOld = RedImapNodeBlock( 1U - gpRedCoreVol->bCurMR, ulImapNode );
|
|
|
|
ret = RedBufferDiscardRange( ulBlockCurrent, 1U );
|
|
|
|
/* Buffer the committed copy then reassign the block number to the
|
|
* writeable location. This also dirties the buffer.
|
|
*/
|
|
if( ret == 0 )
|
|
{
|
|
ret = RedBufferGet( ulBlockOld, BFLAG_META_IMAP, CAST_VOID_PTR_PTR( ppImap ) );
|
|
|
|
if( ret == 0 )
|
|
{
|
|
RedBufferBranch( *ppImap, ulBlockCurrent );
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/** @brief Determine whether an imap node is branched.
|
|
*
|
|
* If the imap node is branched, it can be overwritten in its current location.
|
|
*
|
|
* @param ulImapNode The imap node to examine.
|
|
*
|
|
* @return Whether the imap node is branched.
|
|
*/
|
|
static bool ImapNodeIsBranched( uint32_t ulImapNode )
|
|
{
|
|
bool fNodeBitSetInMetaroot0 = RedBitGet( gpRedCoreVol->aMR[ 0U ].abEntries, ulImapNode );
|
|
bool fNodeBitSetInMetaroot1 = RedBitGet( gpRedCoreVol->aMR[ 1U ].abEntries, ulImapNode );
|
|
|
|
/* If the imap node is not branched, both metaroots will point to the same
|
|
* copy of the node.
|
|
*/
|
|
return fNodeBitSetInMetaroot0 != fNodeBitSetInMetaroot1;
|
|
}
|
|
#endif /* REDCONF_READ_ONLY == 0 */
|
|
|
|
|
|
/** @brief Calculate the block number of the imap node location indicated by the
|
|
* given metaroot.
|
|
*
|
|
* An imap node has two locations on disk. A bit in the metaroot bitmap
|
|
* indicates which location is the valid one, according to that metaroot. This
|
|
* function returns the block number of the imap node which is valid in the
|
|
* given metaroot.
|
|
*
|
|
* @param bMR Which metaroot to examine.
|
|
* @param ulImapNode The imap node for which to calculate the block number.
|
|
*
|
|
* @return Block number of the imap node, as indicated by the given metaroot.
|
|
*/
|
|
uint32_t RedImapNodeBlock( uint8_t bMR,
|
|
uint32_t ulImapNode )
|
|
{
|
|
uint32_t ulBlock;
|
|
|
|
REDASSERT( ulImapNode < gpRedCoreVol->ulImapNodeCount );
|
|
|
|
ulBlock = gpRedCoreVol->ulImapStartBN + ( ulImapNode * 2U );
|
|
|
|
if( bMR > 1U )
|
|
{
|
|
REDERROR();
|
|
}
|
|
else if( RedBitGet( gpRedCoreVol->aMR[ bMR ].abEntries, ulImapNode ) )
|
|
{
|
|
/* Bit is set, so point ulBlock at the second copy of the node.
|
|
*/
|
|
ulBlock++;
|
|
}
|
|
else
|
|
{
|
|
/* ulBlock already points at the first copy of the node.
|
|
*/
|
|
}
|
|
|
|
return ulBlock;
|
|
}
|
|
|
|
#endif /* REDCONF_IMAP_EXTERNAL == 1 */
|