sedna 0.5.1 → 0.6.0

data/vendor/sedna/kernel/common/u/uthread.h

@@ -0,0 +1,95 @@
+/*
+ * File:  uthread.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef UTHREAD_H
+#define UTHREAD_H
+
+#include "common/u/u.h"
+#include "common/u/usecurity.h"
+
+
+#ifdef _WIN32
+#else
+#include <pthread.h>
+#endif
+  
+
+#ifdef _WIN32
+#define U_THREAD_PROC(ProcName, arg) DWORD WINAPI ProcName(LPVOID arg)
+#else 
+#define U_THREAD_PROC(ProcName, arg) void *       ProcName(void*  arg)
+#endif
+
+#define UEXITTHREAD_OK			0
+#define UEXITTHREAD_FAIL		(-1)
+
+
+#ifdef _WIN32
+typedef HANDLE                 uResVal;
+typedef LPVOID                 uArg;
+typedef HANDLE                 UTHANDLE;
+typedef SIZE_T                 uStackSize;
+typedef LPTHREAD_START_ROUTINE uThreadProc;
+typedef DWORD                  UTID;
+
+typedef volatile LONG          uspinlock;
+#else
+typedef int                    uResVal;
+typedef void*                  uArg;
+typedef pthread_t              UTHANDLE;
+typedef size_t                 uStackSize;
+typedef void*                (*uThreadProc)(void*);
+typedef int                    UTID;
+
+#ifdef HAVE_SPINLOCKS
+typedef pthread_spinlock_t     uspinlock;
+#endif
+#endif
+
+#ifdef _WIN32
+#define uSpinInit(sl)		((*(sl) = FALSE), 0)
+#define uSpinDestroy(sl)	0
+#define uSpinLock(sl)		while (InterlockedExchange(sl, TRUE) == TRUE) { Sleep(0); }
+#define uSpinUnlock(sl)		InterlockedExchange(sl, FALSE)
+#else
+#define uSpinInit(sl)		pthread_spin_init(sl, 0)
+#define uSpinDestroy(sl)	pthread_spin_destroy(sl)
+#define uSpinLock(sl)		pthread_spin_lock(sl)
+#define uSpinUnlock(sl)		pthread_spin_unlock(sl)
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uResVal uCreateThread(
+    uThreadProc proc,
+    uArg        arg,
+    UTHANDLE    *id,
+    uStackSize  size,
+    USECURITY_ATTRIBUTES* sa,
+    sys_call_error_fun fun
+);
+
+int uEnableSuspend(sys_call_error_fun fun);
+int uSuspendThread(UTHANDLE id, sys_call_error_fun fun);
+int uResumeThread(UTHANDLE id, sys_call_error_fun fun);
+int uTerminateThread(UTHANDLE id, sys_call_error_fun fun);
+int uCloseThreadHandle(UTHANDLE id, sys_call_error_fun fun);
+int uThreadJoin(UTHANDLE id, sys_call_error_fun fun);
+// use UEXITTHREAD_OK or UEXITTHREAD_FAIL as arguments to uExitThread
+void uExitThread(int rc, sys_call_error_fun fun);
+UTHANDLE uGetCurrentThread(sys_call_error_fun fun);
+int uThreadBlockAllSignals(sys_call_error_fun fun);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

data/vendor/sedna/kernel/common/u/utime.c

@@ -0,0 +1,65 @@
+/*
+ * File:  utime.c
+ * Copyright (C) 2006 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _UTIME_H
+#define _UTIME_H
+
+#include "common/u/utime.h"
+
+
+utm getLocalTime()
+{
+    utm retval;
+
+//FIXME: Need to deal with daylight savings times
+#ifdef _WIN32
+    SYSTEMTIME systime;
+    TIME_ZONE_INFORMATION tz_info;
+
+    GetLocalTime(&systime);
+    retval.utm_year = systime.wYear;
+    retval.utm_mon = systime.wMonth;
+    retval.utm_wday = systime.wDayOfWeek;
+    retval.utm_mday = systime.wDay;
+    retval.utm_hour = systime.wHour;
+    retval.utm_min = systime.wMinute;
+    retval.utm_sec = systime.wSecond;
+    retval.utm_millis = systime.wMilliseconds;
+
+    GetTimeZoneInformation(&tz_info);
+    retval.utm_gmtoff = -(tz_info.Bias + tz_info.DaylightBias)*60;
+#else
+    // !!! Calling localtime is not thread safe (use localtime_r 
+    //     instead if you want thread safe code)
+    time_t t;
+    struct tm* tm_ptr;
+    time(&t);
+    tm_ptr = localtime(&t); 
+    retval.utm_millis = 0;
+    retval.utm_sec = tm_ptr->tm_sec;
+    retval.utm_min = tm_ptr->tm_min;
+    retval.utm_hour = tm_ptr->tm_hour;
+    retval.utm_mday = tm_ptr->tm_mday;
+    retval.utm_mon = tm_ptr->tm_mon+1;
+    retval.utm_year = tm_ptr->tm_year+1900;
+    retval.utm_wday = tm_ptr->tm_wday;
+    retval.utm_yday = tm_ptr->tm_yday;
+    retval.utm_isdst = tm_ptr->tm_isdst;
+
+#if defined(__cygwin__) || defined(SunOS) 
+    retval.utm_zone = 0;
+    retval.utm_gmtoff = 0;
+#else
+    retval.utm_zone = tm_ptr->tm_zone;
+    retval.utm_gmtoff = tm_ptr->tm_gmtoff;
+#endif
+
+#endif
+
+    return retval;
+}
+
+#endif /* _UTIME_H */
+

data/vendor/sedna/kernel/common/u/utime.h

@@ -0,0 +1,40 @@
+/*
+ * File:  utime.h
+ * Copyright (C) 2006 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef UTIME_H
+#define UTIME_H
+
+#include "common/u/u.h"
+
+
+// Define the time structure class in the spirit of extended POSIX tm
+// structure
+typedef struct {
+   /* ANSI standard fields */
+   int utm_millis;   /* 0 to 1000 */
+   int utm_sec;   /* 0 to 60 */
+   int utm_min;   /* 0 to 59 */
+   int utm_hour;  /* 0 to 23 */
+   int utm_mday;  /* 1 to 31 */
+   int utm_mon;   /* 0 to 11 */
+   int utm_year;  /* year - 1900 */
+   int utm_wday;  /* Sunday = 0 */
+   int utm_yday;  /* 0 to 365 */
+   int utm_isdst;
+       /* >0 if Daylight Savings Time,
+        *  0 if Standard,
+        * <0 if unknown */
+   /* extensions to ANSI standard */
+   const char *utm_zone;  /* time zone name    */
+   long utm_gmtoff; /* offset from GMT   */
+} utm;
+
+
+SE_EXTERN_C
+utm getLocalTime();
+
+
+#endif /* UTIME_H */
+

data/vendor/sedna/kernel/common/u/uutils.c

@@ -0,0 +1,142 @@
+/*
+ * File:  uutils.c
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#include <stdlib.h>
+#include "common/u/uutils.h"
+#include "common/errdbg/d_printf.h"
+
+
+#ifndef _WIN32
+
+char *u_itoa(int value, char *str, int radix)
+{
+    if (radix != 10)
+    {
+        d_printf1("radix in call to _ultoa has unsupported value\n");
+        return NULL;
+    }
+    sprintf(str, "%d", value);
+    return str;
+}
+
+char *u_ltoa(long value, char *str, int radix)
+{
+    if (radix != 10)
+    {
+        d_printf1("radix in call to _ltoa has unsupported value\n");
+        return NULL;
+    }
+    sprintf(str, "%ld", value);
+    return str;
+}
+
+char *u_ultoa(unsigned long value, char *str, int radix)
+{
+    if (radix != 10)
+    {
+        d_printf1("radix in call to _ultoa has unsupported value\n");
+        return NULL;
+    }
+    sprintf(str, "%lu", value);
+    return str;
+}
+
+char *u_i64toa(__int64 value, char *str, int radix)
+{
+    if (radix != 10)
+    {
+        d_printf1("radix in call to _ultoa has unsupported value\n");
+        return NULL;
+    }
+    sprintf(str, "%lld", value);
+    return str;
+}
+
+char *u_ui64toa(__uint64 value, char *str, int radix)
+{
+    if (radix != 10)
+    {
+        d_printf1("radix in call to _ui64toa has unsupported value\n");
+        return NULL;
+    }
+    sprintf(str, "%llu", value);
+    return str;
+}
+
+char *u_gcvt(double value, int digits, char *buf)
+{
+#ifdef HAVE_GCVT
+    return gcvt(value, digits, buf);
+#else
+    sprintf(buf, "%.*E", digits, value);
+    return buf;
+#endif
+}
+
+int _stricmp(const char *str1, const char *str2)
+{
+    return strcasecmp(str1, str2);
+}
+
+int _strnicmp(const char *str1, const char *str2, size_t n)
+{
+    return strncasecmp(str1, str2, n);
+}
+
+int _vsnprintf(char *str, size_t size, const char *format, va_list ap)
+{
+    int res = vsnprintf(str, size, format, ap);
+    if (res >= size) return -1;
+    return res;
+}
+
+#endif /* _WIN32 */
+
+void int2net_int(__int32 i, char *buf)
+{
+    i = htonl(i);
+    memcpy(buf, (void*)&i, sizeof(__int32));
+}
+
+void net_int2int(__int32* i, const char *buf)
+{
+    memcpy((void*)i, buf, sizeof(__int32));
+    *i = ntohl(*i);
+}
+
+char *int2c_str(int value, char *buf)
+{
+    u_itoa(value, buf, 10);
+    return buf;
+}
+
+__int64  strto__int64(const char *nptr, char **endptr, int base)
+{
+#ifdef _WIN32
+    return _strtoi64(nptr, endptr, base);
+#else
+    return strtoll(nptr, endptr, base);
+#endif
+}
+
+__uint64 strto__uint64(const char *nptr, char **endptr, int base)
+{
+#ifdef _WIN32
+    return _strtoui64(nptr, endptr,base);
+#else
+    return strtoull(nptr, endptr,base);
+#endif
+}
+
+__int64 u_double2int64(double v)
+{
+    __int64 res;
+    if(u_is_nan(v)) return 0;
+    if(u_is_neg_inf(v) || v < _I64_MIN) return _I64_MIN;
+    if(u_is_pos_inf(v) || v > _I64_MAX) return _I64_MAX;
+    res = (__int64)v;
+    return res;
+}

data/vendor/sedna/kernel/common/u/uutils.h

@@ -0,0 +1,65 @@
+/*
+ * File:  uutils.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _UUTILS_H
+#define _UUTILS_H
+
+
+#include "common/u/u.h"
+
+#ifndef _WIN32
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef _WIN32
+  #define u_itoa _itoa
+  #define u_ltoa _ltoa
+  #define u_i64toa _i64toa
+  #define u_ui64toa _ui64toa
+  #define u_ultoa _ultoa
+  #define u_gcvt _gcvt
+#else
+    char *u_itoa(int value, char *str, int radix);
+    char *u_ltoa(long value, char *str, int radix);
+    char *u_ultoa(unsigned long value, char *str, int radix);
+    char *u_i64toa(__int64 value, char *str, int radix);
+	char *u_ui64toa(__uint64 value, char *str, int radix);
+    char *u_gcvt(double value, int digits, char *buf);
+    int _stricmp(const char *str1, const char *str2);
+    int _strnicmp(const char *str1, const char *str2, size_t n);
+    int _vsnprintf(char *str, size_t size, const char *format, va_list ap);
+#define _snprintf snprintf
+#endif
+
+    void int2net_int(__int32 i, char *buf);
+    void net_int2int(__int32 *i, const char *buf);
+
+    /* buf length must not be less than 20 */
+    char *int2c_str(int value, char *buf);
+
+    __int64  strto__int64(const char *nptr, char **endptr, int base);
+    __uint64 strto__uint64(const char *nptr, char **endptr, int base);
+
+    /* 
+     * (__int64)INF, (__int64)NaN is undefined behaviour and give different
+     * results on Win/Linux/Mac OS
+     * returns 0 if NaN
+     *         __I64_MAX if +INF, or v > _I64_MAX
+     *         __I64_MIN if -INF, or v < _I64_MIN
+     */
+     __int64 u_double2int64(double v); 
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _UUTILS_H */

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

@@ -0,0 +1,156 @@
+/*
+ * File:  ugc.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#include "common/sedna.h"
+
+#include "common/ugc.h"
+#include "common/base.h"
+#include "common/u/ushm.h"
+#include "common/u/usem.h"
+#include "common/u/ummap.h"
+#include "common/u/uevent.h"
+#include "common/errdbg/d_printf.h"
+#include "common/config.h"
+#include "common/SSMMsg.h"
+
+
+
+#define EVENT_CLEANUP(name)						if (UEventOpen(&ev, name, __sys_call_error) == 0)						\
+                                                {																			\
+                                                    UEventCloseAndUnlink(&ev, __sys_call_error);								\
+                                                    d_printf1("Event cleanup    : "#name"\n");							\
+                                                }
+
+#define SEMAPHORE_CLEANUP(name)					if (USemaphoreOpen(&sem, name, __sys_call_error) == 0)						\
+                                                {																			\
+                                                    USemaphoreRelease(sem, __sys_call_error);								\
+                                                    d_printf1("Semaphore cleanup    : "#name"\n");							\
+                                                }
+
+#define SHAREDMEM_CLEANUP(name, size)			if (uOpenShMem(&shm, name, 0, __sys_call_error) == 0)					\
+                                                {																			\
+                                                    uReleaseShMem(shm, __sys_call_error);									\
+                                                    d_printf1("Shared memory cleanup: "#name"\n");							\
+                                                 }
+
+#define SEMAPHORE_CLEANUP2(name, name2)			if (USemaphoreOpen(&sem, name, __sys_call_error) == 0)						\
+                                                {																			\
+                                                    USemaphoreRelease(sem, __sys_call_error);								\
+                                                    d_printf1("Semaphore cleanup    : "#name2"\n");							\
+                                                }
+
+#define SHAREDMEM_CLEANUP2(name, name2, size)	if (uOpenShMem(&shm, name, 0, __sys_call_error) == 0)					\
+                                                {																			\
+                                                    uReleaseShMem(shm, __sys_call_error);									\
+                                                    d_printf1("Shared memory cleanup: "#name2"\n");							\
+                                                }
+
+#define FILE_MAPPING_CLEANUP(name)				if (!U_INVALID_FILEMAPPING(map = uOpenFileMapping(U_INVALID_FD, 0, name, __sys_call_error)))	\
+                                                {																			\
+                                                    uReleaseFileMapping(map, name, __sys_call_error);						\
+                                                    d_printf1("Filemapping cleanup    : "#name"\n");						\
+                                                }
+
+
+
+void gov_ugc(bool background_off_from_background_on, int os_primitives_bound)
+{
+#ifdef _WIN32
+#else
+    USemaphore sem;
+    UShMem shm;
+    UMMap map;
+    char buf[1024];
+
+    if (background_off_from_background_on) return;
+
+    d_printf1("Starting CLEANUP\n");
+    SEMAPHORE_CLEANUP(CHARISMA_GOVERNOR_IS_READY);
+
+    SEMAPHORE_CLEANUP(SE_EVENT_LOG_SEMAPHORES_NAME);
+    SHAREDMEM_CLEANUP(SE_EVENT_LOG_SHARED_MEMORY_NAME, sizeof(event_log_msg));
+
+    SHAREDMEM_CLEANUP(GOVERNOR_SHARED_MEMORY_NAME, sizeof(gov_config_struct));
+    FILE_MAPPING_CLEANUP(SEDNA_GLOBAL_MEMORY_MAPPING);
+
+    /// releasing semaphores depending on sessions
+    for (int i = 0; i < MAX_SESSIONS_NUMBER; i++)
+    {
+        SEMAPHORE_CLEANUP2(SM_TO_VMM_CALLBACK_SEM1_BASE_STR(i, buf, 1024), SM_TO_VMM_CALLBACK_SEM1_BASE_STR);
+        SEMAPHORE_CLEANUP2(SM_TO_VMM_CALLBACK_SEM2_BASE_STR(i, buf, 1024), SM_TO_VMM_CALLBACK_SEM2_BASE_STR);
+        SEMAPHORE_CLEANUP2(SEDNA_TRANSACTION_LOCK(i, buf, 1024), SEDNA_TRANSACTION_LOCK);
+    } 
+ 
+    d_printf1("CLEANUP completed\n\n");
+#endif
+}
+
+void sm_ugc(bool background_off_from_background_on, int db_id, int os_primitives_bound)
+{
+#ifdef _WIN32
+#else
+    USemaphore sem;
+    UShMem shm;
+    UMMap map;
+    UEvent ev;
+    char buf[1024];
+
+    if (background_off_from_background_on) return;
+
+    d_printf1("Starting CLEANUP\n");
+    SEMAPHORE_CLEANUP(CHARISMA_SM_WAIT_FOR_SHUTDOWN);
+    SEMAPHORE_CLEANUP(VMM_SM_SEMAPHORE_STR);
+    SEMAPHORE_CLEANUP(VMM_SM_EXCLUSIVE_MODE_SEM_STR);
+
+    SEMAPHORE_CLEANUP(CATALOG_NAMETABLE_SEMAPHORE_STR);
+    SEMAPHORE_CLEANUP(CATALOG_MASTER_SEMAPHORE_STR);
+
+//    SEMAPHORE_CLEANUP(METADATA_SEMAPHORE_STR);
+//    SEMAPHORE_CLEANUP(INDEX_SEMAPHORE_STR);
+#ifdef SE_ENABLE_FTSEARCH
+    //SEMAPHORE_CLEANUP(FT_INDEX_SEMAPHORE_STR);
+#endif
+#ifdef SE_ENABLE_TRIGGERS
+    //SEMAPHORE_CLEANUP(TRIGGER_SEMAPHORE_STR);
+#endif
+    SHAREDMEM_CLEANUP(CHARISMA_SM_CALLBACK_SHARED_MEMORY_NAME, 8);
+    SHAREDMEM_CLEANUP(CHARISMA_LOGICAL_LOG_SHARED_MEM_NAME, 0/*CHARISMA_LOGICAL_LOG_SHARED_MEM_SIZE*/);
+    SHAREDMEM_CLEANUP(SEDNA_LFS_SHARED_MEM_NAME, 0);
+    //SEMAPHORE_CLEANUP(CHARISMA_CHECKPOINT_SEM);
+    SEMAPHORE_CLEANUP(SEDNA_TRNS_FINISHED);
+    SEMAPHORE_CLEANUP(CHARISMA_LOGICAL_LOG_PROTECTION_SEM_NAME);
+    SEMAPHORE_CLEANUP(CHARISMA_DB_RECOVERED_BY_LOGICAL_LOG);
+    //SEMAPHORE_CLEANUP(CHARISMA_WAIT_FOR_CHECKPOINT);
+    SEMAPHORE_CLEANUP(SEDNA_CHECKPOINT_FINISHED_SEM);
+    SEMAPHORE_CLEANUP(SEDNA_LOCK_MANAGER_SEM);
+    SEMAPHORE_CLEANUP(SEDNA_LFS_SEM_NAME);
+
+	EVENT_CLEANUP(SNAPSHOT_CHECKPOINT_EVENT);
+	EVENT_CLEANUP(TRY_ADVANCE_SNAPSHOT_EVENT);
+
+    SHAREDMEM_CLEANUP(CHARISMA_LRU_STAMP_SHARED_MEMORY_NAME, 8);
+    SEMAPHORE_CLEANUP(CHARISMA_SYNC_TRN_IDS_TABLE);
+    //SEMAPHORE_CLEANUP(CHARISMA_SM_SMSD_ID);
+    SEMAPHORE_CLEANUP(CHARISMA_SM_IS_READY);
+
+	SSMMsg::ipc_cleanup(CHARISMA_SSMMSG_SM_ID(db_id, buf, 1024));
+
+    FILE_MAPPING_CLEANUP(CHARISMA_BUFFER_SHARED_MEMORY_NAME);
+
+
+    d_printf1("CLEANUP completed\n\n");
+
+//    std::string buf_dir = SEDNA_DATA + std::string("/data/") + db_name + std::string("_files/buf");
+#endif
+}
+
+void cdb_ugc(int db_id, int os_primitives_bound)
+{
+#ifdef _WIN32
+#else
+    sm_ugc(false, db_id, os_primitives_bound);
+#endif
+}
+