sedna 0.5.1 → 0.6.0

data/vendor/sedna/kernel/common/base.cpp

@@ -0,0 +1,339 @@
+/*
+ * File:  base.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#include <fstream>
+#include "common/base.h"
+#include "common/u/ugnames.h"
+#include "common/u/uhdd.h"
+#include "common/u/uprocess.h"
+#include "common/errdbg/d_printf.h"
+#include "common/u/uutils.h"
+
+using namespace std;
+
+void  *LAYER_ADDRESS_SPACE_START_ADDR     = NULL;
+void  *LAYER_ADDRESS_SPACE_BOUNDARY       = NULL;
+__uint32 LAYER_ADDRESS_SPACE_START_ADDR_INT = 0;
+__uint32 LAYER_ADDRESS_SPACE_BOUNDARY_INT   = 0;
+
+__uint32 LAYER_ADDRESS_SPACE_SIZE           = 0;
+
+FILE* res_os = stdout; //otput stream of transaction results (result of the user's query)
+
+/*	global names */ 
+
+#define POLICY_SINGLETON()				NULL,1
+#define POLICY_INSTANCE_PER_DB()		"DB",(MAX_DBS_NUMBER)
+#define POLICY_INSTANCE_PER_SESSION()	"SES",(UPPER_SESSIONS_NUM_BOUND)
+
+/*	If you want to add a new global IPC object, do it here.
+	We are going to extract basenames automaticly, so don't 
+	try anything unusual below and preserve markers. */
+static UGlobalNamesRegistryItem globalNamesRegistry[] =
+{
+	/* {% GlobalNamesRegistry */ 
+	{"SHMEM_GLOBAL",					POLICY_SINGLETON()}, /* vmm region info + VMM placeholder when no buffer mapped */ 
+	
+	{"SHMEM_GOV",						POLICY_SINGLETON()}, /* holding system state and config info (gov_config_struct) */ 
+	
+	{"SHMEM_EVENT_LOG",					POLICY_SINGLETON()}, /* event logger */ 
+	{"SEMAR_EVENT_LOG",					POLICY_SINGLETON()}, /* event logger  */ 
+
+	{"SHMEM_BUFFERS",					POLICY_INSTANCE_PER_DB()}, /* buffer memory */  
+	{"SEMAP_BUFMGR_EXCL_MODE",			POLICY_INSTANCE_PER_DB()}, /* regulates the exclusive mode entering by TRN */ 
+	{"SHMEM_BUFFERS_LRU",				POLICY_INSTANCE_PER_DB()}, /* LRU stats on buffers usage */ 
+
+//    {"SHMEM_SHARED_HEAP",               POLICY_INSTANCE_PER_DB()}, /* shared heap */
+    {"SEMAP_CATALOG_NAMETABLES",        POLICY_INSTANCE_PER_DB()}, /* catalog nametables lock */
+    {"SEMAP_CATALOG_METADATA",          POLICY_INSTANCE_PER_DB()}, /* catalog metadata lock */
+
+	{"SHMEM_SM_TALK",					POLICY_INSTANCE_PER_DB()}, /* used by shared memory-based SM messaging interface */ 
+	{"SEMAR_SM_TALK",					POLICY_INSTANCE_PER_DB()}, /* used by shared memory-based SM messaging interface */ 
+
+	{"SEMAP_VMM_INIT",					POLICY_INSTANCE_PER_DB()}, /* VMM initialisation is serialised with this sem */ 
+	{"SHMEM_VMM_CALLBACK_PARAMS",		POLICY_INSTANCE_PER_DB()}, /* parameters passed to VMM calback */ 
+	{"EVENT_VMM_CALLBACK",				POLICY_INSTANCE_PER_SESSION()}, /* VMM callback thread waits on it */ 
+	{"EVENT_VMM_CALLBACK_COMPLETED",	POLICY_INSTANCE_PER_SESSION()}, /* sem for callback thread to signal call completion */ 
+
+//	{"SEMAP_METADATA",					POLICY_INSTANCE_PER_DB()}, /* synchronises access to metadata registry in PH */
+//	{"SEMAP_INDICES",					POLICY_INSTANCE_PER_DB()}, /* synchronises access to indices registry in PH */
+//	{"SEMAP_FT_INDICES",				POLICY_INSTANCE_PER_DB()}, /* synchronises access to full-text indices registry in PH */
+//	{"SEMAP_TRIGGERS",					POLICY_INSTANCE_PER_DB()}, /* synchronises access to triggers registry in PH */
+
+	{"SEMAP_LOCKMGR",					POLICY_INSTANCE_PER_DB()}, /* serialises requests to lock manager (in SM) */ 
+	{"EVENT_LOCK_GRANTED",				POLICY_INSTANCE_PER_SESSION()}, /* if transaction request for a lock on DB entity is not satisfied immediately trn waits until the event is signalled (hence if transaction enters the wait state, it can't become a victim for the deadlock-resolution process) */ 
+
+	{"SEMAP_TRN_REGULATION",			POLICY_INSTANCE_PER_DB()}, /* currently if checkpoint is active no updater transactions are allowed and vice-versa (earlier mutual exclusion applied to micro-ops but not transactions) */ 
+	{"EVENT_NEW_JOB_4_CHECKPOINT_THREAD", POLICY_INSTANCE_PER_DB()}, /* signals that a checkpoint must be activated or snapshots must be advanced */ 
+	{"EVENT_READONLY_TRN_COMPLETED",	POLICY_INSTANCE_PER_DB()}, /* signals read-only transaction completion */ 
+
+	{"SHMEM_LFS",						POLICY_INSTANCE_PER_DB()}, /* lfs state & buffer in shared memory */ 
+	{"SEMAP_LFS",						POLICY_INSTANCE_PER_DB()}, /* synchronises operation with lfs */ 
+    {"SEMAP_CHECKPOINT_FINISHED",       POLICY_INSTANCE_PER_DB()}, /* to wait for checkpoint to finish */ 
+
+	{"SHMEM_LOGICAL_LOG",				POLICY_INSTANCE_PER_DB()}, /* logical log state & buffer in shared memory */
+	{"SEMAP_LOGICAL_LOG",				POLICY_INSTANCE_PER_DB()}, /* synchronises operation with logical log */ 
+
+	{"EVENT_SM_SHUTDOWN_COMMAND",		POLICY_INSTANCE_PER_DB()}, /* signaled by SSMMsg thread in SM when shutdown command arrives via messaging interface */ 
+
+	{"EVENT_RECOVERY_COMPLETED",		POLICY_INSTANCE_PER_DB()}, /* signaled when se_rcv completes the recovery */ 
+
+	{"SEMAP_TRNS_TABLE",				POLICY_INSTANCE_PER_DB()}, /* synchronises access to transactions table in SM */ 
+
+	{"EVENT_SM_READY",					POLICY_INSTANCE_PER_DB()}, /* used to signal initialisation completion when starting SM in the background mode */ 
+
+	{"EVENT_GOV_READY",					POLICY_SINGLETON()}, /* used to signal initialisation completion when starting GOV in the background mode */ 
+
+	/* %} */ 
+	{NULL}
+};
+
+void InitGlobalNames(int rangeBegin, int rangeEnd)
+{
+	UInitGlobalNamesRegistry(globalNamesRegistry, NULL, rangeBegin, rangeEnd);
+}
+
+void ReleaseGlobalNames()
+{
+	UReleaseGlobalNamesRegistry();
+}
+
+global_name CreateNameOfSmTalk(int databaseId, char *buf, size_t bufSize)
+{
+	const char *namesVec[2];
+	char bufa[128], bufb[128];
+
+	namesVec[0] = UCreateGlobalName("SHMEM_SM_TALK", databaseId, bufa, 128);
+	namesVec[1] = UCreateGlobalName("SEMAR_SM_TALK", databaseId, bufb, 128);
+	
+	return UCreateCompoundName(namesVec, 2, buf, bufSize);
+}
+
+global_name CreateNameOfEventVmmCalback(int sessionId, char *buf, size_t bufSize)
+{
+	return UCreateGlobalName("EVENT_VMM_CALLBACK", sessionId, buf, bufSize);
+}
+
+global_name CreateNameOfEventVmmCalbackCompleted(int sessionId, char *buf, size_t bufSize)
+{
+	return UCreateGlobalName("EVENT_VMM_CALLBACK_COMPLETED", sessionId, buf, bufSize);
+}
+
+global_name CreateNameOfEventLockGranted(int sessionId, char *buf, size_t bufSize)
+{
+	return UCreateGlobalName("EVENT_LOCK_GRANTED", sessionId, buf, bufSize);
+}
+
+/* empty string is invalid as a global name but NULL is valid, so we use empty string as initializer  */ 
+global_name GOVERNOR_SHARED_MEMORY_NAME = "";
+global_name CHARISMA_GOVERNOR_IS_READY = "";
+global_name SE_EVENT_LOG_SHARED_MEMORY_NAME = "";
+global_name SE_EVENT_LOG_SEMAPHORES_NAME = "";
+global_name SEDNA_GLOBAL_MEMORY_MAPPING = "";
+
+void SetGlobalNames()
+{
+	static char 
+		GOVERNOR_SHARED_MEMORY_NAME__buf__		[128],
+		CHARISMA_GOVERNOR_IS_READY__buf__		[128],
+		SE_EVENT_LOG_SHARED_MEMORY_NAME__buf__	[128],
+		SE_EVENT_LOG_SEMAPHORES_NAME__buf__		[128],
+		SEDNA_GLOBAL_MEMORY_MAPPING__buf__		[128];
+
+	GOVERNOR_SHARED_MEMORY_NAME = 
+		UCreateGlobalName("SHMEM_GOV", 0, GOVERNOR_SHARED_MEMORY_NAME__buf__, 128);
+
+	CHARISMA_GOVERNOR_IS_READY = 
+		UCreateGlobalName("EVENT_GOV_READY", 0, CHARISMA_GOVERNOR_IS_READY__buf__, 128);
+
+	SE_EVENT_LOG_SHARED_MEMORY_NAME = 
+		UCreateGlobalName("SHMEM_EVENT_LOG", 0, SE_EVENT_LOG_SHARED_MEMORY_NAME__buf__, 128);
+
+	SE_EVENT_LOG_SEMAPHORES_NAME = 
+		UCreateGlobalName("SEMAR_EVENT_LOG", 0, SE_EVENT_LOG_SEMAPHORES_NAME__buf__, 128);
+
+	SEDNA_GLOBAL_MEMORY_MAPPING = 
+		UCreateGlobalName("SHMEM_GLOBAL", 0, SEDNA_GLOBAL_MEMORY_MAPPING__buf__, 128);
+}
+
+/* empty string is invalid as a global name but NULL is valid, so we use empty string as initializer  */ 
+global_name CHARISMA_SM_CALLBACK_SHARED_MEMORY_NAME = "";
+global_name CHARISMA_BUFFER_SHARED_MEMORY_NAME = "";
+global_name VMM_SM_SEMAPHORE_STR = "";
+global_name VMM_SM_EXCLUSIVE_MODE_SEM_STR = "";
+global_name SNAPSHOT_CHECKPOINT_EVENT = "";
+global_name TRY_ADVANCE_SNAPSHOT_EVENT = "";
+
+global_name CATALOG_NAMETABLE_SEMAPHORE_STR;
+global_name CATALOG_MASTER_SEMAPHORE_STR;
+
+//global_name METADATA_SEMAPHORE_STR = "";
+//global_name INDEX_SEMAPHORE_STR = "";
+//global_name FT_INDEX_SEMAPHORE_STR = "";
+//global_name TRIGGER_SEMAPHORE_STR = "";
+
+global_name SEDNA_LFS_SEM_NAME = "";
+global_name SEDNA_LFS_SHARED_MEM_NAME = "";
+global_name CHARISMA_LOGICAL_LOG_SHARED_MEM_NAME = "";
+global_name CHARISMA_LOGICAL_LOG_PROTECTION_SEM_NAME = "";
+global_name CHARISMA_CHECKPOINT_SEM = "";
+global_name SEDNA_CHECKPOINT_FINISHED_SEM = "";
+global_name SEDNA_TRNS_FINISHED = "";
+global_name CHARISMA_WAIT_FOR_CHECKPOINT = "";
+global_name CHARISMA_DB_RECOVERED_BY_LOGICAL_LOG = "";
+global_name CHARISMA_SYNC_TRN_IDS_TABLE = "";
+global_name CHARISMA_SM_WAIT_FOR_SHUTDOWN = "";
+global_name CHARISMA_LRU_STAMP_SHARED_MEMORY_NAME = "";
+global_name SEDNA_LOCK_MANAGER_SEM = "";
+global_name CHARISMA_SM_SMSD_ID = "";
+global_name CHARISMA_SM_IS_READY = "";
+
+void SetGlobalNamesDB(int databaseId)
+{
+	static char
+		CHARISMA_SM_CALLBACK_SHARED_MEMORY_NAME__buf__  [128],
+		CHARISMA_BUFFER_SHARED_MEMORY_NAME__buf__		[128],
+		VMM_SM_SEMAPHORE_STR__buf__						[128],
+		VMM_SM_EXCLUSIVE_MODE_SEM_STR__buf__			[128],
+		SNAPSHOT_CHECKPOINT_EVENT__buf__				[128],
+        SEDNA_CHECKPOINT_FINISHED_SEM__buf__			[128],
+//		METADATA_SEMAPHORE_STR__buf__					[128],
+//		INDEX_SEMAPHORE_STR__buf__						[128],
+//		FT_INDEX_SEMAPHORE_STR__buf__					[128],
+//		TRIGGER_SEMAPHORE_STR__buf__					[128],
+        CATALOG_NAMETABLE_SEMAPHORE_STR__buf__          [128],
+        CATALOG_MASTER_SEMAPHORE_STR__buf__             [128],
+		SEDNA_LFS_SEM_NAME__buf__                       [128],
+		SEDNA_LFS_SHARED_MEM_NAME__buf__                [128],
+		CHARISMA_LOGICAL_LOG_SHARED_MEM_NAME__buf__		[128],
+		CHARISMA_LOGICAL_LOG_PROTECTION_SEM_NAME__buf__	[128],
+		SEDNA_TRNS_FINISHED__buf__						[128],
+        TRY_ADVANCE_SNAPSHOT_EVENT__buf__               [128],
+        CHARISMA_DB_RECOVERED_BY_LOGICAL_LOG__buf__		[128],
+		CHARISMA_SYNC_TRN_IDS_TABLE__buf__				[128],
+		CHARISMA_SM_WAIT_FOR_SHUTDOWN__buf__			[128],
+		CHARISMA_LRU_STAMP_SHARED_MEMORY_NAME__buf__	[128],
+		SEDNA_LOCK_MANAGER_SEM__buf__					[128],
+		CHARISMA_SM_IS_READY__buf__						[128];
+
+	CHARISMA_SM_CALLBACK_SHARED_MEMORY_NAME = 
+		UCreateGlobalName("SHMEM_VMM_CALLBACK_PARAMS", databaseId, CHARISMA_SM_CALLBACK_SHARED_MEMORY_NAME__buf__, 128);
+
+	CHARISMA_BUFFER_SHARED_MEMORY_NAME =
+		UCreateGlobalName("SHMEM_BUFFERS", databaseId, CHARISMA_BUFFER_SHARED_MEMORY_NAME__buf__, 128);
+
+	VMM_SM_SEMAPHORE_STR =
+		UCreateGlobalName("SEMAP_VMM_INIT", databaseId, VMM_SM_SEMAPHORE_STR__buf__, 128);
+
+	VMM_SM_EXCLUSIVE_MODE_SEM_STR =
+		UCreateGlobalName("SEMAP_BUFMGR_EXCL_MODE", databaseId, VMM_SM_EXCLUSIVE_MODE_SEM_STR__buf__, 128);
+
+	SNAPSHOT_CHECKPOINT_EVENT =
+		UCreateGlobalName("EVENT_NEW_JOB_4_CHECKPOINT_THREAD", databaseId, SNAPSHOT_CHECKPOINT_EVENT__buf__, 128);
+
+	TRY_ADVANCE_SNAPSHOT_EVENT =
+		UCreateGlobalName("EVENT_READONLY_TRN_COMPLETED", databaseId, TRY_ADVANCE_SNAPSHOT_EVENT__buf__, 128);
+
+    SEDNA_CHECKPOINT_FINISHED_SEM = 
+        UCreateGlobalName("SEMAP_CHECKPOINT_FINISHED", databaseId, SEDNA_CHECKPOINT_FINISHED_SEM__buf__, 128);
+/*
+
+	METADATA_SEMAPHORE_STR =
+		UCreateGlobalName("SEMAP_METADATA", databaseId, METADATA_SEMAPHORE_STR__buf__, 128);
+
+	INDEX_SEMAPHORE_STR =
+		UCreateGlobalName("SEMAP_INDICES", databaseId, INDEX_SEMAPHORE_STR__buf__, 128);
+
+	FT_INDEX_SEMAPHORE_STR =
+		UCreateGlobalName("SEMAP_FT_INDICES", databaseId, FT_INDEX_SEMAPHORE_STR__buf__, 128);
+
+	TRIGGER_SEMAPHORE_STR =
+		UCreateGlobalName("SEMAP_TRIGGERS", databaseId, TRIGGER_SEMAPHORE_STR__buf__, 128);
+*/
+
+    CATALOG_NAMETABLE_SEMAPHORE_STR =
+        UCreateGlobalName("SEMAP_CATALOG_NAMETABLES", databaseId, CATALOG_NAMETABLE_SEMAPHORE_STR__buf__, 128);
+
+    CATALOG_MASTER_SEMAPHORE_STR =
+        UCreateGlobalName("SEMAP_CATALOG_METADATA", databaseId, CATALOG_MASTER_SEMAPHORE_STR__buf__, 128);
+
+	SEDNA_LFS_SEM_NAME =
+		UCreateGlobalName("SEMAP_LFS", databaseId, SEDNA_LFS_SEM_NAME__buf__, 128);
+
+	SEDNA_LFS_SHARED_MEM_NAME =
+		UCreateGlobalName("SHMEM_LFS", databaseId, SEDNA_LFS_SHARED_MEM_NAME__buf__, 128);
+
+	CHARISMA_LOGICAL_LOG_SHARED_MEM_NAME =
+		UCreateGlobalName("SHMEM_LOGICAL_LOG", databaseId, CHARISMA_LOGICAL_LOG_SHARED_MEM_NAME__buf__, 128);
+
+	CHARISMA_LOGICAL_LOG_PROTECTION_SEM_NAME =
+		UCreateGlobalName("SEMAP_LOGICAL_LOG", databaseId, CHARISMA_LOGICAL_LOG_PROTECTION_SEM_NAME__buf__, 128);
+
+	SEDNA_TRNS_FINISHED =
+		UCreateGlobalName("SEMAP_TRN_REGULATION", databaseId, SEDNA_TRNS_FINISHED__buf__, 128);
+
+	CHARISMA_DB_RECOVERED_BY_LOGICAL_LOG =
+		UCreateGlobalName("EVENT_RECOVERY_COMPLETED", databaseId, CHARISMA_DB_RECOVERED_BY_LOGICAL_LOG__buf__, 128);
+
+	CHARISMA_SYNC_TRN_IDS_TABLE =
+		UCreateGlobalName("SEMAP_TRNS_TABLE", databaseId, CHARISMA_SYNC_TRN_IDS_TABLE__buf__, 128);
+
+	CHARISMA_SM_WAIT_FOR_SHUTDOWN =
+		UCreateGlobalName("EVENT_SM_SHUTDOWN_COMMAND", databaseId, CHARISMA_SM_WAIT_FOR_SHUTDOWN__buf__, 128);
+
+	CHARISMA_LRU_STAMP_SHARED_MEMORY_NAME =
+		UCreateGlobalName("SHMEM_BUFFERS_LRU", databaseId, CHARISMA_LRU_STAMP_SHARED_MEMORY_NAME__buf__, 128);
+
+	SEDNA_LOCK_MANAGER_SEM =
+		UCreateGlobalName("SEMAP_LOCKMGR", databaseId, SEDNA_LOCK_MANAGER_SEM__buf__, 128);
+
+	CHARISMA_SM_IS_READY =
+		UCreateGlobalName("EVENT_SM_READY", databaseId, CHARISMA_SM_IS_READY__buf__, 128);
+};
+
+
+/* The following chars are allowed:
+ * ! (0x21), # (0x23), % (0x25), & (0x26), ( (0x28), ) (0x29),
+ * + (0x2B), , (0x2C), - (0x2D), . (0x2E), 0-9 (0x30 - 0x39),
+ * ; (0x3B), = (0x3D), @ (0x40), A-Z (0x41-0x5A), [ (5B), ] (5D),
+ * ^ (0x5E), _ (0x5F), ` (0x60), a-z (0x61-0x7A), { (0x7B), 
+ * } (0x7D), ~ (0x7E) */
+static const unsigned char 
+database_name_map[16] = {0x00, 0x00, 0x00, 0x00,
+                         0x56, 0xDE, 0xFF, 0xD4,
+                         0xFF, 0xFF, 0xFF, 0xF7,
+                         0xFF, 0xFF, 0xFF, 0xF6};
+
+
+/* Is char is allowed within a database name  */
+#define DATABASE_NAME_ALLOWED_BYTE(byte) \
+    ((byte) & 0x80 ? 0 : (database_name_map[((byte) >> 3)] & (0x80 >> ((byte) & 7))))
+
+
+void check_db_name_validness(const char* name) 
+{
+    if (NULL == name)  
+        throw USER_EXCEPTION2(SE1003, 
+            "database name validation failed (null database name was given)");
+    
+    int len     = strlen(name);
+    int counter = 0;
+
+    /* Name must contain at least one symbol and its length must
+     * be less or equal than MAX_DATABASE_NAME_LENGTH */
+    if (len < 1 || len > MAX_DATABASE_NAME_LENGTH) 
+        throw USER_EXCEPTION2(SE4307, "empty or too long database name");
+
+    while(counter < len)
+    {
+        unsigned char c = name[counter];
+        if(DATABASE_NAME_ALLOWED_BYTE(c))
+            counter++;
+        else
+            throw USER_EXCEPTION2(SE4307, name);
+    }
+}
+

data/vendor/sedna/kernel/common/base.h

@@ -0,0 +1,226 @@
+/*
+ * File:  base.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _BASE_H
+#define _BASE_H
+
+#include <string>
+#include <vector>
+
+#include "common/sedna.h"
+
+#include "common/utils.h"
+#include "common/rcv_test.h"
+#include "common/wutypes.h"
+
+
+#define SEDNA_DATA_STRUCTURES_VER 9
+
+// buffer memory offset; this type is used for addressing buffers in buffer
+// memory area by defining offset of buffer from the beginning of the shared
+// memory
+typedef int ramoffs;
+#define RAMOFFS_OUT_OFF_BOUNDS                          INT_MAX
+
+//typedef __int64 LSN;
+//typedef long LSN;
+//typedef __int64 LONG_LSN;
+typedef __uint32 CP_counter;
+//#define  NULL_LSN (-1)
+#define  NULL_FILE (-1)
+
+#define MAX_FILE_SIZE_WITHOUT_CHECKPOINT 50*(1024*1024)
+
+
+#define SEDNA_NAMESPACE_URI     "http://www.modis.ispras.ru/sedna"
+#define SEDNA_NAMESPACE_PREFIX  "se"
+
+typedef int session_id;
+
+/**
+ * Transaction identifier
+ */
+typedef int transaction_id;
+
+#define MAX_RESOURCE_NAME_LENGTH                100
+#define MAX_DATABASE_NAME_LENGTH                100
+
+
+/* shift in the block */
+typedef unsigned short int shft;
+
+#define PAGE_SIZE                               65536
+#define PAGE_BIT_SIZE                           16
+#define PAGE_BIT_MASK                           (__uint32)0xFFFF0000
+#define PAGE_REVERSE_BIT_MASK                   (__uint32)0x0000FFFF
+
+
+extern void  *LAYER_ADDRESS_SPACE_START_ADDR;
+extern void  *LAYER_ADDRESS_SPACE_BOUNDARY;
+extern uint32_t LAYER_ADDRESS_SPACE_START_ADDR_INT;
+extern uint32_t LAYER_ADDRESS_SPACE_BOUNDARY_INT;
+
+extern uint32_t LAYER_ADDRESS_SPACE_SIZE;
+
+struct vmm_region_values
+{
+    __uint32 LAYER_ADDRESS_SPACE_START_ADDR_INT;
+    __uint32 LAYER_ADDRESS_SPACE_BOUNDARY_INT;
+    __uint32 LAYER_ADDRESS_SPACE_SIZE;
+};
+
+#define VMM_REGION_SEARCH_MAX_SIZE                      ((__uint32)0x79C00000)
+#define VMM_REGION_MIN_SIZE                             ((__uint32)0x4000000)
+#define VMM_REGION_MAX_SIZE                             ((__uint32)0x40000000)
+
+#define TR_AUTHENTICATION_FLAG 1
+#define TR_AUTHORIZATION_FLAG  2
+
+#ifdef _WIN32
+#define SESSION_EXE "se_trn.exe"
+#else
+#define SESSION_EXE "se_trn"
+#endif
+
+
+#define MODULES_COLLECTION_NAME "$modules"
+
+/*
+	Global Names section */
+
+void InitGlobalNames(int rangeBegin, int rangeEnd);
+
+void ReleaseGlobalNames();
+
+global_name CreateNameOfSmTalk(int databaseId, char *buf, size_t bufSize);
+
+global_name CreateNameOfEventVmmCalback(int sessionId, char *buf, size_t bufSize);
+
+global_name CreateNameOfEventVmmCalbackCompleted(int sessionId, char *buf, size_t bufSize);
+
+global_name CreateNameOfEventLockGranted(int sessionId, char *buf, size_t bufSize);
+
+void SetGlobalNames();
+
+void SetGlobalNamesDB(int databaseId);
+
+#define SM_TO_VMM_CALLBACK_SEM1_BASE_STR(SID,BUF,BUFSZ) \
+	CreateNameOfEventVmmCalback((SID),(BUF),(BUFSZ))
+
+#define SM_TO_VMM_CALLBACK_SEM2_BASE_STR(SID,BUF,BUFSZ) \
+	CreateNameOfEventVmmCalbackCompleted((SID),(BUF),(BUFSZ))
+
+#define SEDNA_TRANSACTION_LOCK(SID,BUF,BUFSZ) \
+	CreateNameOfEventLockGranted((SID),(BUF),(BUFSZ))
+
+#define CHARISMA_SSMMSG_SM_ID(DB,BUF,BUFSZ) \
+	CreateNameOfSmTalk((DB),(BUF),(BUFSZ))
+
+extern global_name CHARISMA_BUFFER_SHARED_MEMORY_NAME;
+extern global_name SEDNA_GLOBAL_MEMORY_MAPPING;
+extern global_name CHARISMA_SM_CALLBACK_SHARED_MEMORY_NAME;
+extern global_name VMM_SM_SEMAPHORE_STR;
+extern global_name VMM_SM_EXCLUSIVE_MODE_SEM_STR;
+extern global_name SNAPSHOT_CHECKPOINT_EVENT;
+extern global_name TRY_ADVANCE_SNAPSHOT_EVENT;
+
+extern global_name CATALOG_NAMETABLE_SEMAPHORE_STR;
+extern global_name CATALOG_MASTER_SEMAPHORE_STR;
+
+#ifdef SE_ENABLE_FTSEARCH
+//extern global_name FT_INDEX_SEMAPHORE_STR;
+#endif
+
+#ifdef SE_ENABLE_TRIGGERS
+//extern global_name TRIGGER_SEMAPHORE_STR;
+#endif
+
+extern global_name CHARISMA_SSMMSG_GOV_ID;
+extern global_name CHARISMA_GOVERNOR_IS_READY;
+extern global_name SEDNA_LFS_SEM_NAME;
+extern global_name SEDNA_LFS_SHARED_MEM_NAME;
+extern global_name CHARISMA_LOGICAL_LOG_SHARED_MEM_NAME;
+extern global_name CHARISMA_LOGICAL_LOG_PROTECTION_SEM_NAME;
+extern global_name CHARISMA_SM_WAIT_FOR_SHUTDOWN;
+extern global_name CHARISMA_CHECKPOINT_SEM;
+extern global_name SEDNA_CHECKPOINT_FINISHED_SEM;
+extern global_name SEDNA_TRNS_FINISHED;
+extern global_name CHARISMA_WAIT_FOR_CHECKPOINT;
+extern global_name CHARISMA_DB_RECOVERED_BY_LOGICAL_LOG;
+extern global_name CHARISMA_SYNC_TRN_IDS_TABLE;
+extern global_name CHARISMA_LRU_STAMP_SHARED_MEMORY_NAME;
+extern global_name GOVERNOR_SHARED_MEMORY_NAME;
+extern global_name SEDNA_LOCK_MANAGER_SEM;
+extern global_name SE_EVENT_LOG_SHARED_MEMORY_NAME;
+extern global_name SE_EVENT_LOG_SEMAPHORES_NAME;
+extern global_name CHARISMA_SM_SMSD_ID;
+extern global_name CHARISMA_SM_IS_READY;
+
+#define TRIGGER_MAX_CASCADING_LEVEL                     10
+
+#define SM_NUMBER_OF_SERVER_THREADS                     1
+
+#define GOV_NUMBER_OF_SERVER_THREADS                    1
+
+#define SEDNA_DETERMINE_VMM_REGION                      "SEDNA_DETERMINE_VMM_REGION"
+#define CONNECTION_SOCKET_HANDLE                        "CONNECTION_SOCKET_HANDLE"
+#define SEDNA_SERVER_MODE                               "SEDNA_SERVER_MODE"
+
+#define SEDNA_LOAD_METADATA_TRANSACTION                 "SEDNA_LOAD_METADATA_TRANSACTION"
+
+#define SEDNA_OS_PRIMITIVES_ID_MIN_BOUND                "SEDNA_OS_PRIMITIVES_ID_MIN_BOUND"
+
+#define SEDNA_RUN_RECOVERY_TRANSACTION                  "SEDNA_RUN_RECOVERY_TRANSACTION"
+
+#define SECURITY_METADATA_DOCUMENT                      "$db_security_data"
+#define INITIAL_SECURITY_METADATA_FILE_NAME             "sedna_auth_md.xml"
+
+#define CHARISMA_MAX_TRNS_NUMBER                        50
+#define MAX_SESSIONS_NUMBER								50
+#define MAX_DBS_NUMBER                                  10
+
+typedef uint64_t strsize_t;
+
+#define STRMAXSIZE                                      4000000000lu
+
+#define UPPER_SESSIONS_NUM_BOUND                        100
+
+void check_db_name_validness(const char* name);
+
+extern FILE* res_os;
+
+/* The following parameters are related to kernel<-->transaction protocol */
+#define  ERR_SYMBOL     ((char)254)
+#define  DELIM_SYMBOL   ((char)250)
+#define  EOD_SYMBOL     ((char)253)
+#define  EOALL_SYMBOL   ((char)252)
+
+/* Command definitions for governor */
+enum commands
+{
+    CREATE_NEW_SESSION     = 110,
+    STOP                   = 501,
+    REGISTER_NEW_SESSION   = 121,
+    REGISTER_DB            = 122,
+    RUNTIME_CONFIG         = 600,
+    HOTBACKUP_START        = 666,
+    IS_RUN_SM              = 888
+};
+
+/* Defines variouse kinds of se_stop command */
+enum stoptype
+{
+    SE_STOP_NO   = 0, /// sedna operates
+    SE_STOP_SOFT = 1, /// wait for transactions are completed
+    SE_STOP_HARD = 2  /// attempts to immediately rollback all running transactions.
+};
+
+/* The following definitions are related to gov<-->rc protocol */
+#define  SE_RC_VALID     ((char)1)
+#define  SE_RC_INVALID   ((char)0)
+#define  SE_RC_OVERFLOW  ((char)2)
+
+#endif