#define USE_FTR

#include <PalmOS.h>
#include <VFSMgr.h>
#include <68k/system/PmPalmOSNVFS.h>
#ifndef STANDALONE
#include "Backup.h"
#endif

#ifndef memHeapFlagReadOnly
# define memHeapFlagReadOnly 0x0001
#endif

// To use DBCacheFlush() code in another application modify these defines:
#define CREATOR                 appCreator
#define FIRST_FTR_ID    1

void DBCacheFlush( Boolean fast );

#ifdef DA
void DA_Main( void )
{
   DBCacheFlush( true );
}
#endif



static void SetRecyclable( UInt16 card, LocalID id )
{
   UInt16 attr;

   if ( id == NULL )
       return;

   if ( errNone == DmDatabaseInfo( card, id, NULL, &attr, NULL,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ) {

       attr = attr | dmHdrAttrRecyclable;
       DmSetDatabaseInfo( card, id, NULL, &attr, NULL,
                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL );
   }

}


static Boolean HaveNVFS( void )
{
   Err err;
   UInt32 value;

   err = FtrGet( sysFtrCreator, sysFtrNumDmAutoBackup, &value );

   return ( err == errNone && value != 0 );
}



static void Progress( Boolean show )
{
#if 0
    Coord w;
    Coord h;

    if ( ! show )
        return;

    WinGetDisplayExtent( &w, &h );

    WinDrawPixel( SysRandom(0)%w, SysRandom(0)%h );
#endif
}



// Flushing via feature memory (Does not work well for lower NVFS version [bellow TX])
// Better in defragmentation
static void FtrFlush( UInt16 storageHeapId, Boolean savedScreen )
{
       #define BLOCK_SIZE  65536       // 32768
       Int32     needed ;
       UInt16    fNum ;
       Int32     i ;
       void     *f ;
       UInt32    size ;
       UInt32    dbCacheTotal = MemHeapSize( storageHeapId|dbCacheFlag );

       // First algorithm
       fNum = FIRST_FTR_ID;
       for( i=70 ; 10 <= i ; i-=10 )
       {
               Progress( savedScreen );
               size = dbCacheTotal*i/100 ;
               if( FtrPtrNew( CREATOR, fNum, size, &f) == 0 )
                       fNum++ ;
       }

       needed = dbCacheTotal / BLOCK_SIZE;
       for( i=0 ; i < needed ; i++ )
       {
               Progress( savedScreen );
               if( FtrPtrNew( CREATOR, fNum, BLOCK_SIZE, &f) != 0 )
                       break ;
               fNum++ ;
       }

       for( i=FIRST_FTR_ID ; i < fNum ; i++ )
               FtrPtrFree( CREATOR, i );

       // Second algorithm
       for( fNum=FIRST_FTR_ID ; ; fNum++ )
       {
               UInt32 free ;

               Progress( savedScreen );

               MemHeapFreeBytes( storageHeapId|dbCacheFlag, &free, &size );

               if( size < 500 )
                       break ;

               if( FtrPtrNew( CREATOR, fNum, size, &f) != 0 )
                       break ;

               do {
                       Progress( savedScreen );
                       size += BLOCK_SIZE ;
               }
               while( MemPtrResize(f, size) == 0 ) ;
       }

       for( i=FIRST_FTR_ID ; i < fNum ; i++ )
               FtrPtrFree( CREATOR, i );
}


void GetFlushName( Char* s )
{
   *s++ = 'F';
   *s++ = 'l';
   *s++ = 'u';
   *s++ = 's';
   *s++ = '-';
   *s++ = 't';
   *s++ = 'm';
   *s++ = 'p';
   *s++ = '.';
   *s++ = 'f';
   *s++ = 'l';
   *s++ = 'u';
   *s++ = 's';
   *s++ = 'h';
   *s = 0;
}


// Flushing via DB writes.
// Procedure suitable for all NVFS versions
static void DBFlush( UInt16 storageHeapId, Boolean savedScreen )
{
       #define BLK_SIZE        30000

       UInt32          dbCacheTotal ;
       DmOpenRef       ref = NULL ;

       // Get available DB space.
       // Must be both bellow the DbCache capacity and bellow the free storage space.
       {
               #define MIN_FREE_STORAGE        100000L

               UInt32 free, maxBytes;
               MemHeapFreeBytes( storageHeapId, &free, &maxBytes ) ;
               if( free < MIN_FREE_STORAGE )
                       return ;

               dbCacheTotal = MemHeapSize( storageHeapId|dbCacheFlag );
               if( dbCacheTotal > free )
                       dbCacheTotal = free ;

               dbCacheTotal -= MIN_FREE_STORAGE ;
       }

       // Open tmp recyclable database
       {
               char flushName[ dmDBNameLength ];
               LocalID    dbId;

               GetFlushName( flushName );
               dbId = DmFindDatabase( 0, flushName );
               if( dbId != NULL )
                       DmDeleteDatabase( 0, dbId );

               DmCreateDatabase( 0, flushName, CREATOR, 'temp', false );

               dbId = DmFindDatabase( 0, flushName );
               if( dbId != NULL )
               {
                       //SetRecyclable
                       SetRecyclable( 0, dbId );
                       ref = DmOpenDatabase( 0, dbId, dmModeReadWrite ) ;
                       if( ref == NULL )
                               DmDeleteDatabase( 0, dbId );
               }
       }

       if( ref != NULL )
       {
               // Fill DB records
               Int32 nNeededRecs = dbCacheTotal / BLK_SIZE ;

               while( nNeededRecs-- > 0 )
               {
                       UInt16 location = dmMaxRecordIndex;

                       Progress( savedScreen );

                       if( DmNewRecord( ref, &location, BLK_SIZE) == NULL )
                               break;
               }

               // Cleanup
               {
                       // This would save quite a few seconds (prevents unneeded commit to NVFS),
                       // but does not work on T650.
                       // UInt16 n_recs = DmNumRecords( ref ) ;
                       // while( n_recs-- != 0 )
                       //   DmDeleteRecord( ref, n_recs ) ;

                       DmCloseDatabase( ref ) ;        // This deletes the DB
               }
       }
}


UInt32 CacheSize( UInt32* freeP, UInt32* chunkP )
{
               UInt16 numHeaps = MemNumHeaps(0);
               UInt16 i;
               for( i=0 ; i < numHeaps; i++ )
               {
                       UInt16 heapId = MemHeapID(0, i);

                       if( !MemHeapDynamic(heapId) )
                       {
                               UInt16 heapFlags = MemHeapFlags( heapId ) ;

                               if( (heapFlags & 0x1) == 0 )  // memHeapFlagReadOnly==0x01
                               {
                                    UInt32 free;
                                    UInt32 chunk;

                                    MemHeapFreeBytes( heapId|dbCacheFlag, &free, &chunk );
                                    if ( freeP != NULL )
                                        *freeP = free;
                                    if ( chunkP != NULL )
                                        *chunkP = chunk;
                                    return MemHeapSize( heapId|dbCacheFlag );
                               }
                       }
                }
                return 0;
}



void GetMessage( Char* m )
{
   *m++ = 'F';
   *m++ = 'l';
   *m++ = 'u';
   *m++ = 's';
   *m++ = 'h';
   *m++ = 'i';
   *m++ = 'n';
   *m++ = 'g';
   *m++ = '.';
   *m++ = '.';
   *m++ = '.';
   *m = 0;
}


void DBCacheFlush( Boolean fast )
{
       // Attention!!!
       //
       // No system processing is allowed during DbCache flush. (That's way user abort is not implemented.)
       // Otherwise the OS may negatively influence the results. (Proved on T650.)

               UInt16 numHeaps = MemNumHeaps(0);
               UInt16 i;
               WinHandle oldWinH;
               void* bits;
               RectangleType r;
               Err           err;
               Boolean       savedScreen;

               if ( ! HaveNVFS() )
                   return;

               oldWinH = WinSetDrawWindow( WinGetDisplayWindow() );

               WinGetDrawWindowBounds( &r );

               bits = WinSaveBits( &r, &err );

               if ( err != errNone ) {
                   savedScreen = false;
               }
               else {
                   RectangleType rect;
                   Char          message[ 60 ];
                   Coord         messageSize;

                   savedScreen = true;

                   GetMessage( message );

                   messageSize = FntCharsWidth( message, StrLen( message ) );

                   rect.topLeft.x = 80 - messageSize / 2 - 14;
                   rect.extent.x  = messageSize + 28;
                   rect.topLeft.y = 70-4;
                   rect.extent.y  = 28;

                   WinEraseRectangle( &rect, 0 );
                   WinDrawRectangleFrame( dialogFrame, &rect );

                   WinDrawChars( message, StrLen( message ), 80 - messageSize / 2, 80 - 5 );

               }

               // Get storage heap characteristics
               for( i=0 ; i < numHeaps; i++ )
               {
                       UInt16 heapId = MemHeapID(0, i);

                       if( !MemHeapDynamic(heapId) )
                       {
                               UInt16 heapFlags = MemHeapFlags( heapId ) ;

                               if( (heapFlags & 0x1) == 0 )  // memHeapFlagReadOnly==0x01
                               {
                                       DmSync() ;
                                       if ( ! fast )
                                           DBFlush( heapId, savedScreen ) ;
                                       FtrFlush( heapId, savedScreen ) ;
                                       DmSync() ;
                                       break ;
                               }
                       }
               }

               if ( savedScreen ) {
                   WinRestoreBits( bits, 0, 0 );
                   MemPtrFree( bits );
               }
               WinSetDrawWindow( oldWinH );
}

You are viewing proxied material from 1436.ninja. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.