path: root/percona/5.0.77-b13/innodb_fsync_source.patch

diff -r 61031ebb48ce innobase/buf/buf0flu.c
--- a/innobase/buf/buf0flu.c	Mon Nov 03 05:07:46 2008 -0800
+++ b/innobase/buf/buf0flu.c	Mon Nov 03 05:07:56 2008 -0800
@@ -341,7 +341,7 @@
 
 	/* Now flush the doublewrite buffer data to disk */
 
-	fil_flush(TRX_SYS_SPACE);
+	fil_flush(TRX_SYS_SPACE, FLUSH_FROM_DIRTY_BUFFER);
 
 	/* We know that the writes have been flushed to disk now
 	and in recovery we will find them in the doublewrite buffer
@@ -381,7 +381,7 @@
 
 	/* Now we flush the data to disk (for example, with fsync) */
 
-	fil_flush_file_spaces(FIL_TABLESPACE);
+	fil_flush_file_spaces(FIL_TABLESPACE, FLUSH_FROM_DIRTY_BUFFER);
 
 	/* We can now reuse the doublewrite memory buffer: */
 
@@ -501,7 +501,8 @@
 	}
 #else
 	/* Force the log to the disk before writing the modified block */
-	log_write_up_to(block->newest_modification, LOG_WAIT_ALL_GROUPS, TRUE);
+	log_write_up_to(block->newest_modification, LOG_WAIT_ALL_GROUPS, TRUE,
+		LOG_WRITE_FROM_DIRTY_BUFFER);
 #endif	
 	buf_flush_init_for_writing(block->frame, block->newest_modification,
 						block->space, block->offset);
diff -r 61031ebb48ce innobase/fil/fil0fil.c
--- a/innobase/fil/fil0fil.c	Mon Nov 03 05:07:46 2008 -0800
+++ b/innobase/fil/fil0fil.c	Mon Nov 03 05:07:56 2008 -0800
@@ -245,6 +245,7 @@
 					request */
 	UT_LIST_BASE_NODE_T(fil_space_t) space_list;
 					/* list of all file spaces */
+	ulint flush_types[FLUSH_FROM_NUMBER];/* calls to fil_flush by caller */
 };
 
 /* The tablespace memory cache. This variable is NULL before the module is
@@ -849,7 +850,7 @@
 	/* Flush tablespaces so that we can close modified files in the LRU
 	list */
 
-	fil_flush_file_spaces(FIL_TABLESPACE);		
+	fil_flush_file_spaces(FIL_TABLESPACE, FLUSH_FROM_OTHER);		
 
 	count++;
 
@@ -1309,7 +1310,10 @@
 
 	UT_LIST_INIT(system->unflushed_spaces);
 	UT_LIST_INIT(system->space_list);
-
+	{
+		int x;
+		for (x = 0; x < FLUSH_FROM_NUMBER; ++x) system->flush_types[x] = 0;
+	}
 	return(system);
 }
 
@@ -1437,6 +1441,23 @@
 	}
 
 	mutex_exit(&(system->mutex));
+}
+
+/********************************************************************
+Prints internal counters */
+
+void
+fil_print(FILE *file)
+{
+	fprintf(file,
+		"fsync callers: %lu buffer pool, %lu other, %lu checkpoint, "
+		"%lu log aio, %lu log sync, %lu archive\n",
+		fil_system->flush_types[FLUSH_FROM_DIRTY_BUFFER],
+		fil_system->flush_types[FLUSH_FROM_OTHER],
+		fil_system->flush_types[FLUSH_FROM_CHECKPOINT],
+		fil_system->flush_types[FLUSH_FROM_LOG_IO_COMPLETE],
+		fil_system->flush_types[FLUSH_FROM_LOG_WRITE_UP_TO],
+		fil_system->flush_types[FLUSH_FROM_ARCHIVE]);
 }
 
 /********************************************************************
@@ -2256,7 +2277,7 @@
 
 		os_thread_sleep(20000);
 
-		fil_flush(id);
+		fil_flush(id, FLUSH_FROM_OTHER);
 
 		goto retry;
 
@@ -3574,7 +3595,7 @@
                                         size_after_extend, *actual_size); */
 	mutex_exit(&(system->mutex));	
 
-	fil_flush(space_id);
+	fil_flush(space_id, FLUSH_FROM_OTHER);
 
 	return(success);
 }
@@ -4166,8 +4187,9 @@
 void
 fil_flush(
 /*======*/
-	ulint	space_id)	/* in: file space id (this can be a group of
+	ulint	space_id,	/* in: file space id (this can be a group of
 				log files or a tablespace of the database) */
+	flush_from_type flush_type)/* in: identifies the caller */
 {
 	fil_system_t*	system	= fil_system;
 	fil_space_t*	space;
@@ -4176,7 +4198,7 @@
 	ib_longlong	old_mod_counter;
 
 	mutex_enter(&(system->mutex));
-	
+	system->flush_types[flush_type]++;	
 	HASH_SEARCH(hash, system->spaces, space_id, space,
 							space->id == space_id);
 	if (!space || space->is_being_deleted) {
@@ -4281,7 +4303,8 @@
 void
 fil_flush_file_spaces(
 /*==================*/
-	ulint	purpose)	/* in: FIL_TABLESPACE, FIL_LOG */
+	ulint	purpose,	/* in: FIL_TABLESPACE, FIL_LOG */
+	flush_from_type flush_type)/* in: identifies the caller */
 {
 	fil_system_t*	system	= fil_system;
 	fil_space_t*	space;
@@ -4322,7 +4345,7 @@
 	a non-existing space id. */
 	for (i = 0; i < n_space_ids; i++) {
 
-		fil_flush(space_ids[i]);
+		fil_flush(space_ids[i], flush_type);
 	}
 
 	mem_free(space_ids);
diff -r 61031ebb48ce innobase/include/fil0fil.h
--- a/innobase/include/fil0fil.h	Mon Nov 03 05:07:46 2008 -0800
+++ b/innobase/include/fil0fil.h	Mon Nov 03 05:07:56 2008 -0800
@@ -197,6 +197,13 @@
 fil_init(
 /*=====*/
 	ulint	max_n_open);	/* in: max number of open files */
+/********************************************************************
+ * Prints internal counters. */
+
+void
+fil_print(
+	/*=====*/
+	FILE* file); /* in: output stream */
 /***********************************************************************
 Opens all log files and system tablespace data files. They stay open until the
 database server shutdown. This should be called at a server startup after the
@@ -621,14 +628,26 @@
 	ulint	segment);	/* in: the number of the segment in the aio
 				array to wait for */ 
 /**************************************************************************
+Identifies the caller of fil_flush. */
+typedef enum {
+	FLUSH_FROM_DIRTY_BUFFER,
+	FLUSH_FROM_OTHER,
+	FLUSH_FROM_CHECKPOINT,
+	FLUSH_FROM_LOG_IO_COMPLETE,
+	FLUSH_FROM_LOG_WRITE_UP_TO,
+	FLUSH_FROM_ARCHIVE,
+	FLUSH_FROM_NUMBER
+} flush_from_type;
+/**************************************************************************
 Flushes to disk possible writes cached by the OS. If the space does not exist
 or is being dropped, does not do anything. */
 
 void
 fil_flush(
 /*======*/
-	ulint	space_id);	/* in: file space id (this can be a group of
+	ulint	space_id, 	/* in: file space id (this can be a group of
 				log files or a tablespace of the database) */
+	flush_from_type flush_type);/* in: identifies the caller */
 /**************************************************************************
 Flushes to disk writes in file spaces of the given type possibly cached by
 the OS. */
@@ -636,7 +655,8 @@
 void
 fil_flush_file_spaces(
 /*==================*/
-	ulint	purpose);	/* in: FIL_TABLESPACE, FIL_LOG */
+	ulint	purpose, 	/* in: FIL_TABLESPACE, FIL_LOG */
+	flush_from_type flush_type);/* in: identifies the caller */
 /**********************************************************************
 Checks the consistency of the tablespace cache. */
 
diff -r 61031ebb48ce innobase/include/log0log.h
--- a/innobase/include/log0log.h	Mon Nov 03 05:07:46 2008 -0800
+++ b/innobase/include/log0log.h	Mon Nov 03 05:07:56 2008 -0800
@@ -146,6 +146,22 @@
 log_io_complete(
 /*============*/
 	log_group_t*	group);	/* in: log group */
+
+/**********************************************************
+Describes the caller of log_write_up_to. */
+
+typedef enum {
+	LOG_WRITE_FROM_DIRTY_BUFFER,
+	LOG_WRITE_FROM_BACKGROUND_SYNC,
+	LOG_WRITE_FROM_BACKGROUND_ASYNC,
+	LOG_WRITE_FROM_INTERNAL,
+	LOG_WRITE_FROM_CHECKPOINT_SYNC,
+	LOG_WRITE_FROM_CHECKPOINT_ASYNC,
+	LOG_WRITE_FROM_LOG_ARCHIVE,
+	LOG_WRITE_FROM_COMMIT_SYNC,
+	LOG_WRITE_FROM_COMMIT_ASYNC,
+	LOG_WRITE_FROM_NUMBER
+} log_sync_type;
 /**********************************************************
 This function is called, e.g., when a transaction wants to commit. It checks
 that the log has been written to the log file up to the last log entry written
@@ -159,14 +175,21 @@
 			be written, ut_dulint_max if not specified */
 	ulint	wait,	/* in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
 			or LOG_WAIT_ALL_GROUPS */
-	ibool	flush_to_disk);
-			/* in: TRUE if we want the written log also to be
-			flushed to disk */
+	ibool	flush_to_disk,
+	/* in: TRUE if we want the written log also to be flushed to disk */
+	log_sync_type caller);/* in: identifies the caller */
 /********************************************************************
 Does a syncronous flush of the log buffer to disk. */
 
 void
 log_buffer_flush_to_disk(void);
+/*==========================*/
+/********************************************************************
+Flushes the log buffer. Forces it to disk depending on the value of
+the configuration parameter innodb_flush_log_at_trx_commit. */
+
+void
+log_buffer_flush_maybe_sync(void);
 /*==========================*/
 /********************************************************************
 Advances the smallest lsn for which there are unflushed dirty blocks in the
@@ -744,6 +767,12 @@
 					AND flushed to disk */
 	ulint		n_pending_writes;/* number of currently pending flushes
 					or writes */
+	ulint           log_sync_callers[LOG_WRITE_FROM_NUMBER];
+		/* counts calls to log_write_up_to */
+	ulint           log_sync_syncers[LOG_WRITE_FROM_NUMBER];
+		/* counts calls to log_write_up_to when log file is sync'd */
+	ulint           n_syncs;        /* number of fsyncs done for log file */
+	ulint           n_checkpoints;  /* number of calls to log_checkpoint */
 	/* NOTE on the 'flush' in names of the fields below: starting from
 	4.0.14, we separate the write of the log file and the actual fsync()
 	or other method to flush it to disk. The names below shhould really
diff -r 61031ebb48ce innobase/log/log0log.c
--- a/innobase/log/log0log.c	Mon Nov 03 05:07:46 2008 -0800
+++ b/innobase/log/log0log.c	Mon Nov 03 05:07:56 2008 -0800
@@ -782,6 +782,15 @@
 	log_sys->written_to_all_lsn = log_sys->lsn;
 	
 	log_sys->n_pending_writes = 0;
+	{
+		int x;
+		for (x = 0; x < LOG_WRITE_FROM_NUMBER; ++x) {
+			log_sys->log_sync_callers[x] = 0;
+			log_sys->log_sync_syncers[x] = 0;
+		}
+	}
+	log_sys->n_syncs = 0;
+        log_sys->n_checkpoints = 0;
 
 	log_sys->no_flush_event = os_event_create(NULL);
 
@@ -1066,7 +1075,7 @@
 		if (srv_unix_file_flush_method != SRV_UNIX_O_DSYNC
 		   && srv_unix_file_flush_method != SRV_UNIX_NOSYNC) {
 		
-		        fil_flush(group->space_id);
+			fil_flush(group->space_id, FLUSH_FROM_LOG_IO_COMPLETE);
 		}
 
 #ifdef UNIV_DEBUG
@@ -1088,7 +1097,7 @@
 	    && srv_unix_file_flush_method != SRV_UNIX_NOSYNC
 	    && srv_flush_log_at_trx_commit != 2) {
 
-	        fil_flush(group->space_id);
+		fil_flush(group->space_id, FLUSH_FROM_LOG_IO_COMPLETE);
 	}
 
 	mutex_enter(&(log_sys->mutex));
@@ -1303,9 +1312,10 @@
 			be written, ut_dulint_max if not specified */
 	ulint	wait,	/* in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
 			or LOG_WAIT_ALL_GROUPS */
-	ibool	flush_to_disk)
+	ibool	flush_to_disk,
 			/* in: TRUE if we want the written log also to be
 			flushed to disk */
+	log_sync_type caller) /* in: identifies caller */
 {
 	log_group_t*	group;
 	ulint		start_offset;
@@ -1315,6 +1325,7 @@
 	ulint		loop_count;
 	ulint		unlock;
 
+	log_sys->log_sync_callers[caller]++;
 	if (recv_no_ibuf_operations) {
 		/* Recovery is running and no operations on the log files are
 		allowed yet (the variable name .._no_ibuf_.. is misleading) */
@@ -1465,13 +1476,17 @@
 		so we have also flushed to disk what we have written */
 
 		log_sys->flushed_to_disk_lsn = log_sys->write_lsn;
+		log_sys->n_syncs++;
+		log_sys->log_sync_syncers[caller]++;
 
 	} else if (flush_to_disk) {
 
 		group = UT_LIST_GET_FIRST(log_sys->log_groups);
 
-	        fil_flush(group->space_id);
+		fil_flush(group->space_id, FLUSH_FROM_LOG_WRITE_UP_TO);
 		log_sys->flushed_to_disk_lsn = log_sys->write_lsn;
+		log_sys->n_syncs++;
+		log_sys->log_sync_syncers[caller]++;
 	}
 
 	mutex_enter(&(log_sys->mutex));
@@ -1520,7 +1535,8 @@
 
 	mutex_exit(&(log_sys->mutex));
 
-	log_write_up_to(lsn, LOG_WAIT_ALL_GROUPS, TRUE);
+	log_write_up_to(lsn, LOG_WAIT_ALL_GROUPS, TRUE,
+                        LOG_WRITE_FROM_BACKGROUND_SYNC);
 }
 
 /********************************************************************
@@ -1551,7 +1567,7 @@
 	mutex_exit(&(log->mutex));
 
 	if (do_flush) {
-		log_write_up_to(lsn, LOG_NO_WAIT, FALSE);
+		log_write_up_to(lsn, LOG_NO_WAIT, FALSE, LOG_WRITE_FROM_INTERNAL);
 	}
 }
 
@@ -1921,11 +1937,11 @@
 	}
 
 	if (srv_unix_file_flush_method != SRV_UNIX_NOSYNC) {
-	        fil_flush_file_spaces(FIL_TABLESPACE);
+		fil_flush_file_spaces(FIL_TABLESPACE, FLUSH_FROM_CHECKPOINT);
 	}
 
 	mutex_enter(&(log_sys->mutex));
-
+	log_sys->n_checkpoints++;
 	oldest_lsn = log_buf_pool_get_oldest_modification();
 
 	mutex_exit(&(log_sys->mutex));
@@ -1938,7 +1954,8 @@
 	write-ahead-logging algorithm ensures that the log has been flushed
 	up to oldest_lsn. */
 
-	log_write_up_to(oldest_lsn, LOG_WAIT_ALL_GROUPS, TRUE);
+	log_write_up_to(oldest_lsn, LOG_WAIT_ALL_GROUPS, TRUE,
+		LOG_WRITE_FROM_CHECKPOINT_SYNC);
 
 	mutex_enter(&(log_sys->mutex));
 
@@ -2566,7 +2583,7 @@
 
 	mutex_exit(&(log_sys->mutex));
 
-	fil_flush(group->archive_space_id);
+	fil_flush(group->archive_space_id, FLUSH_FROM_ARCHIVE);
 	
 	mutex_enter(&(log_sys->mutex));
 	
@@ -2647,7 +2664,8 @@
 
 		mutex_exit(&(log_sys->mutex));
 	
-		log_write_up_to(limit_lsn, LOG_WAIT_ALL_GROUPS, TRUE);
+		log_write_up_to(limit_lsn, LOG_WAIT_ALL_GROUPS, TRUE,
+			LOG_WRITE_FROM_LOG_ARCHIVE);
 
 		calc_new_limit = FALSE;
 
@@ -3184,8 +3202,8 @@
 	}
 	mutex_exit(&kernel_mutex);
 
-	fil_flush_file_spaces(FIL_TABLESPACE);
-	fil_flush_file_spaces(FIL_LOG);
+	fil_flush_file_spaces(FIL_TABLESPACE, FLUSH_FROM_OTHER);
+	fil_flush_file_spaces(FIL_LOG, FLUSH_FROM_OTHER);
 
 	/* The call fil_write_flushed_lsn_to_data_files() will pass the buffer
 	pool: therefore it is essential that the buffer pool has been
@@ -3218,7 +3236,7 @@
 
 		fil_write_flushed_lsn_to_data_files(lsn, arch_log_no);
 
-	fil_flush_file_spaces(FIL_TABLESPACE);
+	fil_flush_file_spaces(FIL_TABLESPACE, FLUSH_FROM_OTHER);
 
 	fil_close_all_files();
 
@@ -3331,15 +3349,45 @@
 	time_elapsed = 0.001 + difftime(current_time,
 					log_sys->last_printout_time);
 	fprintf(file,
-	"%lu pending log writes, %lu pending chkp writes\n"
-	"%lu log i/o's done, %.2f log i/o's/second\n",
-	(ulong) log_sys->n_pending_writes,
-	(ulong) log_sys->n_pending_checkpoint_writes,
-	(ulong) log_sys->n_log_ios,
-	((log_sys->n_log_ios - log_sys->n_log_ios_old) / time_elapsed));
+		"%lu pending log writes, %lu pending chkp writes\n"
+		"%lu log i/o's done, %.2f log i/o's/second, %lu syncs, %lu checkpoints\n",
+		(ulong) log_sys->n_pending_writes,
+		(ulong) log_sys->n_pending_checkpoint_writes,
+		(ulong) log_sys->n_log_ios,
+		(log_sys->n_log_ios - log_sys->n_log_ios_old) / time_elapsed,
+		log_sys->n_syncs,
+		log_sys->n_checkpoints);
 
 	log_sys->n_log_ios_old = log_sys->n_log_ios;
 	log_sys->last_printout_time = current_time;
+
+	fprintf(file,
+		"log sync callers: %lu buffer pool, background %lu sync and %lu async, "
+		"%lu internal, checkpoint %lu sync and %lu async, %lu archive, "
+		"commit %lu sync and %lu async\n",
+		log_sys->log_sync_callers[LOG_WRITE_FROM_DIRTY_BUFFER],
+		log_sys->log_sync_callers[LOG_WRITE_FROM_BACKGROUND_SYNC],
+		log_sys->log_sync_callers[LOG_WRITE_FROM_BACKGROUND_ASYNC],
+		log_sys->log_sync_callers[LOG_WRITE_FROM_INTERNAL],
+		log_sys->log_sync_callers[LOG_WRITE_FROM_CHECKPOINT_SYNC],
+		log_sys->log_sync_callers[LOG_WRITE_FROM_CHECKPOINT_ASYNC],
+		log_sys->log_sync_callers[LOG_WRITE_FROM_LOG_ARCHIVE],
+		log_sys->log_sync_callers[LOG_WRITE_FROM_COMMIT_SYNC],
+		log_sys->log_sync_callers[LOG_WRITE_FROM_COMMIT_ASYNC]);
+
+	fprintf(file,
+		"log sync syncers: %lu buffer pool, background %lu sync and %lu async, "
+		"%lu internal, checkpoint %lu sync and %lu async, %lu archive, "
+		"commit %lu sync and %lu async\n",
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_DIRTY_BUFFER],
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_BACKGROUND_SYNC],
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_BACKGROUND_ASYNC],
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_INTERNAL],
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_CHECKPOINT_SYNC],
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_CHECKPOINT_ASYNC],
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_LOG_ARCHIVE],
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_COMMIT_SYNC],
+		log_sys->log_sync_syncers[LOG_WRITE_FROM_COMMIT_ASYNC]);
 
 	mutex_exit(&(log_sys->mutex));
 }
diff -r 61031ebb48ce innobase/srv/srv0srv.c
--- a/innobase/srv/srv0srv.c	Mon Nov 03 05:07:46 2008 -0800
+++ b/innobase/srv/srv0srv.c	Mon Nov 03 05:07:56 2008 -0800
@@ -1638,6 +1638,12 @@
 		(ulong)time_elapsed);
 
 	fputs("----------\n"
+               "BACKGROUND THREAD\n"
+               "----------\n", file);
+        fil_print(file);
+
+
+	fputs("----------\n"
 		"SEMAPHORES\n"
 		"----------\n", file);
 	sync_print(file);
diff -r 61031ebb48ce innobase/trx/trx0sys.c
--- a/innobase/trx/trx0sys.c	Mon Nov 03 05:07:46 2008 -0800
+++ b/innobase/trx/trx0sys.c	Mon Nov 03 05:07:56 2008 -0800
@@ -511,7 +511,7 @@
 		page += UNIV_PAGE_SIZE;
 	}
 
-	fil_flush_file_spaces(FIL_TABLESPACE);
+	fil_flush_file_spaces(FIL_TABLESPACE, FLUSH_FROM_OTHER);
 	
 leave_func:
 	ut_free(unaligned_read_buf);
diff -r 61031ebb48ce innobase/trx/trx0trx.c
--- a/innobase/trx/trx0trx.c	Mon Nov 03 05:07:46 2008 -0800
+++ b/innobase/trx/trx0trx.c	Mon Nov 03 05:07:56 2008 -0800
@@ -916,19 +916,21 @@
                         if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
                              	/* Write the log but do not flush it to disk */
 
-                               	log_write_up_to(lsn, LOG_WAIT_ONE_GROUP,
-									FALSE);
+                               	log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE,
+                                                LOG_WRITE_FROM_COMMIT_ASYNC);
                         } else {
                                	/* Write the log to the log files AND flush
                                	them to disk */
 
-                               	log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
+                               	log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE,
+                                                LOG_WRITE_FROM_COMMIT_SYNC);
                         }
                 } else if (srv_flush_log_at_trx_commit == 2) {
 
                         /* Write the log but do not flush it to disk */
 
-                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
+                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE,
+                                        LOG_WRITE_FROM_COMMIT_ASYNC);
                 } else {
                         ut_error;
                 }
@@ -1659,18 +1661,21 @@
                 if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
                         /* Write the log but do not flush it to disk */
 
-                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
+                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE,
+                                        LOG_WRITE_FROM_COMMIT_ASYNC);
                 } else {
                         /* Write the log to the log files AND flush them to
                         disk */
 
-                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
+                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE,
+                                        LOG_WRITE_FROM_COMMIT_SYNC);
                 }
         } else if (srv_flush_log_at_trx_commit == 2) {
 
                 /* Write the log but do not flush it to disk */
 
-                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
+                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE,
+                                LOG_WRITE_FROM_COMMIT_ASYNC);
         } else {
                 ut_error;
         }
@@ -1906,19 +1911,21 @@
                    	if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
                         	/* Write the log but do not flush it to disk */
 
-                        	log_write_up_to(lsn, LOG_WAIT_ONE_GROUP,
-								FALSE);
+                        	log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE,
+                                          LOG_WRITE_FROM_COMMIT_ASYNC);
                         } else {
                                	/* Write the log to the log files AND flush
                                	them to disk */
 
-                               	log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
+                               	log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE,
+                                                LOG_WRITE_FROM_COMMIT_SYNC);
                         }
                 } else if (srv_flush_log_at_trx_commit == 2) {
 
                         /* Write the log but do not flush it to disk */
 
-                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
+                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE,
+                                        LOG_WRITE_FROM_COMMIT_ASYNC);
                 } else {
                         ut_error;
                 }
diff -r 61031ebb48ce patch_info/innodb_fsync_source.info
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/patch_info/innodb_fsync_source.info	Mon Nov 03 05:07:56 2008 -0800
@@ -0,0 +1,9 @@
+File=innodb_fsync_source.patch
+Name=Information of fsync callers in InnoDB
+Version=1.0
+Author=Google
+License=GPL
+Comment=
+ChangeLog=
+2008-11-01 
+VT: Initial porting