fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
97a23295d548d74579bef6ee84f265bb790dd2bc
harbour-core/include/hbvm.h
Przemysław Czerpak 7349602fcb 2014-04-01 12:33 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) 
* src/rtl/filebuf.c
    ! unlock HVM stack before locking local mutex and calling hb_fs*()
      functions which also unlocks HVM. It fixes possible deadlock condition
      when hb_gcAll( .T. ) is executed.

  * include/hbapi.h
  * src/vm/garbage.c
    ! changed mark function semantic.
      Adding support for user defined mark function I created race condition
      in MT GC code. It happens because blocks marked as deleted were not
      scanned by GC mark code so their subitems where not accessible.
      To fix it we have to change mark function semantic. Now mark function
      can be executed also for blocks currently deleted. It means that GC
      block destructor should clean references to just removed items and
      subblocks. The best place to make it is clearing pointers to GC blocks
      just after hb_itemRelease() or hb_gcRefFree().
      It is save to clean the reference just before hb_itemRelease() or
      hb_gcRefFree() but only for the single block passed to these functions.
      It is not save to clear reference to more then one block and then
      execute above functions.
    + check reference count after destructor execution for all blocks
      not only arrays - warning it may exploit some wrong C code.
    - removed not longer used hb_gcRefCheck() function.

  * include/hbvm.h
  * src/vm/hvm.c
    + added new internal function hb_vmLockForce()
    ! fixed to mark GC blocks with active threads

  * src/vm/thread.c
  * include/hbthread.h
    % modified sync mutexes used by xBase++ signal class emulation
      to not use item array internally
    * updated mutex destructor to new GC mark semantic
    ! mark GT items if GT is bound with thread item
    ! fixed mutex notify/subscribe code to not change GC items
      when HVM stack is unlocked
    ! use hb_vmLockForce() to eliminate potential deadlock
    + added new C function hb_threadEnterCriticalSectionGC().
      It should be used instead of hb_threadEnterCriticalSection()
      in code which manipulates GC items inside critical section.
      It's slower but eliminates possible deadlock condition.
      Please remember that remember that both functions cannot
      be used for the same mutex. So if it's necessary to use
      hb_threadEnterCriticalSectionGC() in one place then it
      has to be used in all others when the same mutex is locked.

  * src/vm/arrays.c
  * src/vm/codebloc.c
  * src/vm/hashes.c
  * src/rtl/hbgtcore.c
  * contrib/hbcurl/core.c
  * contrib/hbexpat/core.c
    * updated destructors to new GC mark semantic

  * contrib/hbxpp/dllx.c
    ! fixed destructor for pointer item created by DllPrepareCall()
      Now it respects reference counter.
    ; added note about real behavior of library handle destructor,
      I haven't changed existing code behavior but maybe it should
      be done.

  * contrib/xhb/hbserv.c
  * src/debug/dbgentry.c
  * src/rdd/wacore.c
    ! fixed possible deadlocks by using hb_threadEnterCriticalSectionGC()
      instead of hb_threadEnterCriticalSection().

  * contrib/hbmemio/memio.c
    ! slightly modified hb_memfsDirectory() code to avoid race condition
      without using hb_threadEnterCriticalSectionGC()

  * src/vm/fm.c
    % reduce the lock range in HB_FM_STAT builds

  * src/rtl/hbsocket.c
    ! added missing HVM stack unlocking in hb_socketSelect() function

  * src/rtl/gtxwc/gtxwc.c
    ! added few missing locks for version compiled with HB_XWC_XLIB_NEEDLOCKS

  * src/rdd/dbtotal.prg
    * allow to use symbols instead of codeblocks
    * modified Harbour extension which uses ordKey() as default group
      signature to work also without index. In such case all records
      are summarized into single one.

  ; Most of above modifications were critical for stability of MT programs.
    They should allow to activate GC in any place.
2014-04-01 12:33:17 +02:00

197 lines
12 KiB
C
Raw Blame History

/*
* Harbour Project source code:
* Header file for the Virtual Machine API
*
* Copyright 1999 Antonio Linares <alinares@fivetech.com>
* www - http://harbour-project.org
*
* 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; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but 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 software; see the file COPYING.txt. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
*
* As a special exception, the Harbour Project gives permission for
* additional uses of the text contained in its release of Harbour.
*
* The exception is that, if you link the Harbour libraries with other
* files to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the Harbour library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the Harbour
* Project under the name Harbour. If you copy code from other
* Harbour Project or Free Software Foundation releases into a copy of
* Harbour, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for Harbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
#ifndef HB_VM_H_
#define HB_VM_H_
#include "hbapi.h"
HB_EXTERN_BEGIN
/* Harbour virtual machine init/exit functions */
extern HB_EXPORT void hb_vmInit( HB_BOOL bStartMainProc );
extern HB_EXPORT int hb_vmQuit( void ); /* Immediately quits the virtual machine, return ERRORLEVEL code */
/* registration AtInit, AtExit and AtQuit functions.
* AtInit functions are executed just before .prg INIT procedures.
* AtExit functions are executed just after .prg EXIT procedures.
* AtQuit functions are executed after deallocating all HVM items and
* disabling .prg destructors. They can make final cleanup at C level
* but should not reenter HVM.
*/
extern HB_EXPORT void hb_vmAtInit( HB_INIT_FUNC pFunc, void * cargo );
extern HB_EXPORT void hb_vmAtExit( HB_INIT_FUNC pFunc, void * cargo );
extern HB_EXPORT void hb_vmAtQuit( HB_INIT_FUNC pFunc, void * cargo );
/* Harbour virtual machine functions */
extern HB_EXPORT void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) HB_FLATTEN_ATTR; /* invokes the virtual machine */
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPcodeVer ); /* module symbols initialization with extended information */
extern HB_EXPORT PHB_SYMB hb_vmProcessDynLibSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPcodeVer ); /* module symbols initialization with extended information */
#ifdef _HB_API_INTERNAL_
typedef struct _HB_SYMBOLS
{
PHB_SYMB pModuleSymbols; /* pointer to module symbol table */
HB_USHORT uiModuleSymbols; /* number of symbols on that table */
HB_USHORT uiStaticsOffset; /* ofset of statics base symbol */
struct _HB_SYMBOLS * pNext; /* pointer to the next SYMBOLS structure */
HB_SYMBOLSCOPE hScope; /* scope collected from all symbols in module used to speed initialization code */
void * hDynLib; /* handler to dynamic library */
HB_BOOL fAllocated; /* the symbol table is dynamically allocated and should be freed on HVM exit */
HB_BOOL fActive; /* the symbol table is currently active */
HB_BOOL fInitStatics; /* static initialization should be executed */
char * szModuleName; /* module name */
HB_ULONG ulID; /* module unique identifier */
} HB_SYMBOLS, * PHB_SYMBOLS; /* structure to keep track of all modules symbol tables */
extern PHB_SYMBOLS hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, HB_USHORT uiSymbols, const char * szModuleName, HB_ULONG ulID, HB_BOOL fDynLib, HB_BOOL fClone, HB_BOOL fOverLoad );
extern HB_BOOL hb_vmLockModuleSymbols( void );
extern void hb_vmUnlockModuleSymbols( void );
extern void hb_vmFreeSymbols( PHB_SYMBOLS pSymbols );
extern void hb_vmBeginSymbolGroup( void * hDynLib, HB_BOOL fClone );
extern void hb_vmInitSymbolGroup( void * hNewDynLib, int argc, const char * argv[] );
extern void hb_vmExitSymbolGroup( void * hDynLib );
extern PHB_SYMB hb_vmFindFuncSym( const char * szFuncName, void * hDynLib );
extern const char * hb_vmFindModuleSymbolName( PHB_SYMB pSym );
extern HB_BOOL hb_vmFindModuleSymbols( PHB_SYMB pSym, PHB_SYMB * pSymbols, HB_USHORT * puiSymbols );
extern PHB_SYMB hb_vmGetRealFuncSym( PHB_SYMB pSym );
extern void hb_vmSetFunction( PHB_SYMB pOldSym, PHB_SYMB pNewSym );
extern void hb_vmSetDynFunc( PHB_DYNS pDynSym );
extern void hb_vmEnumRelease( PHB_ITEM pBase, PHB_ITEM pValue );
extern HB_BOOL hb_vmMsgReference( PHB_ITEM pObject, PHB_DYNS pMessage, PHB_DYNS pAccMsg ); /* create extended message reference */
extern void hb_vmUpdateAllocator( PHB_ALLOCUPDT_FUNC pFunc, int iCount );
extern void hb_vmEval( HB_USHORT uiParams );
#endif
extern void hb_vmSetExceptionHandler( void );
extern void hb_vmUnsetExceptionHandler( void );
extern HB_EXPORT void hb_vmSymbolInit_RT( void ); /* initialization of runtime support symbols */
/* Harbour virtual machine escaping API */
extern HB_EXPORT void hb_vmRequestDebug( void );
extern HB_EXPORT void hb_vmRequestBreak( PHB_ITEM pItem );
extern HB_EXPORT void hb_vmRequestCancel( void );
extern HB_EXPORT void hb_vmRequestQuit( void );
extern HB_EXPORT void hb_vmRequestEndProc( void );
extern HB_EXPORT HB_USHORT hb_vmRequestQuery( void );
extern HB_EXPORT HB_BOOL hb_vmRequestReenter( void );
extern HB_EXPORT void hb_vmRequestRestore( void );
extern HB_EXPORT HB_BOOL hb_vmRequestReenterExt( void );
extern HB_EXPORT HB_BOOL hb_vmIsActive( void );
extern HB_EXPORT HB_BOOL hb_vmIsReady( void );
/* Return values of hb_vmRequestQuery() */
#define HB_QUIT_REQUESTED 1 /* immediately quit the application */
#define HB_BREAK_REQUESTED 2 /* break to nearest RECOVER/END sequence */
#define HB_ENDPROC_REQUESTED 4 /* immediately return from procedure (error handler in macro evaluation) */
#ifdef _HB_API_INTERNAL_
#define HB_VMSTACK_REQUESTED 0x100 /* inetrnel flag to signal thread local stack */
#endif
/* Public PCode functions */
/* Execution */
extern HB_EXPORT void hb_vmDo( HB_USHORT uiParams ); /* invoke the virtual machine */
extern HB_EXPORT void hb_vmProc( HB_USHORT uiParams ); /* executes a function or procedure */
extern HB_EXPORT void hb_vmFunction( HB_USHORT uiParams ); /* executes a function */
extern HB_EXPORT void hb_vmSend( HB_USHORT uiParams ); /* sends a message to an object */
extern HB_EXPORT PHB_ITEM hb_vmEvalBlock( PHB_ITEM pBlockItem ); /* executes passed codeblock with no arguments */
/* executes passed codeblock with variable number of arguments */
extern HB_EXPORT PHB_ITEM hb_vmEvalBlockV( PHB_ITEM pBlockItem, HB_ULONG ulArgCount, ... );
extern HB_EXPORT PHB_ITEM hb_vmEvalBlockOrMacro( PHB_ITEM pItem ); /* executes codeblock or macro pointed by given item */
extern HB_EXPORT void hb_vmDestroyBlockOrMacro( PHB_ITEM pItem ); /* destroy codeblock or macro in given item */
/* Push */
extern HB_EXPORT void hb_vmPush( PHB_ITEM pItem ); /* pushes a generic item onto the stack */
extern HB_EXPORT void hb_vmPushNil( void ); /* in this case it places nil at self */
extern HB_EXPORT void hb_vmPushNumber( double dNumber, int iDec ); /* pushes a number on to the stack and decides if it is integer, long or double */
extern HB_EXPORT void hb_vmPushInteger( int iNumber ); /* pushes a integer number onto the stack */
extern HB_EXPORT void hb_vmPushLong( long lNumber ); /* pushes a long number onto the stack */
extern HB_EXPORT void hb_vmPushDouble( double dNumber, int iDec ); /* pushes a double number onto the stack */
extern HB_EXPORT void hb_vmPushSize( HB_ISIZ nNumber ); /* pushes a HB_SIZE number onto the stack */
extern HB_EXPORT void hb_vmPushNumInt( HB_MAXINT nNumber ); /* pushes a number on to the stack and decides if it is integer or HB_MAXINT */
extern HB_EXPORT void hb_vmPushLogical( HB_BOOL bValue ); /* pushes a logical value onto the stack */
extern HB_EXPORT void hb_vmPushString( const char * szText, HB_SIZE length ); /* pushes a string on to the stack */
extern HB_EXPORT void hb_vmPushStringPcode( const char * szText, HB_SIZE length ); /* pushes a string from pcode on to the stack */
extern HB_EXPORT void hb_vmPushDate( long lDate ); /* pushes a long date onto the stack */
extern HB_EXPORT void hb_vmPushTimeStamp( long lJulian, long lMilliSec ); /* pushes two long value as timestamp onto the stack */
extern HB_EXPORT void hb_vmPushSymbol( PHB_SYMB pSym ); /* pushes a function pointer onto the stack */
extern HB_EXPORT void hb_vmPushDynSym( PHB_DYNS pDynSym ); /* pushes a function/method pointer onto the stack */
extern HB_EXPORT void hb_vmPushEvalSym( void ); /* pushes a codeblock eval symbol onto the stack */
extern HB_EXPORT void hb_vmPushPointer( void * pPointer ); /* push an item of HB_IT_POINTER type */
extern HB_EXPORT void hb_vmPushPointerGC( void * pPointer ); /* push an item of GC HB_IT_POINTER type */
extern HB_EXPORT void hb_vmPushItemRef( PHB_ITEM pItem ); /* push item reference */
extern HB_EXPORT HB_BOOL hb_vmIsMt( void ); /* return HB_TRUE if HVM is compiled with thread support */
extern HB_EXPORT void hb_vmLock( void ); /* lock VM blocking GC execution by other threads */
extern HB_EXPORT void hb_vmLockForce( void ); /* lock VM blocking GC execution by other threads, ignore GC request */
extern HB_EXPORT void hb_vmUnlock( void ); /* unlock VM, allow GC execution */
#ifdef _HB_API_INTERNAL_
extern HB_EXPORT HB_BOOL hb_vmSuspendThreads( HB_BOOL fWait ); /* (try to) stop all threads except current one */
extern HB_EXPORT void hb_vmResumeThreads( void ); /* unblock execution of threads stopped by hb_vmSuspendThreads() */
#endif
extern HB_EXPORT HB_BOOL hb_vmThreadRegister( void * ); /* Register new thread without local thread HVM stack */
extern HB_EXPORT void hb_vmThreadRelease( void * ); /* Remove registered thread which does not have local thread HVM stack yet */
extern HB_EXPORT void hb_vmThreadInit( void * ); /* allocate local thread HVM stack */
extern HB_EXPORT void hb_vmThreadQuit( void ); /* destroy local thread HVM stack */
extern HB_EXPORT void hb_vmThreadQuitRequest( void * ); /* send QUIT request to given thread */
extern HB_EXPORT void hb_vmWaitForThreads( void ); /* wait for all threads to terminate can be called only by main HVM thread */
extern HB_EXPORT void hb_vmTerminateThreads( void ); /* send QUIT request to all threads except current one and wait for their termination, should be called only by main HVM thread */
extern HB_EXPORT PHB_ITEM hb_vmThreadStart( HB_ULONG ulAttr, PHB_CARGO_FUNC pThreadFunc, void * cargo ); /* create new thread with HVM stack */
extern HB_EXPORT void * hb_vmThreadState( void );
HB_EXTERN_END
#endif /* HB_VM_H_ */
Reference in New Issue View Git Blame Copy Permalink