sedna 0.5.1 → 0.6.0

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

@@ -0,0 +1,60 @@
+/*
+ * File:  ummap.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _UMMAP_H
+#define _UMMAP_H
+
+#include "common/u/uhdd.h"
+#include "common/u/usecurity.h"
+
+#ifdef _WIN32
+
+#define U_INVALID_FILEMAPPING(m)			((m).map == NULL)
+
+typedef struct {
+	HANDLE map;
+    UFile fd;
+} UMMap;
+
+#else
+
+#include <sys/mman.h>
+
+#define U_INVALID_FILEMAPPING(m)			((m).map == -1)
+
+typedef struct {
+	int map;
+    int size;
+    int to_file;
+} UMMap;
+
+#endif
+
+
+// check the result by U_INVALID_FILEMAPPING macros
+// pass U_INVALID_FD as fd if you want to create object in swap file
+UMMap uCreateFileMapping(UFile fd, int size, const char* name, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun);
+UMMap uOpenFileMapping(UFile fd, int size, const char *name, sys_call_error_fun fun);
+/*
+UMMap uCreateFileMapping(const char* file_name, UShareMode share, UFlag attr, global_name g_name);
+UMMap uOpenFileMapping(const char* file_name, UShareMode share, UFlag attr, global_name g_name);
+*/
+// returns -1 in case of error
+int   uReleaseFileMapping(UMMap m, const char *name, sys_call_error_fun fun);
+int   uCloseFileMapping(UMMap m, sys_call_error_fun fun);
+
+// returns 0 in case of error
+void *uMapViewOfFile(UMMap m, void *addr, int size, int offs, sys_call_error_fun fun);
+
+// returns -1 in case of error
+int uUnmapViewOfFile(UMMap m, void *addr, int size, sys_call_error_fun fun);
+int uFlushViewOfFile(UMMap m, void *addr, int size, sys_call_error_fun fun);
+
+int uMemLock(void *addr, size_t size, sys_call_error_fun fun);
+int uMemUnlock(void *addr, size_t size, sys_call_error_fun fun);
+
+#endif
+

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

@@ -0,0 +1,145 @@
+/*
+ * File:  umutex.c
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _WIN32
+/* need this to enable UNIX98 features like pthread_mutexattr_settype from pthread.h */ 
+#define _GNU_SOURCE
+#endif
+#include "common/u/umutex.h"
+
+int uMutexInit(uMutexType *mutex, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    InitializeCriticalSection(mutex);
+    return 0;
+#else
+    pthread_mutexattr_t attr;
+    int res = pthread_mutexattr_init(&attr);
+    if (res != 0) 
+    {
+      sys_call_error("pthread_mutexattr_init");  
+      return res;
+    }
+
+	if (res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE), res!=0)
+	{
+		sys_call_error("pthread_mutexattr_settype");
+		return res;
+	}
+
+    if ((res = pthread_mutex_init(mutex, &attr)) != 0)
+       sys_call_error("pthread_mutex_init");
+    return res;
+#endif
+}
+
+int uMutexLock(uMutexType *mutex, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    EnterCriticalSection(mutex);
+    return 0;
+#else
+    int res;
+    if ((res = pthread_mutex_lock(mutex)) != 0)
+       sys_call_error("pthread_mutex_lock");
+    return res;
+#endif
+}
+
+int uMutexUnlock(uMutexType *mutex, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    LeaveCriticalSection(mutex);
+    return 0;
+#else
+    int res;
+    if ((res = pthread_mutex_unlock(mutex)) != 0)
+       sys_call_error("pthread_mutex_unlock");
+
+    return res;
+#endif
+}
+
+int uMutexDestroy(uMutexType *mutex, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    DeleteCriticalSection(mutex);
+    return 0;
+#else
+    int res;
+    if ((res = pthread_mutex_destroy(mutex)) != 0)
+       sys_call_error("pthread_mutex_destroy");
+
+    return res;
+#endif
+}
+
+
+
+
+
+/*
+int uMutex2Create(uMutex2Type *mutex, int inheritable, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    SECURITY_ATTRIBUTES sa;
+    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+    sa.lpSecurityDescriptor = NULL;
+    sa.bInheritHandle = inheritable ? TRUE : FALSE;
+    *mutex = CreateMutex(
+                   &sa,
+                   TRUE,	// initial owner
+                   NULL		// object name
+             );
+    if (*mutex == NULL) return 1;
+    return 0;
+#else
+#error The platform is unsupported now
+#endif
+}
+
+int uMutex2Lock(uMutex2Type *mutex, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    DWORD res = WaitForSingleObject(
+                    *mutex,        // handle to object
+                    INFINITE   // time-out interval
+                );
+
+    if (res == WAIT_FAILED) return 1;
+    return 0;
+#else
+#error The platform is unsupported now
+#endif
+}
+
+int uMutex2Unlock(uMutex2Type *mutex, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    BOOL res = ReleaseMutex(
+                      *mutex   // handle to mutex
+               );
+
+    if (res == 0) return 1;
+    return 0;
+#else
+#error The platform is unsupported now
+#endif
+}
+
+int uMutex2Destroy(uMutex2Type *mutex, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    BOOL res = CloseHandle(
+                    *mutex   // handle to mutex
+               );
+
+    if (res == 0) return 1;
+    return 0;
+#else
+#error The platform is unsupported now
+#endif
+}
+*/

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

@@ -0,0 +1,65 @@
+/*
+ * File:  umutex.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef UMUTEX_H
+#define UMUTEX_H
+
+#include "common/u/u.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//#if defined _WIN32
+// WIN32 defined
+//#elif defined POSIX
+// POSIX defined
+//#else
+//#error Unknown platform, unknown threads...
+//#endif
+
+  
+#ifdef _WIN32
+typedef CRITICAL_SECTION	uMutexType;
+#else
+#include <pthread.h>
+
+typedef pthread_mutex_t		uMutexType;
+#endif
+
+/*
+#ifdef _WIN32
+typedef HANDLE			uMutex2Type;
+#else
+typedef pthread_mutex_t		uMutex2Type;
+#endif
+*/
+
+int uMutexInit(uMutexType *mutex, sys_call_error_fun fun);
+
+int uMutexLock(uMutexType *mutex, sys_call_error_fun fun);
+
+int uMutexUnlock(uMutexType *mutex, sys_call_error_fun fun);
+
+int uMutexDestroy(uMutexType *mutex, sys_call_error_fun fun);
+
+
+/*
+int uMutex2Create(uMutex2Type *mutex, int inheritable, sys_call_error_fun fun);
+
+int uMutex2Lock(uMutex2Type *mutex, sys_call_error_fun fun);
+
+int uMutex2Unlock(uMutex2Type *mutex, sys_call_error_fun fun);
+
+int uMutex2Destroy(uMutex2Type *mutex, sys_call_error_fun fun);
+*/
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+

data/vendor/sedna/kernel/common/u/upipe.cpp

@@ -0,0 +1,244 @@
+/*
+ * File:  upipe.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#include "common/errdbg/d_printf.h"
+#include "common/u/upipe.h"
+
+int uPipe(UPIPE* rpipe, /*read pipe*/
+          UPIPE* wpipe, /*write pipe*/
+          int inheritable,
+          sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    SECURITY_ATTRIBUTES sa;
+    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+    sa.lpSecurityDescriptor = NULL;
+    sa.bInheritHandle = inheritable ? TRUE : FALSE;
+
+    BOOL res = CreatePipe(
+                     rpipe,		// read handle
+                     wpipe,		// write handle
+                     &sa,		// security attributes
+                     0			// pipe size
+               );
+
+    if (res != 0) return 0;
+    else
+    {
+      sys_call_error("CreatePipe");
+      return -1;
+    }
+#else
+    int fildes[2];
+    int res = pipe(fildes);
+    if (res == -1) sys_call_error("pipe");
+
+    *rpipe = fildes[0];
+    *wpipe = fildes[1];
+    return res;
+#endif
+}
+
+int uReadPipe(UPIPE rpipe,	/*read pipe*/
+              void *buf,	/*buffer for data*/
+              int nbyte,	/*size of the buffer*/
+              sys_call_error_fun fun
+             )
+{
+#ifdef _WIN32
+    DWORD bytes_read = 0;
+    BOOL res = ReadFile(
+                   rpipe,		// handle to file
+                   buf,			// data buffer
+                   nbyte,		// number of bytes to read
+                   &bytes_read,		// number of bytes read
+                   NULL			// overlapped buffer
+               );
+
+    if (res == 0) 
+    {
+        if (GetLastError() == 109) return bytes_read;
+        else
+        {
+            sys_call_error("ReadFile");
+            return -1;
+        }
+    }
+    else return bytes_read;
+#else
+    int res;
+    if ((res = read(rpipe, buf, nbyte)) == -1)
+       sys_call_error("read");
+
+    return res;
+#endif
+}
+
+//return the number of bytes read
+// -1 indicates failure
+int uReadPipeAll(UPIPE rpipe, // read pipe
+                 void* buf,   // buffer for data
+                 int nbyte,    // size of the buffer
+                 sys_call_error_fun fun
+                )
+{
+    int res = 0;
+    int bytes_read = 0;
+    while (true)
+    {
+        res = uReadPipe(rpipe, (char*)buf + bytes_read, nbyte - bytes_read, __sys_call_error);
+        if (res == -1) return -1;
+  
+        if (res == 0 ) return bytes_read;
+        else bytes_read += res;
+
+        if (bytes_read == nbyte) return bytes_read;
+
+    }
+}
+
+
+/*
+int uReadPipeMsg(UPIPE rpipe,
+	             std::string &str, sys_call_error_fun fun)
+{
+    char buf[2];
+    DWORD bytes_read;
+    str = "";
+    for (;;)
+    {
+        memset(buf, (char)0, 1);
+  	    BOOL res = ReadFile(
+                    rpipe,		// handle to file
+                    buf,			// data buffer
+                    1,		    // number of bytes to read
+                    &bytes_read,		// number of bytes read
+                    NULL			// overlapped buffer
+                    );
+        if (bytes_read < 0) return -1;
+        if (buf[0] == '\0') break;
+        
+        buf[1]='\0';                      
+        str += std::string(buf);
+    }
+    
+    return 0;
+}
+*/
+
+int uWritePipe(UPIPE wpipe,	/*write pipe*/
+               const void *buf,	/*pointer to data*/
+               int nbyte,	/*size of the data*/
+               sys_call_error_fun fun
+              )
+{
+#ifdef _WIN32
+    DWORD bytes_written = 0;
+    BOOL res = WriteFile(
+                    wpipe,		// handle to file
+                    buf,		// data buffer
+                    nbyte,		// number of bytes to write
+                    &bytes_written,	// number of bytes written
+                    NULL		// overlapped buffer
+               );
+
+    if (res == 0) 
+    {
+        sys_call_error("WriteFile");
+        return -1;
+    }
+    else return bytes_written;
+#else
+    int res;
+    if ((res = write(wpipe, buf, nbyte)) == -1)
+       sys_call_error("write");
+ 
+    return res;
+#endif
+}
+
+// return value 0 indicates success
+int uWritePipeAll(UPIPE wpipe,	/*write pipe*/
+                  const void *buf,	/*pointer to data*/
+                  int nbyte,	/*size of the data*/
+                  sys_call_error_fun fun
+                 )
+{
+    int res = 0;
+    int bytes_written = 0;
+    while (true)
+    {
+        res = uWritePipe(wpipe, (char*)buf + bytes_written, nbyte - bytes_written, __sys_call_error);
+        if (res == -1) return -1;
+        else bytes_written += res;
+
+        if (bytes_written == nbyte) return 0;
+    }
+}
+
+int uClosePipe(UPIPE upipe, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    BOOL res = CloseHandle(
+                    upipe		// handle to object
+               );
+
+
+    if (res == 0)
+    {
+       sys_call_error("CloseHandle");
+       return -1;
+    }
+    else return 0;
+#else
+    int res;
+    if ((res = close(upipe)) == -1)
+       sys_call_error("close");
+
+    return res;
+#endif
+}
+
+#define BUFSIZE 1024
+
+int uReadPipeAll(UPIPE rpipe, std::string &str, sys_call_error_fun fun)
+{
+    char buf[BUFSIZE + 1];
+    int bytes_read;
+    for (;;)
+    {
+        memset(buf, (char)0, BUFSIZE + 1);
+        bytes_read = uReadPipe(rpipe, buf, BUFSIZE, __sys_call_error);
+        if (bytes_read < 0) return -1;
+        if (bytes_read == 0) break;
+        str += std::string(buf);
+    }
+    return 0;
+}
+
+/*
+int uPipeDoNotInherit(UPIPE *upipe, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    HANDLE tmp = *upipe;
+    BOOL res = DuplicateHandle(
+                        GetCurrentProcess(), 
+                        tmp,
+                        GetCurrentProcess(), 
+                        upipe, 
+                        0,
+                        FALSE,
+                        DUPLICATE_SAME_ACCESS);
+    
+    CloseHandle(tmp);
+
+    if (res == 0) return -1;
+    else return 0;
+#else
+    return 0;
+#endif
+}
+*/