sedna 0.5.1 → 0.6.0

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

@@ -0,0 +1,119 @@
+/*
+ * File:  pping.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _PPING_H
+#define _PPING_H
+
+#include "common/sedna.h"
+#include "common/base.h"
+
+#include "common/u/usocket.h"
+#include "common/u/uthread.h"
+#include "common/u/usem.h"
+
+#if (defined(EL_DEBUG) && (EL_DEBUG == 1))
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#endif
+
+
+#define PPING_ON
+
+#define PPING_MAX_HOSTLEN 128
+
+class pping_client
+{
+private:
+    int port;
+    char host[PPING_MAX_HOSTLEN];
+    int component;
+    USOCKET sock;
+    bool stop_keep_alive;
+    bool initialized;
+    UTHANDLE client_thread_handle;
+    UUnnamedSemaphore sem;
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Timeout counter and flags. 
+    /// Timer is implemented above pping since there is no portable way to implement good timer on POSIX systems.
+    int counter;
+    volatile int timeout;
+    volatile bool  reset_flag;
+    volatile bool* signaled_flag;
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    void throw_exception(SednaUserException& e, bool is_soft);
+    void startup(SednaUserException& e, bool is_soft);
+
+#if (defined(EL_DEBUG) && (EL_DEBUG == 1))
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Exception logging. 
+#ifdef _WIN32
+private:
+	volatile LPEXCEPTION_POINTERS exceptPtrs;
+	volatile DWORD except_thread_id;
+	volatile UFile stacktrace_fh;
+public:
+	void WriteStackTraceFile(LPEXCEPTION_POINTERS exceptPtrs);
+#endif
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#endif
+
+
+public:
+    pping_client(int _port_, int _component_, const char* _host_ = NULL);
+    pping_client(int _port_, int _component_, volatile bool* _signaled_flag_, const char* _host_ = NULL);
+    ~pping_client();
+
+    void startup(SednaUserException& e);
+    void startup(SednaUserSoftException& e);
+    void shutdown();
+
+    void start_timer(int _timeout_);
+    void stop_timer();
+
+    friend U_THREAD_PROC(pping_client_thread_proc, arg);
+};
+
+
+#define PPING_SERVER_THREAD_TABLE_SIZE		(2 * (MAX_SESSIONS_NUMBER + MAX_DBS_NUMBER))
+
+
+class pping_server
+{
+public:
+    struct thread_table_t
+    {
+        UTHANDLE handle;
+        bool is_running;
+        bool is_empty;
+    };
+
+private:
+    int port;
+    USOCKET sock;
+    int component;
+    bool initialized;
+    UTHANDLE server_lstn_thread_handle;
+    volatile bool close_lstn_thread;
+    thread_table_t thread_table[PPING_SERVER_THREAD_TABLE_SIZE];
+
+public:
+    pping_server(int _port_, int _component_);
+    ~pping_server();
+
+    void startup();
+    void shutdown();
+
+    friend U_THREAD_PROC(pping_server_cli_thread_proc, arg);
+    friend U_THREAD_PROC(pping_server_lstn_thread_proc_mt, arg);
+    friend U_THREAD_PROC(pping_server_lstn_thread_proc_st, arg);
+    friend int client_exception_handler(USOCKET sock, const pping_server *pps);
+};
+
+
+#endif

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

@@ -0,0 +1,273 @@
+/*********************************************************************************************************
+ * 
+ *  Ok, here is the main plan:
+ *		1) Read cfg file in /data/rcvtest.cfg
+ *		2) If we have some previous saved state use it instead (/data/rcvstate.tmp)
+ *      3) When we step on macros RCV_TEST_CRASH rcvTestCrashPoint function is called
+ *		4) Check if we need to crash here by: 
+ *				a) check if function is in cfg table
+ *				b) computing probability
+ *		5) If check is ok then decrementing number of tries, save state to rcvstate.tmp file and exit.
+ *		6) Else, continuing execution
+ *
+ *	Config note: you must define all crash points in rcvtest.cfg along with crash probability 
+ *	(real from [0; 1]) and max number of tries (-1 for infinite number; 0 to disable crash).
+ *
+ ********************************************************************************************************/
+
+#include "common/rcv_test.h"
+#include "common/errdbg/d_printf.h"
+#include "common/u/uhdd.h"
+
+#include <map>
+#include <string>
+
+typedef struct
+{
+	int try_numbers;
+	double prob;
+
+} rcvPointInfo;
+
+using namespace std;
+
+static  map <string, rcvPointInfo *> fname_cfg_table;
+typedef	map <string, rcvPointInfo *>::iterator table_it;
+
+// store current crash info into file; file name is relative to SEDNA_DATA
+static void rcvSerializeInfoToFile(const char *file_name)
+{
+	char tmp_file_name[U_MAX_PATH];
+	UFile tfh;
+	table_it it = fname_cfg_table.begin();
+	int written, err = 0, len;
+
+	sprintf(tmp_file_name, "%s/%s", SEDNA_DATA, file_name);
+
+	// delete old file (ignore error, if it doesn't exist)	
+	uDeleteFile(tmp_file_name, __sys_call_error);
+
+	// create new file
+	tfh = uCreateFile(tmp_file_name, U_SHARE_READ | U_SHARE_WRITE, U_READ_WRITE, 0, NULL, NULL);
+	if (tfh == U_INVALID_FD)
+   		fprintf(stderr, "Cannot create temporary file to store rcv_crash info\n");
+
+	while (it != fname_cfg_table.end())
+	{
+		// get function name length
+		len = (it->first).size();
+
+		// store string length
+		if (uWriteFile(tfh, &len, sizeof len, &written, __sys_call_error) == 0 ||
+				written != sizeof len)
+		{
+	   		fprintf(stderr, "Cannot serialize recovery crash info\n");
+			err = 1;
+			break;
+		}
+
+		// store current function name
+		if (uWriteFile(tfh, (it->first).c_str(), len, &written, __sys_call_error) == 0 ||
+				written != len)
+		{
+	   		fprintf(stderr, "Cannot serialize recovery crash info\n");
+			err = 1;
+			break;
+		}
+
+		// store the associated structure
+		if (uWriteFile(tfh, (it->second), sizeof(rcvPointInfo), &written, __sys_call_error) == 0 ||
+				written != sizeof(rcvPointInfo))
+		{
+	   		fprintf(stderr, "Cannot serialize recovery crash info\n");
+			err = 1;
+			break;
+		}
+		
+		// next element
+		it++;
+	}
+
+	uCloseFile(tfh, __sys_call_error);
+
+	// delete tmp file in case of error	
+	if (err == 1)
+		uDeleteFile(tmp_file_name, __sys_call_error);
+}
+
+// load current crash info from file; file name is relative to SEDNA_DATA
+// Returns: 0 - all ok; 1 - some problem (file not found, etc.)
+static int rcvLoadInfoFromFile(const char *file_name)
+{
+	char tmp_file_name[U_MAX_PATH], func_buf[1024];
+	UFile tfh;
+	int readb, len;
+	rcvPointInfo *rcvInfo;
+	table_it it;
+
+	sprintf(tmp_file_name, "%s/%s", SEDNA_DATA, file_name);
+
+	// open temp file
+	tfh = uOpenFile(tmp_file_name, U_SHARE_READ | U_SHARE_WRITE, U_READ_WRITE, 0, NULL);
+	// if we cannot open tmp file then read default cfg instead
+	if (tfh == U_INVALID_FD)
+		return 1;  
+
+	while (1)
+	{
+		// load string length
+		if (uReadFile(tfh, &len, sizeof(len), &readb, __sys_call_error) == 0 ||
+				readb != sizeof(len))
+			break;
+
+		// load current function name
+		if (uReadFile(tfh, func_buf, len, &readb, __sys_call_error) == 0 ||
+				readb != len)
+			break;
+
+		// add trailing zero
+		func_buf[len] = '\0';
+
+		// allocate new info structure
+		if ((rcvInfo = (rcvPointInfo *)malloc(sizeof(rcvPointInfo))) == NULL)
+			throw SYSTEM_EXCEPTION("Cannot allocate memory!");
+
+		// load the associated structure
+		if (uReadFile(tfh, rcvInfo, sizeof(rcvPointInfo), &readb, __sys_call_error) == 0 ||
+				readb != sizeof(rcvPointInfo))
+			break;
+
+		// append info to the table
+		fname_cfg_table[func_buf] = rcvInfo;
+	}
+
+	uCloseFile(tfh, __sys_call_error);
+
+	// delete tmp file in case of error	and clear read config
+	if (readb != 0)
+	{
+		uDeleteFile(tmp_file_name, __sys_call_error);
+		for (it = fname_cfg_table.begin(); it != fname_cfg_table.end(); it++)
+			free(it->second);
+
+		fname_cfg_table.clear();
+
+		return 1;
+	}
+
+	return 0;
+}
+
+void rcvTestCrashPoint(const char *func_name)
+{
+    UFile r_fh;
+	rcvPointInfo *point_info;
+	table_it it;
+	char crash_info[256];
+	double prob;
+	int written;
+
+	// if we don't have points to crash then return
+	if (fname_cfg_table.empty()) return;
+
+	// try to find info about the point	
+	it = fname_cfg_table.find(string(func_name));
+
+	// nope, so don't crash	
+	if (it == fname_cfg_table.end()) return;
+
+	// ok, we've found it	
+	point_info = it->second;
+
+    // check probability
+	if ((prob = ((double)rand() / (double)RAND_MAX)) < point_info->prob)
+    {
+		// print to elog
+		elog(EL_ERROR, ("\nTr is crashed in %s due to recovery testing\n", func_name));
+		// and to the console
+		d_printf2("\nTr is crashed in %s due to recovery testing\n", func_name);
+       
+		// correct number of tries
+		if (point_info->try_numbers != -1)
+			point_info->try_numbers--;
+
+		// recovery file-flag
+		string rcv_fname = string(SEDNA_DATA) + string("/data/") + string("rcv_test_crash");
+
+		// create notification file, so that recovery driver could recognize recovery crash
+		uDeleteFile(rcv_fname.c_str(), __sys_call_error);
+		r_fh = uCreateFile(rcv_fname.c_str(), U_SHARE_READ | U_SHARE_WRITE, U_READ_WRITE, 0, NULL, NULL);
+		if (r_fh == U_INVALID_FD)
+       		fprintf(stderr, "Cannot create rcv_test_crash file\n");
+		
+		// write some debug info in this file
+		sprintf(crash_info, "point=%s genp=%lf prob=%lf tryrem=%d", func_name, prob, point_info->prob,
+			point_info->try_numbers);
+
+		// write this info to the file (ignore errors)
+		uWriteFile(r_fh, crash_info, strlen(crash_info), &written, __sys_call_error);
+
+		uCloseFile(r_fh, NULL);
+
+		// if it is the last crash then delete record from config table
+		if (point_info->try_numbers == 0)
+		{
+			free(it->second);
+			fname_cfg_table.erase(it);
+		}
+
+		// serialize current config info to a rcvstate.tmp file to load it after recovery
+		rcvSerializeInfoToFile("/data/rcvstate.tmp");
+
+		// do abnormal exit (recovery crash)
+		_exit(1);
+    }
+}
+
+// read recovery config in /data/rcvtest.cfg
+void rcvReadTestCfg()
+{
+	char rcv_file_name[U_MAX_PATH], read_str[1024], func_name[256];
+	int max_try;
+	double crash_prob;
+	FILE *fd;
+	rcvPointInfo *rcvInfo;
+
+	// init random seed
+	srand((unsigned)time(NULL));
+
+	// first, try to read saved state
+	if (rcvLoadInfoFromFile("/data/rcvstate.tmp") == 0)
+		return;
+	
+	// else, try to read global recovery testing config
+	sprintf(rcv_file_name, "%s/data/rcvtest.cfg", SEDNA_DATA);
+
+	d_printf2("\nrcv_test_cfg_file=%s\n", rcv_file_name);
+
+	// open config file
+	fd = fopen(rcv_file_name, "r");
+	if (fd == NULL) return;
+
+	// parse it until EOF	
+	while (fgets(read_str, 1024, fd))     
+		// ignore comments and not well-defined strings
+		if (sscanf(read_str, "%s %lf %d\n", func_name, &crash_prob, &max_try) == 3 && 
+				func_name[0] != '#' && (max_try > 0 || max_try == -1))
+		{
+			// allocate new info structure
+			if ((rcvInfo = (rcvPointInfo *)malloc(sizeof(rcvPointInfo))) == NULL)
+				throw SYSTEM_EXCEPTION("Cannot allocate memory!");
+
+			rcvInfo->try_numbers = max_try;
+			rcvInfo->prob = crash_prob;
+			
+			fname_cfg_table[func_name] = rcvInfo;
+		}
+
+	// if we've caught an error then complain
+	if (!feof(fd))
+		throw USER_EXCEPTION2(SE4044, "rcvtest.cfg");
+
+	fclose(fd);
+}

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

@@ -0,0 +1,19 @@
+#ifndef __RCV_TEST_H__
+#define __RCV_TEST_H__
+
+//#define RCV_TEST_CRASH
+
+#ifdef RCV_TEST_CRASH
+#define RECOVERY_CRASH rcvTestCrashPoint(__SE_FUNCTION__)
+#else
+#define RECOVERY_CRASH
+#endif
+
+// read test_rcv.xml and parses it to a table
+void rcvReadTestCfg();
+
+// check if function name has been considered in cfg and crashes tr with some probability
+void rcvTestCrashPoint(const char *func_name);
+
+#endif
+

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

@@ -0,0 +1,128 @@
+/*
+ * File:  sedna.c
+ * Copyright (C) 2006 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+/*
+#include "common/sedna.h"
+#include "common/errdbg/d_printf.h"
+#include "common/u/usecurity.h"
+#include "common/u/uhdd.h"
+#include "common/ipc_ops.h"
+*/
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#endif
+
+void DumpFaultInfo()
+{
+	int processId = -1, bIsTrunc = 0;
+	const char *cmdline = "<failed to obtain cmdline>";
+#ifdef _WIN32
+	/* very simple, isn't it? */ 
+	const char *cmdline2 = NULL;
+	processId = (int)GetCurrentProcessId();
+	cmdline2 = GetCommandLine();
+	if (cmdline2) cmdline = cmdline2;
+#else
+	/* rather bloat 
+ * 		- read command line from /proc/[PID]/cmdline
+ * 		- reconstruct command line (we get it already tokenized)
+ * 		- certain characters are escaped during reconstruction
+ * 		- operating on fixed size buffers thus having to truncate
+ * 		  resulting string gracefully when ran out of buffer space */ 
+	pid_t pid = 0;
+	int fd = 0, bNeedQuotes = 0;
+	size_t sz = 0;
+	char path[64];
+	char buf[256], obuf[256];
+	char *a = NULL, *b = NULL, *aEnd = NULL, *bEnd = NULL;
+
+	pid = getpid();
+	sz = snprintf(path, sizeof path, "/proc/%d/cmdline", (int)pid);
+	if (sz==-1 || sz>=sizeof path)
+	{
+		/* buffer too small to hold the path */ 
+	}
+	else if (fd = open(path, O_RDONLY), fd==-1)
+	{
+		/* proc filesystem n/a */
+	}
+	else
+	{
+		a = buf;
+		aEnd = buf + sizeof(buf) - 1; /* space for \0 terminator */
+		b = obuf;
+		bEnd = obuf + sizeof (obuf) - 2; /* space for extra char & \0 */
+
+		for (sz=1; a!=aEnd && sz>0; )
+		{
+			/* have one extra byte after aEnd, to identify trunc */ 
+			sz = read(fd, a, aEnd - a + 1);
+			if (sz==-1)
+			{
+				if (errno == EINTR) sz=1; /* not an error */
+			}
+			else a+=sz;
+		}
+		close(fd);
+		/* read successfully? */
+		if (sz!=-1)
+		{
+			bIsTrunc = (a>aEnd);
+			if (!bIsTrunc) aEnd = a; 
+			a=buf; *aEnd=0;
+			/* processing tokens one-by-one (\0 terminated)*/ 
+			while (a<aEnd && b<bEnd)
+			{
+				/* processing token */ 
+				bNeedQuotes = (*a==0); /* when token is "" */ 
+				if (bNeedQuotes) b++[0]='\"';
+				while (*a && b<bEnd)
+				{
+					switch (*a)
+					{
+					/* escape special chars */
+					case ' ':
+					case '\\':
+					case '\"':
+						/* we have 1 extra char 
+ * 						   after bEnd, so this is 
+ * 						   valid */ 
+						b++[0] = '\\';
+					}
+					b++[0] = *a;
+					++a;
+				}
+				bIsTrunc |= (bNeedQuotes && b>=bEnd);
+				if (b<bEnd && bNeedQuotes) b++[0]='\"';
+				/* a+1 points to next token, if one exists */ 
+				if (a+1<aEnd && b<bEnd) b++[0]=' ';
+				/* if we discard ' ' due to truncation we will
+ * 				   leave outter loop prematurely and bIsTrunc
+ * 				   flag is set outside (not all tokens 
+ * 				   processed)  */
+				bIsTrunc |= (*a!=0);
+				++a;
+			}
+			bIsTrunc |= (a<aEnd); /* not all tokens processed */
+			bEnd = b; b=obuf; *bEnd=0;
+			cmdline = obuf;
+		}
+		processId = (int)pid;
+	}
+#endif
+	assert (cmdline);	
+	fprintf(stderr, "in process [%d] %s%s\n", 
+			processId, cmdline, 
+			bIsTrunc ? "...<truncated>":"");
+};
+