Merge lp:~vkolesnikov/pbxt/pbxt-diskfull into lp:pbxt

[Vladimir Kolesnikov]

=== modified file 'ChangeLog'
--- ChangeLog	2009-07-07 10:54:25 +0000
+++ ChangeLog	2009-07-13 10:48:25 +0000
@@ -1,6 +1,14 @@
 PBXT Release Notes
 ==================
 
+RN258: updated xt_p_join implementation for Windows to check if a thread has already exited or has not yet started
+
+RN257: Removed false assertion that could fail during restore if a transaction log page was zero-filled
+
+RN256: Update datalog eof pointer only if write opearions were sucessful
+
+RN255: Added re-allocation of of filemap if allocating the of the new map failed. This often happens if there's not enough space on disk.
+
 ------- 1.0.08 RC2 - 2009-06-30
 
 RN253: Use fcntl(F_FULLFSYNC) instead of fsync on platforms that support it. Improper fsync operation was presumably the reason of index corruption on Mac OS X

=== modified file 'src/datalog_xt.cc'
--- src/datalog_xt.cc	2009-05-19 14:13:25 +0000
+++ src/datalog_xt.cc	2009-07-13 10:48:25 +0000
@@ -1110,7 +1110,6 @@
 
 	*log_id = dlb_data_log->dlf_log_id;
 	*out_offset = dlb_data_log->dlf_log_eof;
-	dlb_data_log->dlf_log_eof += req_size;
 	return OK;
 }
 
@@ -1158,6 +1157,12 @@
 
 	if (!xt_pwrite_file(dlb_data_log->dlf_log_file, log_offset, size, data, &thread->st_statistics.st_data, thread))
 		return FAILED;
+
+	/* Increment of dlb_data_log->dlf_log_eof was moved here from dlb_get_log_offset()
+	 * to ensure it is done after a successful update of the log, otherwise otherwise a 
+	 * gap occurs in the log which cause eof to be detected  in middle of the log
+	 */
+	dlb_data_log->dlf_log_eof += size;
 #ifdef DEBUG
 	if (log_offset + size > dlb_max_write_offset)
 		dlb_max_write_offset = log_offset + size;
@@ -1179,10 +1184,12 @@
 			if (dlb_buffer_size >= dlb_buffer_len + size) {
 				memcpy(dlb_log_buffer + dlb_buffer_len, data, size);
 				dlb_buffer_len += size;
+				dlb_data_log->dlf_log_eof += size;
 				return OK;
 			}
 		}
-		dlb_flush_log(FALSE, thread);
+		if (dlb_flush_log(FALSE, thread) != OK)
+			return FAILED;
 	}
 	
 	ASSERT_NS(dlb_buffer_len == 0);
@@ -1191,6 +1198,7 @@
 		dlb_buffer_offset = log_offset;
 		dlb_buffer_len = size;
 		memcpy(dlb_log_buffer, data, size);
+		dlb_data_log->dlf_log_eof += size;
 		return OK;
 	}
 
@@ -1202,6 +1210,7 @@
 		dlb_max_write_offset = log_offset + size;
 #endif
 	dlb_flush_required = TRUE;
+	dlb_data_log->dlf_log_eof += size;
 	return OK;
 }
 

=== modified file 'src/filesys_xt.cc'
--- src/filesys_xt.cc	2009-07-07 10:54:25 +0000
+++ src/filesys_xt.cc	2009-07-13 10:48:25 +0000
@@ -1384,14 +1384,23 @@
 		}
 		mm->mm_start = NULL;
 #ifdef XT_WIN
-		if (!CloseHandle(mm->mm_mapdes))
+		/* It is possible that a previous remap attempt has failed: the map was closed
+		 * but the new map was not allocated (e.g. because of insufficient disk space). 
+		 * In this case mm->mm_mapdes will be NULL.
+		 */
+		if (mm->mm_mapdes && !CloseHandle(mm->mm_mapdes))
 			return xt_register_ferrno(XT_REG_CONTEXT, fs_get_win_error(), xt_file_path(map));
 		mm->mm_mapdes = NULL;
 #endif
+		off_t old_size = mm->mm_length;
 		mm->mm_length = new_size;
 
-		if (!fs_map_file(mm, map->fr_file, TRUE))
+		if (!fs_map_file(mm, map->fr_file, TRUE)) {
+			/* Try to restore old mapping */
+			mm->mm_length = old_size;
+			fs_map_file(mm, map->fr_file, FALSE);
 			return FAILED;
+		}
 	}
 	return OK;
 	

=== modified file 'src/ha_pbxt.cc'
--- src/ha_pbxt.cc	2009-07-02 12:13:58 +0000
+++ src/ha_pbxt.cc	2009-07-13 10:48:25 +0000
@@ -1174,7 +1174,11 @@
 #ifndef DRIZZLED
 					myxt_mutex_lock(&LOCK_plugin);
 #endif
-					xt_throw(self);
+					/* It is possible that the error was reset by cleanup code.
+					 * Set a generic error code in that case.
+					 */
+					if (!self->t_exception.e_xt_err)
+						xt_throw_error(self, XT_REG_CONTEXT, XT_SYSTEM_ERROR, 0, "Initialization failed"); 
 				}
 				cont_(b);
 

=== modified file 'src/pthread_xt.cc'
--- src/pthread_xt.cc	2009-01-19 19:03:45 +0000
+++ src/pthread_xt.cc	2009-07-13 10:48:25 +0000
@@ -395,20 +395,31 @@
 
 int xt_p_join(pthread_t thread, void **value)
 {
-	switch (WaitForSingleObject(thread, INFINITE)) {
-		case WAIT_OBJECT_0: 
-		case WAIT_TIMEOUT:
-			/* Don't do this! According to the Win docs:
-			 * _endthread automatically closes the thread handle 
-			 * (whereas _endthreadex does not). Therefore, when using 
-			 * _beginthread and _endthread, do not explicitly close the 
-			 * thread handle by calling the Win32 CloseHandle API.
-			CloseHandle(thread);
-			 */
-			break;
-		case WAIT_FAILED:
-			return GetLastError();
+	DWORD exitcode;
+
+	while(1) {
+		switch (WaitForSingleObject(thread, 10000)) {
+			case WAIT_OBJECT_0:
+				return 0;
+			case WAIT_TIMEOUT:
+				/* Don't do this! According to the Win docs:
+				 * _endthread automatically closes the thread handle
+				 * (whereas _endthreadex does not). Therefore, when using
+				 * _beginthread and _endthread, do not explicitly close the
+				 * thread handle by calling the Win32 CloseHandle API.
+				CloseHandle(thread);
+				 */
+				/* This is done so that if the thread was not [yet] in the running
+				 * state when this function was called we won't deadlock here.
+				 */
+				if (GetExitCodeThread(thread, &exitcode) && (exitcode == STILL_ACTIVE))
+					break;
+				return 0;
+			case WAIT_FAILED:
+				return GetLastError();
+		}
 	}
+
 	return 0;
 }
 

=== modified file 'src/restart_xt.cc'
--- src/restart_xt.cc	2009-06-11 08:02:28 +0000
+++ src/restart_xt.cc	2009-07-13 10:48:25 +0000
@@ -629,6 +629,9 @@
 	xtWord1				*rec_data = NULL;
 	XTTabRecFreeDPtr	free_data;
 
+	if (tab->tab_dic.dic_key_count == 0)
+		check_index = FALSE;
+
 	switch (record->xl.xl_status_1) {
 		case XT_LOG_ENT_REC_MODIFIED:
 		case XT_LOG_ENT_UPDATE:
@@ -642,7 +645,7 @@
 			/* This should be done before we apply change to table, as otherwise we lose
 			 * the key value that we need to remove from index
 			 */
-			if (check_index && ot->ot_table->tab_dic.dic_key_count && record->xl.xl_status_1 == XT_LOG_ENT_REC_MODIFIED) {
+			if (check_index && record->xl.xl_status_1 == XT_LOG_ENT_REC_MODIFIED) {
 				if ((rec_data = xres_load_record(self, ot, rec_id, NULL, 0, rec_buf, tab->tab_dic.dic_ind_cols_req)))
 					xres_remove_index_entries(ot, rec_id, rec_data);			
 			}
@@ -652,7 +655,7 @@
 				xt_throw(self);
 			tab->tab_bytes_to_flush += len;
 
-			if (check_index && ot->ot_table->tab_dic.dic_key_count) {
+			if (check_index) {
 				switch (record->xl.xl_status_1) {
 					case XT_LOG_ENT_DELETE:
 					case XT_LOG_ENT_DELETE_BG:

=== modified file 'src/xactlog_xt.cc'
--- src/xactlog_xt.cc	2009-06-30 15:58:15 +0000
+++ src/xactlog_xt.cc	2009-07-13 10:48:25 +0000
@@ -1132,6 +1132,7 @@
 				/* [(8)] Flush the compactor log. */
 				xt_lock_mutex_ns(&xl_db->db_co_dlog_lock);
 				if (!xl_db->db_co_thread->st_dlog_buf.dlb_flush_log(TRUE, thread)) {
+					xl_log_bytes_written -= part_size;
 					xt_unlock_mutex_ns(&xl_db->db_co_dlog_lock);
 					goto write_failed;
 				}
@@ -1140,8 +1141,10 @@
 
 			/* And flush if required: */
 			flush_time = thread->st_statistics.st_xlog.ts_flush_time;
-			if (!xt_flush_file(xl_log_file, &thread->st_statistics.st_xlog, thread))
+			if (!xt_flush_file(xl_log_file, &thread->st_statistics.st_xlog, thread)) {
+				xl_log_bytes_written -= part_size;
 				goto write_failed;
+			}
 			xl_last_flush_time = (u_int) (thread->st_statistics.st_xlog.ts_flush_time - flush_time);
 
 			xl_log_bytes_flushed = xl_log_bytes_written;
@@ -2514,9 +2517,6 @@
 				if (!record) {
 					break;
 				}
-				/* Count the number of bytes read from the log: */
-				db->db_xlog.xl_log_bytes_read += ws->ws_seqread.xseq_record_len;
-
 				switch (record->xl.xl_status_1) {
 					case XT_LOG_ENT_HEADER:
 						break;
@@ -2540,6 +2540,8 @@
 						xt_xres_apply_in_order(self, ws, ws->ws_seqread.xseq_rec_log_id, ws->ws_seqread.xseq_rec_log_offset, record);
 						break;
 				}
+				/* Count the number of bytes read from the log: */
+				db->db_xlog.xl_log_bytes_read += ws->ws_seqread.xseq_record_len;
 			}
 		}