sedna 0.5.1 → 0.6.0

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

@@ -0,0 +1,49 @@
+/*
+ * File:  sedna.h
+ * Copyright (C) 2006 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _SEDNA_H
+#define _SEDNA_H
+
+
+#include "common/u/u.h"
+#include "sp_defs.h"
+#include "common/mmgr/se_alloc.h"
+#include "common/errdbg/event_log.h"
+
+#ifdef __cplusplus
+#include "common/errdbg/exceptions.h"
+#endif
+
+
+/*
+ * SEDNA_DATA contains path to the Sedna's data directory
+ */
+#define SEDNA_DATA_VAR_SIZE								1024
+SE_EXTERN_C char* SEDNA_DATA;
+
+/*
+ * Pointer to the governor's shared memory
+ */
+SE_EXTERN_C void* sedna_gov_shm_ptr;
+
+
+SE_EXTERN_C 
+int set_sedna_data(char*, sys_call_error_fun fun);
+
+SE_EXTERN_C 
+void DumpFaultInfo();
+
+
+#define SEDNA_SOFT_FAULT_BASE_MSG \
+    fprintf(stderr, "SEDNA Message: FATAL ERROR\n"); \
+    DumpFaultInfo(); \
+    fprintf(stderr, "System error. This error means system malfunction.\n")
+
+#define SEDNA_SOFT_FAULT_FINALIZER \
+    fflush(stderr); \
+    uExitProcess(1, __sys_call_error)
+
+#endif /*_SEDNA_H */

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

@@ -0,0 +1,52 @@
+/*
+ * File:  sedna_ef.h
+ * Copyright (C) 2005 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _SEDNA_EF_H
+#define _SEDNA_EF_H
+
+#define SEDNA_ERROR_MSG_BUF_SIZE	128
+
+typedef enum sedna_atomic_type {SEDNATYPE_integer, SEDNATYPE_float, SEDNATYPE_double, SEDNATYPE_string} SEDNA_ATOMIC_TYPE;
+
+typedef int		SEDNA_integer;
+typedef float	SEDNA_float;
+typedef double	SEDNA_double;
+typedef char 	*SEDNA_string;
+
+typedef struct sedna_atomic_value
+{
+	SEDNA_ATOMIC_TYPE type;
+	union
+	{
+		SEDNA_integer	val_integer;
+		SEDNA_float		val_float;
+		SEDNA_double	val_double;
+		SEDNA_string	val_string;
+	};
+} SEDNA_ATOMIC_VALUE;
+
+typedef struct sedna_sequence_item
+{
+	SEDNA_ATOMIC_VALUE	data;
+	struct sedna_sequence_item	*next;
+} SEDNA_SEQUENCE_ITEM;
+
+typedef struct sedna_ef_init
+{
+	void *(*sedna_malloc)(size_t);
+	void (*sedna_free)(void *);
+	SEDNA_SEQUENCE_ITEM *node_buf;
+	void *ptr;
+} SEDNA_EF_INIT;
+
+typedef struct sedna_ef_args
+{
+	int length;
+	SEDNA_SEQUENCE_ITEM **args;
+} SEDNA_EF_ARGS;
+
+
+
+#endif /* _SEDNA_EF_H */

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

@@ -0,0 +1,144 @@
+/*
+ * File:  sm_vmm_data.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _SM_VMM_DATA_H
+#define _SM_VMM_DATA_H
+
+#include "common/sedna.h"
+#include "common/base.h"
+#include "common/xptr.h"
+#include "common/wustructures.h"
+#include "common/lfsGlobals.h"
+
+struct vmm_sm_blk_hdr
+{
+    xptr p;		// the first 4 bytes is the layer of the block
+    LSN lsn;
+	VersionsHeader versionsHeader;
+
+	int blockType;  // (c) A. Kalinin
+	ramoffs roffs;	// address of block in buffer memory
+    int is_changed;
+	int trid_wr_access; /* Motherfuckers! Session id (sid) is actually stored here! */
+
+	static void init(vmm_sm_blk_hdr *hdr)
+	{
+		hdr->p = XNULL;
+		hdr->lsn = LFS_INVALID_LSN;
+		memset(hdr->versionsHeader.xptr, 0, sizeof hdr->versionsHeader.xptr);
+		memset(hdr->versionsHeader.creatorTs, -1, sizeof hdr->versionsHeader.creatorTs);
+		hdr->roffs = 0;
+		memcpy(&hdr->blockType, "AKNZ", 4);
+		hdr->is_changed = false;
+		hdr->trid_wr_access = -1;
+	}
+};
+
+/* Hot-Backup states and answers in messages */
+enum hb_state
+{
+    HB_START,               // start hot-backup
+    HB_START_CHECKPOINT,    // start hot-backup with preceding checkpoint
+    HB_START_INCR,          // make primary increment copy
+    HB_ADD_INCR,            // archive another portion of the db
+    HB_STOP_INCR,           // disable increment mode for the given database
+    HB_NONE_INCR,           // non-increment mode
+    HB_CONT,                // sm answer: can continue
+    HB_WAIT,                // answer: wait for checkpoint to finish
+    HB_ARCHIVELOG,          // archive logical log (switch to the next one)
+    HB_END,                 // end of the hot-backup process
+    HB_ERR,                 // some error from sm
+    HB_NEXTFILE,            // file request from hbp
+    HB_GETPREVLOG           // get previous log file number
+};
+
+/**
+ *
+ * cmd list:
+ * =========
+ * response list:
+ * ~~~~~~~~~~~~~~
+ * 0 - success
+ * otherwise (int > 0) - fail
+ *
+ * query list:
+ * ~~~~~~~~~~~
+ * 10 - soft shutdown
+ * 11 - hard shutdown
+ *
+ * 21 - bm_register_session
+ * 22 - bm_unregister_session
+ * 23 - bm_allocate_data_block (xptr, offs)
+ * 24 - bm_allocate_tmp_block (xptr, offs)
+ * 25 - bm_delete_block (xptr)
+ * 26 - bm_get_block (xptr, offs)
+ * 27 - bm_enter_exclusive_mode (num)
+ * 28 - bm_exit_exclusive_mode
+ * 29 - bm_memlock_block (xptr)
+ * 30 - bm_memunlock_block (xptr)
+ * 31 - bm_block_statistics (sm_blk_stat)
+ * 32 - bm_pseudo_allocate_data_block (xptr)
+ * 33 - bm_pseudo_delete_data_block (xptr)
+ * 34 - bm_delete_tmp_blocks
+ * 35 - bm_register_transaction
+ * 36 - bm_unregister_transaction
+ * 37 - bm_create_new_version
+ * 38 - transaction rollback
+ * 39 - hot-backup procedure (receive: state, return: status, or log file numbers; use hb_struct for this)
+ */
+
+struct sm_blk_stat
+{
+    int free_data_blocks_num;
+    int free_tmp_blocks_num;
+    int used_data_blocks_num;
+    int used_tmp_blocks_num;
+};
+
+struct sm_msg_struct
+{
+    // cmd (what do you want to do)
+    int cmd;
+    // transaction identifier
+    transaction_id trid;
+
+    //identifier of session
+    session_id sid;
+
+    // additional parameters
+    union {
+        struct {
+            int num; // number of potentially allocated blocks in call to bm_enter_exclusive_mode
+            xptr mptr; // pointer for catalog master block
+            int transaction_flags;
+        } reg;
+
+        xptr ptr; // xptr for deletion, locking and unlocking
+
+        struct {
+            xptr ptr;
+            xptr swapped;
+            int offs;
+        } swap_data;
+
+        struct {
+            uint64_t lnumber;
+            hb_state state;
+            bool is_checkp;
+            hb_state incr_state;
+            TIMESTAMP ts;
+        } hb_struct;
+
+        int64_t snp_ts;   // timestamp of snapshot, not used currently, but may be helpful later
+
+        sm_blk_stat stat; // sm block statistics
+
+        char data[2 + MAX_RESOURCE_NAME_LENGTH]; // first byte->lock mode, second byte->resource type, other bytes->resource name
+
+    } data;
+};
+
+#endif

data/vendor/sedna/kernel/common/sp.c

@@ -0,0 +1,93 @@
+/*
+ * File:  sp.c
+ * Copyright (C) 2009 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#include "common/sp.h"
+#include "common/errdbg/d_printf.h"
+#include "common/u/uutils.h"
+
+/* returns zero - if succeeded;                        
+   returns 1 - if Message length exceeds available size
+   returns U_SOCKET_ERROR if error */
+int sp_recv_msg(USOCKET s, struct msg_struct *msg)
+{
+    int rc = 0, got = 0;
+    __int64 buf = 0;
+    char* ptr = (char*)&buf;
+
+    while (got < 8)
+    {
+        rc = urecv(s, ptr + got, 8 - got, __sys_call_error);
+        if ((rc == U_SOCKET_ERROR) || (rc == 0))
+            return U_SOCKET_ERROR;
+        got += rc;
+    }
+
+    msg->instruction = ntohl(*(sp_int32 *) ptr);
+    msg->length = ntohl(*(sp_int32 *) (ptr + 4));
+    if (msg->length > SE_SOCKET_MSG_BUF_SIZE)
+    {
+        return 1;               /* Message length exceeds available size */
+    }
+
+    got = 0;
+    while (got < msg->length)
+    {
+        rc = urecv(s, msg->body + got, msg->length - got, __sys_call_error);
+        if ((rc == U_SOCKET_ERROR) || (rc == 0))
+            return U_SOCKET_ERROR;
+        got += rc;
+    }
+    return 0;
+}
+
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if error */
+int sp_send_msg(USOCKET s, const struct msg_struct *msg)
+{
+    __int64 buf = 0;
+    char* ptr = (char*)&buf;
+    int rc = 0, sent = 0;
+
+    *(sp_int32*)ptr = htonl(msg->instruction);
+    *((sp_int32*)(ptr + 4)) = htonl(msg->length);
+    while (sent < 8)
+    {
+        rc = usend(s, ptr + sent, 8 - sent, __sys_call_error);
+        if (rc == U_SOCKET_ERROR)
+            return U_SOCKET_ERROR;
+        sent += rc;
+    }
+
+    sent = rc = 0;
+    while (sent < msg->length)
+    {
+        rc = usend(s, (const char *) (msg->body + sent), msg->length - sent, __sys_call_error);
+        if (rc == U_SOCKET_ERROR)
+            return U_SOCKET_ERROR;
+        sent += rc;
+    }
+
+    return 0;
+}
+
+/*  sends error message to client. 
+    Error message contains message instruction, message length, error code, error info.
+    returns zero if succeeded, U_SOCKET_ERROR if failed */
+int sp_error_message_handler(USOCKET s, int error_ins, int error_code, const char *error_info)
+{
+    struct msg_struct server_msg;
+    int err_length = strlen(error_info);
+
+    server_msg.instruction = error_ins;
+    server_msg.length = err_length + 5 + 4;
+    *(sp_int32*)server_msg.body = htonl(error_code);  /* this is error code */
+    server_msg.body[4] = 0;
+    *(sp_int32*)(server_msg.body + 5) = htonl(err_length);  /* this is error_info length */
+    memcpy(server_msg.body + 9, error_info, err_length);
+
+    return sp_send_msg(s, &server_msg);
+}

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

@@ -0,0 +1,36 @@
+/*
+ * File:  sp.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _SP_H
+#define _SP_H
+
+#include "common/u/usocket.h"
+#include "sp_defs.h"
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* returns zero - if succeeded;                        
+   returns 1 - if Message length exceeds available size
+   returns U_SOCKET_ERROR if error */
+    int sp_recv_msg(USOCKET s, struct msg_struct *msg);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if error */
+    int sp_send_msg(USOCKET s, const struct msg_struct *msg);
+
+/*  sends error message to client. 
+    Error message contains message instruction, message length, error code, error info.
+    returns zero if succeeded, U_SOCKET_ERROR if failed */
+    int sp_error_message_handler(USOCKET s, int error_ins, int error_code, const char *error_info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/sedna/kernel/common/st/Makefile

@@ -0,0 +1,20 @@
+#
+# Makefile for u (GNU make)
+#
+
+PP = ../../..
+
+
+include $(PP)/Makefile.include
+
+
+
+ifeq ("$(OS)", "CYGWIN_NT")
+VPATH =  $(PP)/kernel/common/st/os_nt
+else
+VPATH =  $(PP)/kernel/common/st/os_other
+endif
+
+OBJS = stacktrace$(OBJ_EXT) stacktrfmt$(OBJ_EXT)
+
+include $(PP)/Makefile.pseudolib

data/vendor/sedna/kernel/common/st/os_linux/stacktrace.c

@@ -0,0 +1,213 @@
+/* GNU backtraces
+ * 	http://docs.linux.cz/programming/c/www.gnu.org/software/libc/manual/html_node/Backtraces.html#Backtraces
+ *
+ * Solaris walkcontext
+ *	http://docs.sun.com/app/docs/doc/819-2243/printstack-3c?a=view
+ *
+ * Stack parameters not reported properly with either getcontext() or
+ * when invoking signal handlers
+ * 	http://sources.redhat.com/bugzilla/show_bug.cgi?id=759
+ */
+
+#define _GNU_SOURCE
+#include <execinfo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <ucontext.h>
+#include <string.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdint.h>
+#include <dlfcn.h>
+
+/* Obtain a backtrace and print it to stdout. */
+void
+print_trace (void)
+{
+void *array[10];
+size_t size;
+char **strings;
+size_t i;
+
+size = backtrace (array, 10);
+strings = backtrace_symbols (array, size);
+
+printf ("Obtained %zd stack frames.\n", size);
+
+for (i = 0; i < size; i++)
+printf ("%s\n", strings[i]);
+
+free (strings);
+}
+
+/* A dummy function to make the backtrace more interesting. */
+void
+dummy_function ()
+{
+print_trace ();
+}
+
+#define OFFSET(PTR,DIST) (void*)((char*)(PTR)+(DIST))
+
+/* Explore process VM layout parsing /proc/${PID}/maps.
+ * If the segment enclosing sample location is found
+ * function succeeds. Non-zero return status indicates 
+ * success. If segment is found and is availible for
+ * reading start and end variables recieves pointers
+ * to the start and the end of segment. */
+int gsegbounds(void *sample, void **start, void **end)
+{
+	int success = 0, fd = -1;
+	void *localStart = NULL, *localEnd = NULL;
+	char buf[256] = {0}, localPathname[256] = {0}, localPerms[16] = {0};
+	int localOffset = 0, localDevMinor = 0, localDevMajor = 0;
+	int localInode = 0;
+	
+	assert(start && end);
+	*start = *end = NULL;
+
+	sprintf(buf, "/proc/%d/maps", getpid());
+	fd = open(buf, O_RDONLY);
+
+	if (fd != -1)
+	{
+		char *bufGetCursor = buf, *bufPutCursor = buf;
+		char *bufEolCursor = NULL;
+		ssize_t readSz = 0, availSz = 0;
+		int numParsed = 0;
+
+		while (1)
+		{
+			if (bufGetCursor != buf)
+			{
+				readSz = bufPutCursor - bufGetCursor;
+				memmove(buf, bufGetCursor, readSz);
+				bufGetCursor = buf;
+				bufPutCursor = buf + readSz;
+			}
+			availSz = sizeof buf - 1 - (bufPutCursor - buf);
+			readSz = read(fd, bufPutCursor, availSz);
+			if (readSz == -1)
+			{
+				if (errno == EINTR) continue;
+				break;
+			}
+			0[bufPutCursor+=readSz]=0;
+			if (readSz == 0 && bufGetCursor >= bufPutCursor) break;
+			bufEolCursor = strchr(buf,'\n');
+			if (!bufEolCursor) 
+			{
+				if (readSz == 0) bufEolCursor = bufPutCursor;
+				else break;
+			}
+			*bufEolCursor = 0;
+			strcpy(localPathname,"");
+			numParsed = sscanf(bufGetCursor,
+					"%p-%p %15s %x %x:%x %d %255s",
+					&localStart, &localEnd, 
+					localPerms, &localOffset, 
+					&localDevMajor, &localDevMinor,
+					&localInode, localPathname);
+			if (numParsed != 7 && numParsed != 8) break;
+			bufGetCursor = bufEolCursor+1;
+
+			if (localStart<=sample && sample<localEnd)
+			{
+				success = 1;
+				if (strchr(localPerms,'r')==NULL)
+				{
+					localStart = localEnd = NULL;
+				}
+				break;
+			}
+		}
+	}
+	close(fd); fd=-1;
+	if (success) {*start = localStart; *end = localEnd;}
+	return success;
+}
+
+void gsymstr(void *addr, char *buf)
+{
+	Dl_info dlinfo = {};
+	if (!dladdr(addr, &dlinfo))
+	{
+		strcpy(buf,"error");
+	}
+	else
+	{
+		sprintf(buf,"%s %s", dlinfo.dli_fname, dlinfo.dli_sname);
+	}
+}
+
+void ctxstracefd(const ucontext_t *ucontext, int fd)
+{
+	uintptr_t stack_top = 0, stack_bot = 0, stack = 0, code = 0, desert = 0;
+	char buf[1024], buf2[512];
+	size_t sz=0;
+
+	assert(ucontext);
+	stack = ucontext->uc_mcontext.gregs[REG_EBP];
+	desert = stack - 1;
+	code = ucontext->uc_mcontext.gregs[REG_EIP];
+
+	if (gsegbounds((void*)stack,(void**)&stack_top,(void**)&stack_bot) &&
+		stack_top<=stack && stack<stack_bot)
+	{
+		/* We have to check that pointers in the list of 
+		 * stack frames do not point outside the stack segment. 
+		 * We also assume that we will move towards the stack 
+		 * bottom while walking the stack. This way we protect 
+		 * from circular stack frames list in a corrupted stack.
+		 * If (stack == 0), we are in the topmost frame. However
+		 * we still have to extract the function address. */ 
+		while (stack == 0 || stack > desert && stack<=stack_bot)
+		{
+			gsymstr((void*)code, buf2);
+			sz = sprintf(buf,"%p %s\n",code,buf2);
+			write(fd, buf, sz);
+			if (stack == 0) break;
+			desert = stack;
+			code  = 1[(uintptr_t *)stack];
+			stack = 0[(uintptr_t *)stack];
+		}
+	}
+}
+
+
+void sig_handler(int signo, siginfo_t *siginfo, void *ucontext)
+{
+dummy_function();
+ctxstracefd(ucontext, 2);
+abort();
+}
+
+void dummy_function2 (void)
+{
+strcpy(NULL,"DIE");
+}
+
+void dummy_function3 (void)
+{
+ dummy_function2();
+}
+
+int
+main (void)
+{
+void *a = NULL, *b = NULL;
+struct sigaction act;
+act.sa_sigaction = sig_handler;
+sigemptyset(&act.sa_mask);
+act.sa_flags = SA_SIGINFO;
+
+gsegbounds(NULL,&a,&b);
+sigaction (SIGSEGV, &act, NULL);
+dummy_function3();
+
+return 0;
+}
+