core/sqf/inc/nsk/nskmem.h - trafodion - Git at Google

 // @@@ START COPYRIGHT @@@
 //
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 //
 // @@@ END COPYRIGHT @@@
 #ifndef _NSKmem_H
 #define _NSKmem_H
 #include "seaquest/sqtypes.h"
 #define DllImport __declspec( dllimport )
 #define DllExport __declspec( dllexport )


 #ifdef NA_64BIT
 // dg64 - these are equivalent, but this one's easier to see
 #pragma pack(push, enter_NSKmem, 4)
 #else
 #pragma pack(push, enter_NSKmem)
 #pragma pack(4)
 #endif

 // forward reference
 typedef class  _NSK_PCB *PNSK_PCB;

 // table header structure.  This struct is negatively indexed
 // from a table pointer.

 typedef struct _TABLE_HEADER {

    DWORD    eyecatcher;
    LIST_ENTRY  freelist;
    DWORD     spin;
    DWORD    type;
    DWORD    index;
    DWORD    pid;            // added by SH - do not change order of these four fields
    DWORD    tid;            //   "
    DWORD    line;           //   "
    char     file[4];        //   "
    DWORD    headertype;
    DWORD    freecount;
    DWORD    fails;
    DWORD    entrysize;
    DWORD    curentries;
    DWORD    maxentries;

   } TABLE_HEADER, *PTABLE_HEADER;

 // to use the standard table routines, each table entry
 // must have the following fields defined .
 // Please note that the inline function PCBPIN( ) requires
 // the following aspects of the TABLE_ENTRY to remain constant,
 // or we will break the FS...
 //    1) The offsets of the LIST_ENTRY and index cannot change.
 //    2) The format of LIST_ENTRY cannot change.
 //    3) The sizeof( TABLE_ENTRY ) cannot change.

 typedef struct _TABLE_ENTRY {

    LIST_ENTRY     list;
    DWORD           spin;        // spin and type have to be consecutive and type
    DWORD          type;        // should follow spin
    DWORD    index;
    DWORD    pid;            // added by SH - do not change order of these four fields
    DWORD    tid;            //   "
    DWORD    line;           //   "
    char     file[4];        //   "
    long           unused[ 3 ];  // For future use...
 } TABLE_ENTRY, *PTABLE_ENTRY;

 // the base class for all NSK control blocks or control structures
 // including but not limited to PCB, QCB and MQCs.  This must
 // agree with the above struct.

 typedef class _NSK_CB{
 public:
    LIST_ENTRY  list;
    DWORD        spin;            // same comments as above...
    DWORD       type;
    DWORD    index;
    union {
        DWORD    pid;        // added by SH - do not change order of these four fields
        DWORD    num_lockget; // number of times we called NSKLockGet
    };
    union {
        DWORD    tid;        //   "
        DWORD    spin_in_first_try; // count of times we get the spin lock on the first try
    };
    union {
        DWORD    line;       //   "
        DWORD    num_spin_tries;  // number of times we tried to get the spin lock
    };
    union {
        char     file[4];    //   "
        DWORD    max_spins;  // high water mark for number of tries of the spin lock before success
    };
    long        unused[ 3 ];
 } NSK_CB, *PNSK_CB;


 //NRL - named resource table header - for msg ports

 #define NRL_HASH_HEADS 32
 #define NRL_HASH_HEADS_MASK ( NRL_HASH_HEADS - 1 )


 typedef struct _NSK_NRL_TABLE_HEADER {

    // hash chain fields

    NSK_CB      hash_spin[ NRL_HASH_HEADS ]; //added by SH
    LIST_ENTRY  hash_heads[ NRL_HASH_HEADS ];

    LONG        spin;
    DWORD       type;
    DWORD       index;
    DWORD       pid;            // added by SH - do not change order of these four fields
    DWORD       tid;            //   "
    DWORD       line;           //   "
    char        file[4];        //   "
    DWORD        headertype;
    LONG        portnamecounter;      // for $X, $Y and $Znnnn names.

    // common table header

    TABLE_HEADER x;

 } NSK_NRL_TABLE_HEADER, *PNSK_NRL_TABLE_HEADER;


 // pool header structure.  This struct is allocated at the
 // beginning of a pool area.

 typedef struct _POOL_HEADER {
     DWORD        eyecatcher;      // 0

     PVOID        poolstart;      // 4
     PVOID        poolend;         // 8
     PVOID        curhigh;         // 12

     LIST_ENTRY    freelist;  // 16
     PVOID        maxhigh;         // 24
     DWORD        curalloc;      // 28
     DWORD        maxalloc;      // 32
     DWORD        failsize;      // 36
    DWORD    fails;        // 40
     DWORD        gets;             // 44
     DWORD        puts;             // 48
     SHORT        curfrag;         // 52
     SHORT        maxfrag;         // 54
     DWORD        poolsize;      // 56
                            // 60
 } POOL_HEADER, *PPOOL_HEADER;

 #define tag_overhead 4L
 //#define min_block_size 32L
 const long min_block_size = 32L;

 typedef struct _BLOCK_HEAD {
     LONG        tag;            // allocated < 0, free > 0

    union {
         LIST_ENTRY    list;        // free: freelist ptrs
         short        data;           // allocated: data
     };

     LONG        endtag;            // allocated < 0, free > 0
 } BLOCK_HEAD, *PBLOCK_HEAD;

 #pragma pack(pop,enter_NSKmem)


   // The free_spin macro is called from NSKmain.cpp in msgsys_cleanup_thread
   // and in NSKport.cpp from NSKQCBDelete while doing cleanup.
 	// if the spin lock is held, then wait for 20 ms and clear it.  The
   // assumption is that if the lock is still held, then it must be an
   // orphan lock as the data structure is being deallocated.
 	// (This seems quite risky, but as yet we don't have an alternative
 	// way to release all the locks held by a process that died.)
 #ifndef __TDM_NONSKLOCKINFO
 #define free_spin( spin, pid )  do {                                                                \
                                 if(spin != 0) {                                                 \
                                     Sleep(20); spin = 0;                                        \
                                     AddLockerInfo(&spin, __LINE__,__NSK_FILE_FOR_UNLOCK__,pid, GetCurrentThreadId());         \
                                 } } while (0)
 #else
 #define free_spin( spin, pid )  do {                                                                \
                                 if(spin != 0) {                                                 \
                                     Sleep(20); spin = 0;                                        \
                                 } } while (0)

 #endif


 //=========================================================================
 // procedure declarations
 //=========================================================================

 #ifndef NSKMem_C

 DllImport
 void * NSKGetFirstInQ ( LIST_ENTRY *phead) ;

 DllImport
 BOOL NSKIsQEmpty( LIST_ENTRY *phead);

 DllImport
 void NSKQueueInit( LIST_ENTRY *phead );

 DllImport
 LONG NSKInsert( LIST_ENTRY *pwhere, LIST_ENTRY *pitem );

 DllImport
 LONG NSKDelete( LIST_ENTRY *pitem );

 DllImport
 PVOID PoolDefine( PVOID PoolPtr, DWORD PoolSize, PLONG error );

 DllImport
 LONG PoolPutSpace( PPOOL_HEADER pph, PVOID pelement, short poolCheck = 0);

 DllImport
 PVOID PoolGetSpace( PPOOL_HEADER pph,
                  DWORD size,
                  DWORD *error, short poolCheck = 0 );

 DllImport // For NSK-Lite use only
 LONG PgPoolPutSpace( PVOID pelement,
                      BOOL halt_on_error = TRUE );
 DllImport // For NSK-Lite use only
 PVOID PgPoolGetSpace( DWORD size,
                       DWORD *error       = NULL,
                       BOOL halt_on_error = TRUE );

 DllImport
 void TestPool( PVOID membase, DWORD length, int maxalloc = 0 );

 DllImport
 PVOID NSKTableSetup( PVOID base,            // base address
                      DWORD headersize,      // bytes in header
                      DWORD entrysize,       // entry size in bytes
                      DWORD entries,         // entries to allocate
                      DWORD maxentries,       // max entries
                      PVOID *nextaddr,      // address after table
                      DWORD headertype,  // type of table header
                      DWORD    type );   // type of data structure
 DllImport
 void RealNSKTablePut( PVOID ptable, PVOID pentry, int line, PCHAR file );

 DllImport
 PVOID RealNSKTableGet( PVOID ptable, int line, PCHAR file );

 DllImport
 DWORD RealNSKLockGet( DWORD * plock, int line, PCHAR file );

 DllImport
 void RealNSKLockPut( DWORD * plock, int line, PCHAR file );

 DllImport
 inline void AddLockerInfo( DWORD *plock, int line, PCHAR file, DWORD pid, DWORD tid );

 DllImport
 BOOL NSKIsPcbLockedBySelf();


 #endif

 #endif
	// @@@ START COPYRIGHT @@@
	//
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.
	//
	// @@@ END COPYRIGHT @@@
	#ifndef _NSKmem_H
	#define _NSKmem_H
	#include "seaquest/sqtypes.h"
	#define DllImport __declspec( dllimport )
	#define DllExport __declspec( dllexport )




	#ifdef NA_64BIT
	// dg64 - these are equivalent, but this one's easier to see
	#pragma pack(push, enter_NSKmem, 4)
	#else
	#pragma pack(push, enter_NSKmem)
	#pragma pack(4)
	#endif

	// forward reference
	typedef class _NSK_PCB *PNSK_PCB;

	// table header structure. This struct is negatively indexed
	// from a table pointer.

	typedef struct _TABLE_HEADER {

	DWORD eyecatcher;
	LIST_ENTRY freelist;
	DWORD spin;
	DWORD type;
	DWORD index;
	DWORD pid; // added by SH - do not change order of these four fields
	DWORD tid; // "
	DWORD line; // "
	char file[4]; // "
	DWORD headertype;
	DWORD freecount;
	DWORD fails;
	DWORD entrysize;
	DWORD curentries;
	DWORD maxentries;

	} TABLE_HEADER, *PTABLE_HEADER;

	// to use the standard table routines, each table entry
	// must have the following fields defined .
	// Please note that the inline function PCBPIN( ) requires
	// the following aspects of the TABLE_ENTRY to remain constant,
	// or we will break the FS...
	// 1) The offsets of the LIST_ENTRY and index cannot change.
	// 2) The format of LIST_ENTRY cannot change.
	// 3) The sizeof( TABLE_ENTRY ) cannot change.

	typedef struct _TABLE_ENTRY {

	LIST_ENTRY list;
	DWORD spin; // spin and type have to be consecutive and type
	DWORD type; // should follow spin
	DWORD index;
	DWORD pid; // added by SH - do not change order of these four fields
	DWORD tid; // "
	DWORD line; // "
	char file[4]; // "
	long unused[ 3 ]; // For future use...
	} TABLE_ENTRY, *PTABLE_ENTRY;

	// the base class for all NSK control blocks or control structures
	// including but not limited to PCB, QCB and MQCs. This must
	// agree with the above struct.

	typedef class _NSK_CB{
	public:
	LIST_ENTRY list;
	DWORD spin; // same comments as above...
	DWORD type;
	DWORD index;
	union {
	DWORD pid; // added by SH - do not change order of these four fields
	DWORD num_lockget; // number of times we called NSKLockGet
	};
	union {
	DWORD tid; // "
	DWORD spin_in_first_try; // count of times we get the spin lock on the first try
	};
	union {
	DWORD line; // "
	DWORD num_spin_tries; // number of times we tried to get the spin lock
	};
	union {
	char file[4]; // "
	DWORD max_spins; // high water mark for number of tries of the spin lock before success
	};
	long unused[ 3 ];
	} NSK_CB, *PNSK_CB;


	//NRL - named resource table header - for msg ports

	#define NRL_HASH_HEADS 32
	#define NRL_HASH_HEADS_MASK ( NRL_HASH_HEADS - 1 )


	typedef struct _NSK_NRL_TABLE_HEADER {

	// hash chain fields

	NSK_CB hash_spin[ NRL_HASH_HEADS ]; //added by SH
	LIST_ENTRY hash_heads[ NRL_HASH_HEADS ];

	LONG spin;
	DWORD type;
	DWORD index;
	DWORD pid; // added by SH - do not change order of these four fields
	DWORD tid; // "
	DWORD line; // "
	char file[4]; // "
	DWORD headertype;
	LONG portnamecounter; // for $X, $Y and $Znnnn names.

	// common table header

	TABLE_HEADER x;

	} NSK_NRL_TABLE_HEADER, *PNSK_NRL_TABLE_HEADER;




	// pool header structure. This struct is allocated at the
	// beginning of a pool area.

	typedef struct _POOL_HEADER {
	DWORD eyecatcher; // 0

	PVOID poolstart; // 4
	PVOID poolend; // 8
	PVOID curhigh; // 12

	LIST_ENTRY freelist; // 16
	PVOID maxhigh; // 24
	DWORD curalloc; // 28
	DWORD maxalloc; // 32
	DWORD failsize; // 36
	DWORD fails; // 40
	DWORD gets; // 44
	DWORD puts; // 48
	SHORT curfrag; // 52
	SHORT maxfrag; // 54
	DWORD poolsize; // 56
	// 60
	} POOL_HEADER, *PPOOL_HEADER;

	#define tag_overhead 4L
	//#define min_block_size 32L
	const long min_block_size = 32L;

	typedef struct _BLOCK_HEAD {
	LONG tag; // allocated < 0, free > 0

	union {
	LIST_ENTRY list; // free: freelist ptrs
	short data; // allocated: data
	};

	LONG endtag; // allocated < 0, free > 0
	} BLOCK_HEAD, *PBLOCK_HEAD;

	#pragma pack(pop,enter_NSKmem)


	// The free_spin macro is called from NSKmain.cpp in msgsys_cleanup_thread
	// and in NSKport.cpp from NSKQCBDelete while doing cleanup.
	// if the spin lock is held, then wait for 20 ms and clear it. The
	// assumption is that if the lock is still held, then it must be an
	// orphan lock as the data structure is being deallocated.
	// (This seems quite risky, but as yet we don't have an alternative
	// way to release all the locks held by a process that died.)
	#ifndef __TDM_NONSKLOCKINFO
	#define free_spin( spin, pid ) do { \
	if(spin != 0) { \
	Sleep(20); spin = 0; \
	AddLockerInfo(&spin, __LINE__,__NSK_FILE_FOR_UNLOCK__,pid, GetCurrentThreadId()); \
	} } while (0)
	#else
	#define free_spin( spin, pid ) do { \
	if(spin != 0) { \
	Sleep(20); spin = 0; \
	} } while (0)

	#endif


	//=========================================================================
	// procedure declarations
	//=========================================================================

	#ifndef NSKMem_C

	DllImport
	void * NSKGetFirstInQ ( LIST_ENTRY *phead) ;

	DllImport
	BOOL NSKIsQEmpty( LIST_ENTRY *phead);

	DllImport
	void NSKQueueInit( LIST_ENTRY *phead );

	DllImport
	LONG NSKInsert( LIST_ENTRY pwhere, LIST_ENTRY pitem );

	DllImport
	LONG NSKDelete( LIST_ENTRY *pitem );

	DllImport
	PVOID PoolDefine( PVOID PoolPtr, DWORD PoolSize, PLONG error );

	DllImport
	LONG PoolPutSpace( PPOOL_HEADER pph, PVOID pelement, short poolCheck = 0);

	DllImport
	PVOID PoolGetSpace( PPOOL_HEADER pph,
	DWORD size,
	DWORD *error, short poolCheck = 0 );

	DllImport // For NSK-Lite use only
	LONG PgPoolPutSpace( PVOID pelement,
	BOOL halt_on_error = TRUE );
	DllImport // For NSK-Lite use only
	PVOID PgPoolGetSpace( DWORD size,
	DWORD *error = NULL,
	BOOL halt_on_error = TRUE );

	DllImport
	void TestPool( PVOID membase, DWORD length, int maxalloc = 0 );

	DllImport
	PVOID NSKTableSetup( PVOID base, // base address
	DWORD headersize, // bytes in header
	DWORD entrysize, // entry size in bytes
	DWORD entries, // entries to allocate
	DWORD maxentries, // max entries
	PVOID *nextaddr, // address after table
	DWORD headertype, // type of table header
	DWORD type ); // type of data structure
	DllImport
	void RealNSKTablePut( PVOID ptable, PVOID pentry, int line, PCHAR file );

	DllImport
	PVOID RealNSKTableGet( PVOID ptable, int line, PCHAR file );

	DllImport
	DWORD RealNSKLockGet( DWORD * plock, int line, PCHAR file );

	DllImport
	void RealNSKLockPut( DWORD * plock, int line, PCHAR file );

	DllImport
	inline void AddLockerInfo( DWORD *plock, int line, PCHAR file, DWORD pid, DWORD tid );

	DllImport
	BOOL NSKIsPcbLockedBySelf();


	#endif

	#endif