From: Marc Alff Date: July 14 2010 4:24pm Subject: bzr push into mysql-trunk-bugfixing branch (marc.alff:3105 to 3106) List-Archive: http://lists.mysql.com/commits/113608 Message-Id: <20100714162407.0504C45E80@linux-su11.site> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============2567393122922207139==" --===============2567393122922207139== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline 3106 Marc Alff 2010-07-14 Implemented code review comments. Fixed style according to the specific innodb style, for innodb code. modified: storage/innobase/include/os0file.ic storage/innobase/include/sync0rw.ic storage/innobase/row/row0merge.c 3105 Marc Alff 2010-07-14 [merge] local merge renamed: mysql-test/r/analyse.result => mysql-test/r/func_analyse.result mysql-test/t/analyse.test => mysql-test/t/func_analyse.test modified: BUILD/build_mccge.sh cmake/package_name.cmake sql/sql_class.h === modified file 'include/mysql/psi/mysql_file.h' --- a/include/mysql/psi/mysql_file.h 2010-07-08 21:20:08 +0000 +++ b/include/mysql/psi/mysql_file.h 2010-07-09 23:00:24 +0000 @@ -506,9 +506,10 @@ inline_mysql_file_fgets( char *result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_READ); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) size, src_file, src_line); @@ -532,9 +533,10 @@ inline_mysql_file_fgetc( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_READ); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 1, src_file, src_line); @@ -558,10 +560,11 @@ inline_mysql_file_fputs( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; size_t bytes= 0; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_WRITE); if (likely(locker != NULL)) { @@ -588,9 +591,10 @@ inline_mysql_file_fputc( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_WRITE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 1, src_file, src_line); @@ -614,9 +618,10 @@ inline_mysql_file_fprintf(MYSQL_FILE *fi va_list args; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_WRITE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, __FILE__, __LINE__); @@ -642,9 +647,10 @@ inline_mysql_file_vfprintf( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_WRITE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -668,9 +674,10 @@ inline_mysql_file_fflush( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_FLUSH); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -700,9 +707,10 @@ inline_mysql_file_fstat( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(filenr, + locker= PSI_server->get_thread_file_descriptor_locker(&state, filenr, PSI_FILE_FSTAT); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -726,9 +734,11 @@ inline_mysql_file_stat( MY_STAT *result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_STAT, + locker= PSI_server->get_thread_file_name_locker(&state, + key, PSI_FILE_STAT, path, &locker); if (likely(locker != NULL)) PSI_server->start_file_open_wait(locker, src_file, src_line); @@ -752,9 +762,10 @@ inline_mysql_file_chsize( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(file, + locker= PSI_server->get_thread_file_descriptor_locker(&state, file, PSI_FILE_CHSIZE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) newlength, src_file, @@ -784,10 +795,11 @@ inline_mysql_file_fopen( { #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { locker= PSI_server->get_thread_file_name_locker - (key, PSI_FILE_STREAM_OPEN, filename, that); + (&state, key, PSI_FILE_STREAM_OPEN, filename, that); if (likely(locker != NULL)) that->m_psi= PSI_server->start_file_open_wait(locker, src_file, src_line); @@ -820,10 +832,11 @@ inline_mysql_file_fclose( { #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; DBUG_ASSERT(file != NULL); if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_STREAM_CLOSE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -849,9 +862,10 @@ inline_mysql_file_fread( size_t result= 0; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_READ); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, count, src_file, src_line); @@ -882,9 +896,10 @@ inline_mysql_file_fwrite( size_t result= 0; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_WRITE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, count, src_file, src_line); @@ -915,9 +930,10 @@ inline_mysql_file_fseek( my_off_t result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_SEEK); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -941,9 +957,10 @@ inline_mysql_file_ftell( my_off_t result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server && file->m_psi)) { - locker= PSI_server->get_thread_file_stream_locker(file->m_psi, + locker= PSI_server->get_thread_file_stream_locker(&state, file->m_psi, PSI_FILE_TELL); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -967,9 +984,10 @@ inline_mysql_file_create( File file; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_CREATE, + locker= PSI_server->get_thread_file_name_locker(&state, key, PSI_FILE_CREATE, filename, &locker); if (likely(locker != NULL)) PSI_server->start_file_open_wait(locker, src_file, src_line); @@ -1014,9 +1032,10 @@ inline_mysql_file_open( File file; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_OPEN, + locker= PSI_server->get_thread_file_name_locker(&state, key, PSI_FILE_OPEN, filename, &locker); if (likely(locker != NULL)) PSI_server->start_file_open_wait(locker, src_file, src_line); @@ -1040,9 +1059,10 @@ inline_mysql_file_close( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(file, + locker= PSI_server->get_thread_file_descriptor_locker(&state, file, PSI_FILE_CLOSE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -1066,9 +1086,10 @@ inline_mysql_file_read( size_t result= 0; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(file, + locker= PSI_server->get_thread_file_descriptor_locker(&state, file, PSI_FILE_READ); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, count, src_file, src_line); @@ -1099,9 +1120,10 @@ inline_mysql_file_write( size_t result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(file, + locker= PSI_server->get_thread_file_descriptor_locker(&state, file, PSI_FILE_WRITE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, count, src_file, src_line); @@ -1132,9 +1154,10 @@ inline_mysql_file_pread( size_t result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(file, PSI_FILE_READ); + locker= PSI_server->get_thread_file_descriptor_locker(&state, file, PSI_FILE_READ); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, count, src_file, src_line); } @@ -1164,9 +1187,10 @@ inline_mysql_file_pwrite( size_t result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(file, + locker= PSI_server->get_thread_file_descriptor_locker(&state, file, PSI_FILE_WRITE); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, count, src_file, src_line); @@ -1197,9 +1221,10 @@ inline_mysql_file_seek( my_off_t result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(file, PSI_FILE_SEEK); + locker= PSI_server->get_thread_file_descriptor_locker(&state, file, PSI_FILE_SEEK); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); } @@ -1222,9 +1247,10 @@ inline_mysql_file_tell( my_off_t result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(file, PSI_FILE_TELL); + locker= PSI_server->get_thread_file_descriptor_locker(&state, file, PSI_FILE_TELL); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); } @@ -1247,9 +1273,10 @@ inline_mysql_file_delete( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_DELETE, + locker= PSI_server->get_thread_file_name_locker(&state, key, PSI_FILE_DELETE, name, &locker); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -1273,9 +1300,10 @@ inline_mysql_file_rename( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_RENAME, + locker= PSI_server->get_thread_file_name_locker(&state, key, PSI_FILE_RENAME, to, &locker); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -1300,9 +1328,10 @@ inline_mysql_file_create_with_symlink( File file; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_CREATE, + locker= PSI_server->get_thread_file_name_locker(&state, key, PSI_FILE_CREATE, filename, &locker); if (likely(locker != NULL)) PSI_server->start_file_open_wait(locker, src_file, src_line); @@ -1327,9 +1356,10 @@ inline_mysql_file_delete_with_symlink( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_DELETE, + locker= PSI_server->get_thread_file_name_locker(&state, key, PSI_FILE_DELETE, name, &locker); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -1353,9 +1383,10 @@ inline_mysql_file_rename_with_symlink( int result; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_RENAME, + locker= PSI_server->get_thread_file_name_locker(&state, key, PSI_FILE_RENAME, to, &locker); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); @@ -1379,9 +1410,10 @@ inline_mysql_file_sync( int result= 0; #ifdef HAVE_PSI_INTERFACE struct PSI_file_locker *locker= NULL; + PSI_file_locker_state state; if (likely(PSI_server != NULL)) { - locker= PSI_server->get_thread_file_descriptor_locker(fd, PSI_FILE_SYNC); + locker= PSI_server->get_thread_file_descriptor_locker(&state, fd, PSI_FILE_SYNC); if (likely(locker != NULL)) PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line); } === modified file 'include/mysql/psi/mysql_thread.h' --- a/include/mysql/psi/mysql_thread.h 2010-07-08 17:04:07 +0000 +++ b/include/mysql/psi/mysql_thread.h 2010-07-09 23:00:24 +0000 @@ -625,9 +625,10 @@ static inline int inline_mysql_mutex_loc int result; #ifdef HAVE_PSI_INTERFACE struct PSI_mutex_locker *locker= NULL; + PSI_mutex_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_mutex_locker(that->m_psi, PSI_MUTEX_LOCK); + locker= PSI_server->get_thread_mutex_locker(&state, that->m_psi, PSI_MUTEX_LOCK); if (likely(locker != NULL)) PSI_server->start_mutex_wait(locker, src_file, src_line); } @@ -654,9 +655,10 @@ static inline int inline_mysql_mutex_try int result; #ifdef HAVE_PSI_INTERFACE struct PSI_mutex_locker *locker= NULL; + PSI_mutex_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_mutex_locker(that->m_psi, PSI_MUTEX_TRYLOCK); + locker= PSI_server->get_thread_mutex_locker(&state, that->m_psi, PSI_MUTEX_TRYLOCK); if (likely(locker != NULL)) PSI_server->start_mutex_wait(locker, src_file, src_line); } @@ -682,13 +684,8 @@ static inline int inline_mysql_mutex_unl { int result; #ifdef HAVE_PSI_INTERFACE - struct PSI_thread *thread; if (likely(PSI_server && that->m_psi)) - { - thread= PSI_server->get_thread(); - if (likely(thread != NULL)) - PSI_server->unlock_mutex(thread, that->m_psi); - } + PSI_server->unlock_mutex(that->m_psi); #endif #ifdef SAFE_MUTEX result= safe_mutex_unlock(&that->m_mutex, src_file, src_line); @@ -771,9 +768,10 @@ static inline int inline_mysql_rwlock_rd int result; #ifdef HAVE_PSI_INTERFACE struct PSI_rwlock_locker *locker= NULL; + PSI_rwlock_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_rwlock_locker(that->m_psi, + locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi, PSI_RWLOCK_READLOCK); if (likely(locker != NULL)) PSI_server->start_rwlock_rdwait(locker, src_file, src_line); @@ -798,9 +796,10 @@ static inline int inline_mysql_prlock_rd int result; #ifdef HAVE_PSI_INTERFACE struct PSI_rwlock_locker *locker= NULL; + PSI_rwlock_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_rwlock_locker(that->m_psi, + locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi, PSI_RWLOCK_READLOCK); if (likely(locker != NULL)) PSI_server->start_rwlock_rdwait(locker, src_file, src_line); @@ -825,9 +824,10 @@ static inline int inline_mysql_rwlock_wr int result; #ifdef HAVE_PSI_INTERFACE struct PSI_rwlock_locker *locker= NULL; + PSI_rwlock_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_rwlock_locker(that->m_psi, + locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi, PSI_RWLOCK_WRITELOCK); if (likely(locker != NULL)) PSI_server->start_rwlock_wrwait(locker, src_file, src_line); @@ -852,9 +852,10 @@ static inline int inline_mysql_prlock_wr int result; #ifdef HAVE_PSI_INTERFACE struct PSI_rwlock_locker *locker= NULL; + PSI_rwlock_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_rwlock_locker(that->m_psi, + locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi, PSI_RWLOCK_WRITELOCK); if (likely(locker != NULL)) PSI_server->start_rwlock_wrwait(locker, src_file, src_line); @@ -879,9 +880,10 @@ static inline int inline_mysql_rwlock_tr int result; #ifdef HAVE_PSI_INTERFACE struct PSI_rwlock_locker *locker= NULL; + PSI_rwlock_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_rwlock_locker(that->m_psi, + locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi, PSI_RWLOCK_TRYREADLOCK); if (likely(locker != NULL)) PSI_server->start_rwlock_rdwait(locker, src_file, src_line); @@ -906,9 +908,10 @@ static inline int inline_mysql_prlock_tr int result; #ifdef HAVE_PSI_INTERFACE struct PSI_rwlock_locker *locker= NULL; + PSI_rwlock_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_rwlock_locker(that->m_psi, + locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi, PSI_RWLOCK_TRYREADLOCK); if (likely(locker != NULL)) PSI_server->start_rwlock_rdwait(locker, src_file, src_line); @@ -933,9 +936,10 @@ static inline int inline_mysql_rwlock_tr int result; #ifdef HAVE_PSI_INTERFACE struct PSI_rwlock_locker *locker= NULL; + PSI_rwlock_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_rwlock_locker(that->m_psi, + locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi, PSI_RWLOCK_TRYWRITELOCK); if (likely(locker != NULL)) PSI_server->start_rwlock_wrwait(locker, src_file, src_line); @@ -960,9 +964,10 @@ static inline int inline_mysql_prlock_tr int result; #ifdef HAVE_PSI_INTERFACE struct PSI_rwlock_locker *locker= NULL; + PSI_rwlock_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_rwlock_locker(that->m_psi, + locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi, PSI_RWLOCK_TRYWRITELOCK); if (likely(locker != NULL)) PSI_server->start_rwlock_wrwait(locker, src_file, src_line); @@ -982,13 +987,8 @@ static inline int inline_mysql_rwlock_un { int result; #ifdef HAVE_PSI_INTERFACE - struct PSI_thread *thread; if (likely(PSI_server && that->m_psi)) - { - thread= PSI_server->get_thread(); - if (likely(thread != NULL)) - PSI_server->unlock_rwlock(thread, that->m_psi); - } + PSI_server->unlock_rwlock(that->m_psi); #endif result= rw_unlock(&that->m_rwlock); return result; @@ -1000,13 +1000,8 @@ static inline int inline_mysql_prlock_un { int result; #ifdef HAVE_PSI_INTERFACE - struct PSI_thread *thread; if (likely(PSI_server && that->m_psi)) - { - thread= PSI_server->get_thread(); - if (likely(thread != NULL)) - PSI_server->unlock_rwlock(thread, that->m_psi); - } + PSI_server->unlock_rwlock(that->m_psi); #endif result= rw_pr_unlock(&that->m_prlock); return result; @@ -1053,9 +1048,10 @@ static inline int inline_mysql_cond_wait int result; #ifdef HAVE_PSI_INTERFACE struct PSI_cond_locker *locker= NULL; + PSI_cond_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_cond_locker(that->m_psi, mutex->m_psi, + locker= PSI_server->get_thread_cond_locker(&state, that->m_psi, mutex->m_psi, PSI_COND_WAIT); if (likely(locker != NULL)) PSI_server->start_cond_wait(locker, src_file, src_line); @@ -1081,9 +1077,10 @@ static inline int inline_mysql_cond_time int result; #ifdef HAVE_PSI_INTERFACE struct PSI_cond_locker *locker= NULL; + PSI_cond_locker_state state; if (likely(PSI_server && that->m_psi)) { - locker= PSI_server->get_thread_cond_locker(that->m_psi, mutex->m_psi, + locker= PSI_server->get_thread_cond_locker(&state, that->m_psi, mutex->m_psi, PSI_COND_TIMEDWAIT); if (likely(locker != NULL)) PSI_server->start_cond_wait(locker, src_file, src_line); @@ -1102,13 +1099,8 @@ static inline int inline_mysql_cond_sign { int result; #ifdef HAVE_PSI_INTERFACE - struct PSI_thread *thread; if (likely(PSI_server && that->m_psi)) - { - thread= PSI_server->get_thread(); - if (likely(thread != NULL)) - PSI_server->signal_cond(thread, that->m_psi); - } + PSI_server->signal_cond(that->m_psi); #endif result= pthread_cond_signal(&that->m_cond); return result; @@ -1119,13 +1111,8 @@ static inline int inline_mysql_cond_broa { int result; #ifdef HAVE_PSI_INTERFACE - struct PSI_thread *thread; if (likely(PSI_server && that->m_psi)) - { - thread= PSI_server->get_thread(); - if (likely(thread != NULL)) - PSI_server->broadcast_cond(thread, that->m_psi); - } + PSI_server->broadcast_cond(that->m_psi); #endif result= pthread_cond_broadcast(&that->m_cond); return result; === modified file 'include/mysql/psi/psi.h' --- a/include/mysql/psi/psi.h 2010-07-08 17:04:07 +0000 +++ b/include/mysql/psi/psi.h 2010-07-09 23:00:24 +0000 @@ -422,6 +422,175 @@ struct PSI_file_info_v1 int m_flags; }; +/** + State data storage for @c get_thread_mutex_locker_v1_t. + This structure provide temporary storage to a mutex locker. + The content of this structure is considered opaque, + the fields are only hints of what an implementation + of the psi interface can use. + This memory is provided by the instrumented code for performance reasons. + @sa get_thread_mutex_locker_v1_t +*/ +struct PSI_mutex_locker_state_v1 +{ + /** Internal state. */ + uint m_flags; + /** Current mutex. */ + struct PSI_mutex *m_mutex; + /** Current thread. */ + struct PSI_thread *m_thread; + /** Timer start. */ + ulonglong m_timer_start; + /** Timer function. */ + ulonglong (*m_timer)(void); + /** Current operation. */ + enum PSI_mutex_operation m_operation; + /** Source file. */ + const char* m_src_file; + /** Source line number. */ + int m_src_line; + /** Internal data. */ + void *m_wait; +}; + +/** + State data storage for @c get_thread_rwlock_locker_v1_t. + This structure provide temporary storage to a rwlock locker. + The content of this structure is considered opaque, + the fields are only hints of what an implementation + of the psi interface can use. + This memory is provided by the instrumented code for performance reasons. + @sa get_thread_rwlock_locker_v1_t +*/ +struct PSI_rwlock_locker_state_v1 +{ + /** Internal state. */ + uint m_flags; + /** Current rwlock. */ + struct PSI_rwlock *m_rwlock; + /** Current thread. */ + struct PSI_thread *m_thread; + /** Timer start. */ + ulonglong m_timer_start; + /** Timer function. */ + ulonglong (*m_timer)(void); + /** Current operation. */ + enum PSI_rwlock_operation m_operation; + /** Source file. */ + const char* m_src_file; + /** Source line number. */ + int m_src_line; + /** Internal data. */ + void *m_wait; +}; + +/** + State data storage for @c get_thread_cond_locker_v1_t. + This structure provide temporary storage to a condition locker. + The content of this structure is considered opaque, + the fields are only hints of what an implementation + of the psi interface can use. + This memory is provided by the instrumented code for performance reasons. + @sa get_thread_cond_locker_v1_t +*/ +struct PSI_cond_locker_state_v1 +{ + /** Internal state. */ + uint m_flags; + /** Current condition. */ + struct PSI_cond *m_cond; + /** Current mutex. */ + struct PSI_mutex *m_mutex; + /** Current thread. */ + struct PSI_thread *m_thread; + /** Timer start. */ + ulonglong m_timer_start; + /** Timer function. */ + ulonglong (*m_timer)(void); + /** Current operation. */ + enum PSI_cond_operation m_operation; + /** Source file. */ + const char* m_src_file; + /** Source line number. */ + int m_src_line; + /** Internal data. */ + void *m_wait; +}; + +/** + State data storage for @c get_thread_file_name_locker_v1_t. + This structure provide temporary storage to a file locker. + The content of this structure is considered opaque, + the fields are only hints of what an implementation + of the psi interface can use. + This memory is provided by the instrumented code for performance reasons. + @sa get_thread_file_name_locker_v1_t + @sa get_thread_file_stream_locker_v1_t + @sa get_thread_file_descriptor_locker_v1_t +*/ +struct PSI_file_locker_state_v1 +{ + /** Internal state. */ + uint m_flags; + /** Current file. */ + struct PSI_file *m_file; + /** Current thread. */ + struct PSI_thread *m_thread; + /** Operation number of bytes. */ + size_t m_number_of_bytes; + /** Timer start. */ + ulonglong m_timer_start; + /** Timer function. */ + ulonglong (*m_timer)(void); + /** Current operation. */ + enum PSI_file_operation m_operation; + /** Source file. */ + const char* m_src_file; + /** Source line number. */ + int m_src_line; + /** Internal data. */ + void *m_wait; +}; + +/** + State data storage for @c get_thread_table_locker_v1_t. + This structure provide temporary storage to a table locker. + The content of this structure is considered opaque, + the fields are only hints of what an implementation + of the psi interface can use. + This memory is provided by the instrumented code for performance reasons. + @sa get_thread_table_locker_v1_t +*/ +struct PSI_table_locker_state_v1 +{ + /** Internal state. */ + uint m_flags; + /** Current table handle. */ + struct PSI_table *m_table; + /** Current table share. */ + struct PSI_table_share *m_table_share; + /** Instrumentation class. */ + void *m_class; + /** Current thread. */ + struct PSI_thread *m_thread; + /** Timer start. */ + ulonglong m_timer_start; + /** Timer function. */ + ulonglong (*m_timer)(void); + /* Current operation (waiting for WL#4895). */ + /* enum PSI_table_operation m_operation; */ + /** Current table io index. */ + uint m_index; + /** Current table lock index. */ + uint m_lock_index; + /** Source file. */ + const char* m_src_file; + /** Source line number. */ + int m_src_line; + /** Internal data. */ + void *m_wait; +}; + /* Using typedef to make reuse between PSI_v1 and PSI_v2 easier later. */ /** @@ -619,40 +788,51 @@ typedef void (*delete_thread_v1_t)(struc /** Get a mutex instrumentation locker. + @param state data storage for the locker @param mutex the instrumented mutex to lock @return a mutex locker, or NULL */ typedef struct PSI_mutex_locker* (*get_thread_mutex_locker_v1_t) - (struct PSI_mutex *mutex, enum PSI_mutex_operation op); + (struct PSI_mutex_locker_state_v1 *state, + struct PSI_mutex *mutex, + enum PSI_mutex_operation op); /** Get a rwlock instrumentation locker. + @param state data storage for the locker @param rwlock the instrumented rwlock to lock @return a rwlock locker, or NULL */ typedef struct PSI_rwlock_locker* (*get_thread_rwlock_locker_v1_t) - (struct PSI_rwlock *rwlock, enum PSI_rwlock_operation op); + (struct PSI_rwlock_locker_state_v1 *state, + struct PSI_rwlock *rwlock, + enum PSI_rwlock_operation op); /** Get a cond instrumentation locker. + @param state data storage for the locker @param cond the instrumented condition to wait on @param mutex the instrumented mutex associated with the condition @return a condition locker, or NULL */ typedef struct PSI_cond_locker* (*get_thread_cond_locker_v1_t) - (struct PSI_cond *cond, struct PSI_mutex *mutex, + (struct PSI_cond_locker_state_v1 *state, + struct PSI_cond *cond, struct PSI_mutex *mutex, enum PSI_cond_operation op); /** Get a table instrumentation locker. + @param state data storage for the locker @param table the instrumented table to lock @return a table locker, or NULL */ typedef struct PSI_table_locker* (*get_thread_table_locker_v1_t) - (struct PSI_table *table); + (struct PSI_table_locker_state_v1 *state, + struct PSI_table *table); /** Get a file instrumentation locker, for opening or creating a file. + @param state data storage for the locker @param key the file instrumentation key @param op the operation to perform @param name the file name @@ -660,58 +840,59 @@ typedef struct PSI_table_locker* (*get_t @return a file locker, or NULL */ typedef struct PSI_file_locker* (*get_thread_file_name_locker_v1_t) - (PSI_file_key key, enum PSI_file_operation op, const char *name, + (struct PSI_file_locker_state_v1 *state, + PSI_file_key key, enum PSI_file_operation op, const char *name, const void *identity); /** Get a file stream instrumentation locker. + @param state data storage for the locker @param file the file stream to access @param op the operation to perform @return a file locker, or NULL */ typedef struct PSI_file_locker* (*get_thread_file_stream_locker_v1_t) - (struct PSI_file *file, enum PSI_file_operation op); + (struct PSI_file_locker_state_v1 *state, + struct PSI_file *file, enum PSI_file_operation op); /** Get a file instrumentation locker. + @param state data storage for the locker @param file the file descriptor to access @param op the operation to perform @return a file locker, or NULL */ typedef struct PSI_file_locker* (*get_thread_file_descriptor_locker_v1_t) - (File file, enum PSI_file_operation op); + (struct PSI_file_locker_state_v1 *state, + File file, enum PSI_file_operation op); /** Record a mutex instrumentation unlock event. - @param thread the running thread instrumentation @param mutex the mutex instrumentation */ typedef void (*unlock_mutex_v1_t) - (struct PSI_thread *thread, struct PSI_mutex *mutex); + (struct PSI_mutex *mutex); /** Record a rwlock instrumentation unlock event. - @param thread the running thread instrumentation @param rwlock the rwlock instrumentation */ typedef void (*unlock_rwlock_v1_t) - (struct PSI_thread *thread, struct PSI_rwlock *rwlock); + (struct PSI_rwlock *rwlock); /** Record a condition instrumentation signal event. - @param thread the running thread instrumentation @param cond the cond instrumentation */ typedef void (*signal_cond_v1_t) - (struct PSI_thread *thread, struct PSI_cond *cond); + (struct PSI_cond *cond); /** Record a condition instrumentation broadcast event. - @param thread the running thread instrumentation @param cond the cond instrumentation */ typedef void (*broadcast_cond_v1_t) - (struct PSI_thread *thread, struct PSI_cond *cond); + (struct PSI_cond *cond); /** Record a mutex instrumentation wait start event. @@ -1013,6 +1194,36 @@ struct PSI_file_info_v2 int placeholder; }; +struct PSI_mutex_locker_state_v2 +{ + /** Placeholder */ + int placeholder; +}; + +struct PSI_rwlock_locker_state_v2 +{ + /** Placeholder */ + int placeholder; +}; + +struct PSI_cond_locker_state_v2 +{ + /** Placeholder */ + int placeholder; +}; + +struct PSI_file_locker_state_v2 +{ + /** Placeholder */ + int placeholder; +}; + +struct PSI_table_locker_state_v2 +{ + /** Placeholder */ + int placeholder; +}; + /** @} (end of group Group_PSI_v2) */ #endif /* HAVE_PSI_2 */ @@ -1056,6 +1267,11 @@ typedef struct PSI_rwlock_info_v1 PSI_rw typedef struct PSI_cond_info_v1 PSI_cond_info; typedef struct PSI_thread_info_v1 PSI_thread_info; typedef struct PSI_file_info_v1 PSI_file_info; +typedef struct PSI_mutex_locker_state_v1 PSI_mutex_locker_state; +typedef struct PSI_rwlock_locker_state_v1 PSI_rwlock_locker_state; +typedef struct PSI_cond_locker_state_v1 PSI_cond_locker_state; +typedef struct PSI_file_locker_state_v1 PSI_file_locker_state; +typedef struct PSI_table_locker_state_v1 PSI_table_locker_state; #endif #ifdef USE_PSI_2 @@ -1065,6 +1281,11 @@ typedef struct PSI_rwlock_info_v2 PSI_rw typedef struct PSI_cond_info_v2 PSI_cond_info; typedef struct PSI_thread_info_v2 PSI_thread_info; typedef struct PSI_file_info_v2 PSI_file_info; +typedef struct PSI_mutex_locker_state_v2 PSI_mutex_locker_state; +typedef struct PSI_rwlock_locker_state_v2 PSI_rwlock_locker_state; +typedef struct PSI_cond_locker_state_v2 PSI_cond_locker_state; +typedef struct PSI_file_locker_state_v2 PSI_file_locker_state; +typedef struct PSI_table_locker_state_v2 PSI_table_locker_state; #endif #else /* HAVE_PSI_INTERFACE */ === modified file 'include/mysql/psi/psi_abi_v1.h.pp' --- a/include/mysql/psi/psi_abi_v1.h.pp 2010-01-26 23:42:54 +0000 +++ b/include/mysql/psi/psi_abi_v1.h.pp 2010-07-09 23:00:24 +0000 @@ -88,6 +88,71 @@ struct PSI_file_info_v1 const char *m_name; int m_flags; }; +struct PSI_mutex_locker_state_v1 +{ + uint m_flags; + struct PSI_mutex *m_mutex; + struct PSI_thread *m_thread; + ulonglong m_timer_start; + ulonglong (*m_timer)(void); + enum PSI_mutex_operation m_operation; + const char* m_src_file; + int m_src_line; + void *m_wait; +}; +struct PSI_rwlock_locker_state_v1 +{ + uint m_flags; + struct PSI_rwlock *m_rwlock; + struct PSI_thread *m_thread; + ulonglong m_timer_start; + ulonglong (*m_timer)(void); + enum PSI_rwlock_operation m_operation; + const char* m_src_file; + int m_src_line; + void *m_wait; +}; +struct PSI_cond_locker_state_v1 +{ + uint m_flags; + struct PSI_cond *m_cond; + struct PSI_mutex *m_mutex; + struct PSI_thread *m_thread; + ulonglong m_timer_start; + ulonglong (*m_timer)(void); + enum PSI_cond_operation m_operation; + const char* m_src_file; + int m_src_line; + void *m_wait; +}; +struct PSI_file_locker_state_v1 +{ + uint m_flags; + struct PSI_file *m_file; + struct PSI_thread *m_thread; + size_t m_number_of_bytes; + ulonglong m_timer_start; + ulonglong (*m_timer)(void); + enum PSI_file_operation m_operation; + const char* m_src_file; + int m_src_line; + void *m_wait; +}; +struct PSI_table_locker_state_v1 +{ + uint m_flags; + struct PSI_table *m_table; + struct PSI_table_share *m_table_share; + void *m_class; + struct PSI_thread *m_thread; + ulonglong m_timer_start; + ulonglong (*m_timer)(void); + uint m_index; + uint m_lock_index; + const char* m_src_file; + int m_src_line; + void *m_wait; +}; typedef void (*register_mutex_v1_t) (const char *category, struct PSI_mutex_info_v1 *info, int count); typedef void (*register_rwlock_v1_t) @@ -129,29 +194,38 @@ typedef void (*set_thread_v1_t)(struct P typedef void (*delete_current_thread_v1_t)(void); typedef void (*delete_thread_v1_t)(struct PSI_thread *thread); typedef struct PSI_mutex_locker* (*get_thread_mutex_locker_v1_t) - (struct PSI_mutex *mutex, enum PSI_mutex_operation op); + (struct PSI_mutex_locker_state_v1 *state, + struct PSI_mutex *mutex, + enum PSI_mutex_operation op); typedef struct PSI_rwlock_locker* (*get_thread_rwlock_locker_v1_t) - (struct PSI_rwlock *rwlock, enum PSI_rwlock_operation op); + (struct PSI_rwlock_locker_state_v1 *state, + struct PSI_rwlock *rwlock, + enum PSI_rwlock_operation op); typedef struct PSI_cond_locker* (*get_thread_cond_locker_v1_t) - (struct PSI_cond *cond, struct PSI_mutex *mutex, + (struct PSI_cond_locker_state_v1 *state, + struct PSI_cond *cond, struct PSI_mutex *mutex, enum PSI_cond_operation op); typedef struct PSI_table_locker* (*get_thread_table_locker_v1_t) - (struct PSI_table *table); + (struct PSI_table_locker_state_v1 *state, + struct PSI_table *table); typedef struct PSI_file_locker* (*get_thread_file_name_locker_v1_t) - (PSI_file_key key, enum PSI_file_operation op, const char *name, + (struct PSI_file_locker_state_v1 *state, + PSI_file_key key, enum PSI_file_operation op, const char *name, const void *identity); typedef struct PSI_file_locker* (*get_thread_file_stream_locker_v1_t) - (struct PSI_file *file, enum PSI_file_operation op); + (struct PSI_file_locker_state_v1 *state, + struct PSI_file *file, enum PSI_file_operation op); typedef struct PSI_file_locker* (*get_thread_file_descriptor_locker_v1_t) - (File file, enum PSI_file_operation op); + (struct PSI_file_locker_state_v1 *state, + File file, enum PSI_file_operation op); typedef void (*unlock_mutex_v1_t) - (struct PSI_thread *thread, struct PSI_mutex *mutex); + (struct PSI_mutex *mutex); typedef void (*unlock_rwlock_v1_t) - (struct PSI_thread *thread, struct PSI_rwlock *rwlock); + (struct PSI_rwlock *rwlock); typedef void (*signal_cond_v1_t) - (struct PSI_thread *thread, struct PSI_cond *cond); + (struct PSI_cond *cond); typedef void (*broadcast_cond_v1_t) - (struct PSI_thread *thread, struct PSI_cond *cond); + (struct PSI_cond *cond); typedef void (*start_mutex_wait_v1_t) (struct PSI_mutex_locker *locker, const char *src_file, uint src_line); typedef void (*end_mutex_wait_v1_t) @@ -240,5 +314,10 @@ typedef struct PSI_rwlock_info_v1 PSI_rw typedef struct PSI_cond_info_v1 PSI_cond_info; typedef struct PSI_thread_info_v1 PSI_thread_info; typedef struct PSI_file_info_v1 PSI_file_info; +typedef struct PSI_mutex_locker_state_v1 PSI_mutex_locker_state; +typedef struct PSI_rwlock_locker_state_v1 PSI_rwlock_locker_state; +typedef struct PSI_cond_locker_state_v1 PSI_cond_locker_state; +typedef struct PSI_file_locker_state_v1 PSI_file_locker_state; +typedef struct PSI_table_locker_state_v1 PSI_table_locker_state; extern MYSQL_PLUGIN_IMPORT PSI *PSI_server; C_MODE_END === modified file 'include/mysql/psi/psi_abi_v2.h.pp' --- a/include/mysql/psi/psi_abi_v2.h.pp 2009-12-01 00:49:15 +0000 +++ b/include/mysql/psi/psi_abi_v2.h.pp 2010-07-09 23:00:24 +0000 @@ -82,11 +82,36 @@ struct PSI_file_info_v2 { int placeholder; }; +struct PSI_mutex_locker_state_v2 +{ + int placeholder; +}; +struct PSI_rwlock_locker_state_v2 +{ + int placeholder; +}; +struct PSI_cond_locker_state_v2 +{ + int placeholder; +}; +struct PSI_file_locker_state_v2 +{ + int placeholder; +}; +struct PSI_table_locker_state_v2 +{ + int placeholder; +}; typedef struct PSI_v2 PSI; typedef struct PSI_mutex_info_v2 PSI_mutex_info; typedef struct PSI_rwlock_info_v2 PSI_rwlock_info; typedef struct PSI_cond_info_v2 PSI_cond_info; typedef struct PSI_thread_info_v2 PSI_thread_info; typedef struct PSI_file_info_v2 PSI_file_info; +typedef struct PSI_mutex_locker_state_v2 PSI_mutex_locker_state; +typedef struct PSI_rwlock_locker_state_v2 PSI_rwlock_locker_state; +typedef struct PSI_cond_locker_state_v2 PSI_cond_locker_state; +typedef struct PSI_file_locker_state_v2 PSI_file_locker_state; +typedef struct PSI_table_locker_state_v2 PSI_table_locker_state; extern MYSQL_PLUGIN_IMPORT PSI *PSI_server; C_MODE_END === modified file 'storage/innobase/include/os0file.h' --- a/storage/innobase/include/os0file.h 2010-06-17 11:11:34 +0000 +++ b/storage/innobase/include/os0file.h 2010-07-09 23:00:24 +0000 @@ -194,12 +194,12 @@ various file I/O operations with perform used to register file creation, opening, closing and renaming. 2) register_pfs_file_io_begin() and register_pfs_file_io_end() are used to register actual file read, write and flush */ -# define register_pfs_file_open_begin(locker, key, op, name, \ +# define register_pfs_file_open_begin(state, locker, key, op, name, \ src_file, src_line) \ do { \ if (PSI_server) { \ locker = PSI_server->get_thread_file_name_locker( \ - key, op, name, &locker); \ + state, key, op, name, &locker); \ if (locker) { \ PSI_server->start_file_open_wait( \ locker, src_file, src_line); \ @@ -215,12 +215,12 @@ do { \ } \ } while (0) -# define register_pfs_file_io_begin(locker, file, count, op, \ +# define register_pfs_file_io_begin(state, locker, file, count, op, \ src_file, src_line) \ do { \ if (PSI_server) { \ locker = PSI_server->get_thread_file_descriptor_locker( \ - file, op); \ + state, file, op); \ if (locker) { \ PSI_server->start_file_wait( \ locker, count, src_file, src_line); \ === modified file 'storage/innobase/include/os0file.ic' --- a/storage/innobase/include/os0file.ic 2010-03-29 07:34:42 +0000 +++ b/storage/innobase/include/os0file.ic 2010-07-14 16:23:21 +0000 @@ -55,9 +55,10 @@ pfs_os_file_create_simple_func( { os_file_t file; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; /* register a file open or creation depending on "create_mode" */ - register_pfs_file_open_begin(locker, key, + register_pfs_file_open_begin(&state, locker, key, ((create_mode == OS_FILE_CREATE) ? PSI_FILE_CREATE : PSI_FILE_OPEN), @@ -101,9 +102,10 @@ pfs_os_file_create_simple_no_error_handl { os_file_t file; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; /* register a file open or creation depending on "create_mode" */ - register_pfs_file_open_begin(locker, key, + register_pfs_file_open_begin(&state, locker, key, ((create_mode == OS_FILE_CREATE) ? PSI_FILE_CREATE : PSI_FILE_OPEN), @@ -153,9 +155,10 @@ pfs_os_file_create_func( { os_file_t file; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; /* register a file open or creation depending on "create_mode" */ - register_pfs_file_open_begin(locker, key, + register_pfs_file_open_begin(&state, locker, key, ((create_mode == OS_FILE_CREATE) ? PSI_FILE_CREATE : PSI_FILE_OPEN), @@ -183,9 +186,10 @@ pfs_os_file_close_func( { ibool result; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; /* register the file close */ - register_pfs_file_io_begin(locker, file, 0, PSI_FILE_CLOSE, + register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_CLOSE, src_file, src_line); result = os_file_close_func(file); @@ -230,9 +234,10 @@ pfs_os_aio_func( { ibool result; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; /* Register the read or write I/O depending on "type" */ - register_pfs_file_io_begin(locker, file, n, + register_pfs_file_io_begin(&state, locker, file, n, (type == OS_FILE_WRITE) ? PSI_FILE_WRITE : PSI_FILE_READ, @@ -268,8 +273,9 @@ pfs_os_file_read_func( { ibool result; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; - register_pfs_file_io_begin(locker, file, n, PSI_FILE_READ, + register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_READ, src_file, src_line); result = os_file_read_func(file, buf, offset, offset_high, n); @@ -303,8 +309,9 @@ pfs_os_file_read_no_error_handling_func( { ibool result; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; - register_pfs_file_io_begin(locker, file, n, PSI_FILE_READ, + register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_READ, src_file, src_line); result = os_file_read_no_error_handling_func(file, buf, offset, @@ -339,8 +346,9 @@ pfs_os_file_write_func( { ibool result; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; - register_pfs_file_io_begin(locker, file, n, PSI_FILE_WRITE, + register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_WRITE, src_file, src_line); result = os_file_write_func(name, file, buf, offset, offset_high, n); @@ -366,8 +374,9 @@ pfs_os_file_flush_func( { ibool result; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; - register_pfs_file_io_begin(locker, file, 0, PSI_FILE_SYNC, + register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_SYNC, src_file, src_line); result = os_file_flush_func(file); @@ -395,8 +404,9 @@ pfs_os_file_rename_func( { ibool result; struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; - register_pfs_file_open_begin(locker, key, PSI_FILE_RENAME, newpath, + register_pfs_file_open_begin(&state, locker, key, PSI_FILE_RENAME, newpath, src_file, src_line); result = os_file_rename_func(oldpath, newpath); === modified file 'storage/innobase/include/sync0rw.ic' --- a/storage/innobase/include/sync0rw.ic 2010-06-17 11:11:34 +0000 +++ b/storage/innobase/include/sync0rw.ic 2010-07-14 16:23:21 +0000 @@ -675,12 +675,13 @@ pfs_rw_lock_x_lock_func( const char* file_name,/*!< in: file name where lock requested */ ulint line) /*!< in: line where requested */ { - struct PSI_rwlock_locker* locker = NULL; + struct PSI_rwlock_locker* locker = NULL; + PSI_rwlock_locker_state state; /* Record the entry of rw x lock request in performance schema */ if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) { locker = PSI_server->get_thread_rwlock_locker( - lock->pfs_psi, PSI_RWLOCK_WRITELOCK); + &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK); if (locker) { PSI_server->start_rwlock_wrwait(locker, @@ -709,13 +710,14 @@ pfs_rw_lock_x_lock_func_nowait( requested */ ulint line) /*!< in: line where requested */ { - struct PSI_rwlock_locker* locker = NULL; + struct PSI_rwlock_locker* locker = NULL; + PSI_rwlock_locker_state state; ibool ret; /* Record the entry of rw x lock request in performance schema */ if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) { locker = PSI_server->get_thread_rwlock_locker( - lock->pfs_psi, PSI_RWLOCK_WRITELOCK); + &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK); if (locker) { PSI_server->start_rwlock_wrwait(locker, @@ -764,12 +766,13 @@ pfs_rw_lock_s_lock_func( requested */ ulint line) /*!< in: line where requested */ { - struct PSI_rwlock_locker* locker = NULL; + struct PSI_rwlock_locker* locker = NULL; + PSI_rwlock_locker_state state; /* Instrumented to inform we are aquiring a shared rwlock */ if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) { locker = PSI_server->get_thread_rwlock_locker( - lock->pfs_psi, PSI_RWLOCK_READLOCK); + &state, lock->pfs_psi, PSI_RWLOCK_READLOCK); if (locker) { PSI_server->start_rwlock_rdwait(locker, file_name, line); @@ -798,14 +801,14 @@ pfs_rw_lock_s_lock_low( const char* file_name, /*!< in: file name where lock requested */ ulint line) /*!< in: line where requested */ { - - struct PSI_rwlock_locker* locker = NULL; + struct PSI_rwlock_locker* locker = NULL; + PSI_rwlock_locker_state state; ibool ret; /* Instrumented to inform we are aquiring a shared rwlock */ if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) { locker = PSI_server->get_thread_rwlock_locker( - lock->pfs_psi, PSI_RWLOCK_READLOCK); + &state, lock->pfs_psi, PSI_RWLOCK_READLOCK); if (locker) { PSI_server->start_rwlock_rdwait(locker, file_name, line); @@ -838,11 +841,7 @@ pfs_rw_lock_x_unlock_func( { /* Inform performance schema we are unlocking the lock */ if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) { - struct PSI_thread* thread; - thread = PSI_server->get_thread(); - if (thread) { - PSI_server->unlock_rwlock(thread, lock->pfs_psi); - } + PSI_server->unlock_rwlock(lock->pfs_psi); } rw_lock_x_unlock_func( @@ -869,11 +868,7 @@ pfs_rw_lock_s_unlock_func( { /* Inform performance schema we are unlocking the lock */ if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) { - struct PSI_thread* thread; - thread = PSI_server->get_thread(); - if (thread) { - PSI_server->unlock_rwlock(thread, lock->pfs_psi); - } + PSI_server->unlock_rwlock(lock->pfs_psi); } rw_lock_s_unlock_func( === modified file 'storage/innobase/include/sync0sync.ic' --- a/storage/innobase/include/sync0sync.ic 2010-06-17 11:11:34 +0000 +++ b/storage/innobase/include/sync0sync.ic 2010-07-09 23:00:24 +0000 @@ -237,11 +237,12 @@ pfs_mutex_enter_func( ulint line) /*!< in: line where locked */ { struct PSI_mutex_locker* locker = NULL; + PSI_mutex_locker_state state; int result = 0; if (UNIV_LIKELY(PSI_server && mutex->pfs_psi)) { locker = PSI_server->get_thread_mutex_locker( - mutex->pfs_psi, PSI_MUTEX_LOCK); + &state, mutex->pfs_psi, PSI_MUTEX_LOCK); if (locker) { PSI_server->start_mutex_wait(locker, file_name, line); } @@ -270,11 +271,12 @@ pfs_mutex_enter_nowait_func( { ulint ret; struct PSI_mutex_locker* locker = NULL; + PSI_mutex_locker_state state; int result = 0; if (UNIV_LIKELY(PSI_server && mutex->pfs_psi)) { locker = PSI_server->get_thread_mutex_locker( - mutex->pfs_psi, PSI_MUTEX_LOCK); + &state, mutex->pfs_psi, PSI_MUTEX_LOCK); if (locker) { PSI_server->start_mutex_wait(locker, file_name, line); } @@ -300,12 +302,7 @@ pfs_mutex_exit_func( mutex_t* mutex) /*!< in: pointer to mutex */ { if (UNIV_LIKELY(PSI_server && mutex->pfs_psi)) { - struct PSI_thread* thread; - thread = PSI_server->get_thread(); - - if (thread) { - PSI_server->unlock_mutex(thread, mutex->pfs_psi); - } + PSI_server->unlock_mutex(mutex->pfs_psi); } mutex_exit_func(mutex); === modified file 'storage/innobase/row/row0merge.c' --- a/storage/innobase/row/row0merge.c 2010-06-17 11:11:34 +0000 +++ b/storage/innobase/row/row0merge.c 2010-07-14 16:23:21 +0000 @@ -2164,8 +2164,9 @@ row_merge_file_create( /* This temp file open does not go through normal file APIs, add instrumentation to register with performance schema */ - struct PSI_file_locker* locker = NULL; - register_pfs_file_open_begin(locker, innodb_file_temp_key, + struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; + register_pfs_file_open_begin(&state, locker, innodb_file_temp_key, PSI_FILE_OPEN, "Innodb Merge Temp File", __FILE__, __LINE__); @@ -2187,8 +2188,9 @@ row_merge_file_destroy( merge_file_t* merge_file) /*!< out: merge file structure */ { #ifdef UNIV_PFS_IO - struct PSI_file_locker* locker = NULL; - register_pfs_file_io_begin(locker, merge_file->fd, 0, PSI_FILE_CLOSE, + struct PSI_file_locker* locker = NULL; + PSI_file_locker_state state; + register_pfs_file_io_begin(&state, locker, merge_file->fd, 0, PSI_FILE_CLOSE, __FILE__, __LINE__); #endif if (merge_file->fd != -1) { === modified file 'storage/perfschema/pfs.cc' --- a/storage/perfschema/pfs.cc 2010-07-08 21:20:08 +0000 +++ b/storage/perfschema/pfs.cc 2010-07-09 23:00:24 +0000 @@ -1093,7 +1093,8 @@ static void delete_thread_v1(PSI_thread } static PSI_mutex_locker* -get_thread_mutex_locker_v1(PSI_mutex *mutex, PSI_mutex_operation op) +get_thread_mutex_locker_v1(PSI_mutex_locker_state *state, + PSI_mutex *mutex, PSI_mutex_operation op) { PFS_mutex *pfs_mutex= reinterpret_cast (mutex); DBUG_ASSERT((int) op >= 0); @@ -1138,7 +1139,8 @@ get_thread_mutex_locker_v1(PSI_mutex *mu } static PSI_rwlock_locker* -get_thread_rwlock_locker_v1(PSI_rwlock *rwlock, PSI_rwlock_operation op) +get_thread_rwlock_locker_v1(PSI_rwlock_locker_state *state, + PSI_rwlock *rwlock, PSI_rwlock_operation op) { PFS_rwlock *pfs_rwlock= reinterpret_cast (rwlock); DBUG_ASSERT(static_cast (op) >= 0); @@ -1184,7 +1186,8 @@ get_thread_rwlock_locker_v1(PSI_rwlock * } static PSI_cond_locker* -get_thread_cond_locker_v1(PSI_cond *cond, PSI_mutex * /* unused: mutex */, +get_thread_cond_locker_v1(PSI_cond_locker_state *state, + PSI_cond *cond, PSI_mutex * /* unused: mutex */, PSI_cond_operation op) { /* @@ -1242,7 +1245,8 @@ get_thread_cond_locker_v1(PSI_cond *cond } static PSI_table_locker* -get_thread_table_locker_v1(PSI_table *table) +get_thread_table_locker_v1(PSI_table_locker_state *state, + PSI_table *table) { PFS_table *pfs_table= reinterpret_cast (table); DBUG_ASSERT(pfs_table != NULL); @@ -1284,7 +1288,8 @@ get_thread_table_locker_v1(PSI_table *ta } static PSI_file_locker* -get_thread_file_name_locker_v1(PSI_file_key key, +get_thread_file_name_locker_v1(PSI_file_locker_state *state, + PSI_file_key key, PSI_file_operation op, const char *name, const void *identity) { @@ -1341,7 +1346,8 @@ get_thread_file_name_locker_v1(PSI_file_ } static PSI_file_locker* -get_thread_file_stream_locker_v1(PSI_file *file, PSI_file_operation op) +get_thread_file_stream_locker_v1(PSI_file_locker_state *state, + PSI_file *file, PSI_file_operation op) { PFS_file *pfs_file= reinterpret_cast (file); @@ -1392,7 +1398,8 @@ get_thread_file_stream_locker_v1(PSI_fil } static PSI_file_locker* -get_thread_file_descriptor_locker_v1(File file, PSI_file_operation op) +get_thread_file_descriptor_locker_v1(PSI_file_locker_state *state, + File file, PSI_file_operation op) { int index= static_cast (file); @@ -1462,7 +1469,7 @@ get_thread_file_descriptor_locker_v1(Fil return NULL; } -static void unlock_mutex_v1(PSI_thread * thread, PSI_mutex *mutex) +static void unlock_mutex_v1(PSI_mutex *mutex) { PFS_mutex *pfs_mutex= reinterpret_cast (mutex); DBUG_ASSERT(pfs_mutex != NULL); @@ -1501,7 +1508,7 @@ static void unlock_mutex_v1(PSI_thread * #endif } -static void unlock_rwlock_v1(PSI_thread *thread, PSI_rwlock *rwlock) +static void unlock_rwlock_v1(PSI_rwlock *rwlock) { PFS_rwlock *pfs_rwlock= reinterpret_cast (rwlock); DBUG_ASSERT(pfs_rwlock != NULL); @@ -1577,7 +1584,7 @@ static void unlock_rwlock_v1(PSI_thread #endif } -static void signal_cond_v1(PSI_thread *thread, PSI_cond* cond) +static void signal_cond_v1(PSI_cond* cond) { PFS_cond *pfs_cond= reinterpret_cast (cond); DBUG_ASSERT(pfs_cond != NULL); @@ -1585,7 +1592,7 @@ static void signal_cond_v1(PSI_thread *t pfs_cond->m_cond_stat.m_signal_count++; } -static void broadcast_cond_v1(PSI_thread *thread, PSI_cond* cond) +static void broadcast_cond_v1(PSI_cond* cond) { PFS_cond *pfs_cond= reinterpret_cast (cond); DBUG_ASSERT(pfs_cond != NULL); === modified file 'storage/perfschema/unittest/pfs-t.cc' --- a/storage/perfschema/unittest/pfs-t.cc 2010-04-13 11:48:46 +0000 +++ b/storage/perfschema/unittest/pfs-t.cc 2010-07-09 23:00:24 +0000 @@ -941,9 +941,13 @@ void test_locker_disabled() ok(file_A1 != NULL, "instrumented"); PSI_mutex_locker *mutex_locker; + PSI_mutex_locker_state mutex_state; PSI_rwlock_locker *rwlock_locker; + PSI_rwlock_locker_state rwlock_state; PSI_cond_locker *cond_locker; + PSI_cond_locker_state cond_state; PSI_file_locker *file_locker; + PSI_file_locker_state file_state; /* Pretend thread T-1 is disabled */ /* ------------------------------ */ @@ -955,17 +959,17 @@ void test_locker_disabled() cond_class_A->m_enabled= true; file_class_A->m_enabled= true; - mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK); + mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1, PSI_MUTEX_LOCK); ok(mutex_locker == NULL, "no locker"); - rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK); + rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK); ok(rwlock_locker == NULL, "no locker"); - cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT); + cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT); ok(cond_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx", NULL); + file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL); ok(file_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ); + file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ); ok(file_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ); ok(file_locker == NULL, "no locker"); /* Pretend the consumer is disabled */ @@ -978,17 +982,17 @@ void test_locker_disabled() cond_class_A->m_enabled= true; file_class_A->m_enabled= true; - mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK); + mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1, PSI_MUTEX_LOCK); ok(mutex_locker == NULL, "no locker"); - rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK); + rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK); ok(rwlock_locker == NULL, "no locker"); - cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT); + cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT); ok(cond_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx", NULL); + file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL); ok(file_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ); + file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ); ok(file_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ); ok(file_locker == NULL, "no locker"); /* Pretend the instrument is disabled */ @@ -1001,17 +1005,17 @@ void test_locker_disabled() cond_class_A->m_enabled= false; file_class_A->m_enabled= false; - mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK); + mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1, PSI_MUTEX_LOCK); ok(mutex_locker == NULL, "no locker"); - rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK); + rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK); ok(rwlock_locker == NULL, "no locker"); - cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT); + cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT); ok(cond_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx", NULL); + file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL); ok(file_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ); + file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ); ok(file_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ); ok(file_locker == NULL, "no locker"); /* Pretend everything is enabled */ @@ -1024,27 +1028,27 @@ void test_locker_disabled() cond_class_A->m_enabled= true; file_class_A->m_enabled= true; - mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK); + mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1, PSI_MUTEX_LOCK); ok(mutex_locker != NULL, "locker"); psi->start_mutex_wait(mutex_locker, __FILE__, __LINE__); psi->end_mutex_wait(mutex_locker, 0); - rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK); + rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK); ok(rwlock_locker != NULL, "locker"); psi->start_rwlock_rdwait(rwlock_locker, __FILE__, __LINE__); psi->end_rwlock_rdwait(rwlock_locker, 0); - cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT); + cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT); ok(cond_locker != NULL, "locker"); psi->start_cond_wait(cond_locker, __FILE__, __LINE__); psi->end_cond_wait(cond_locker, 0); - file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx", NULL); + file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL); ok(file_locker != NULL, "locker"); psi->start_file_open_wait(file_locker, __FILE__, __LINE__); psi->end_file_open_wait(file_locker); - file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ); + file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ); ok(file_locker != NULL, "locker"); psi->start_file_wait(file_locker, 10, __FILE__, __LINE__); psi->end_file_wait(file_locker, 10); - file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ); ok(file_locker != NULL, "locker"); psi->start_file_wait(file_locker, 10, __FILE__, __LINE__); psi->end_file_wait(file_locker, 10); @@ -1059,17 +1063,17 @@ void test_locker_disabled() cond_class_A->m_enabled= true; file_class_A->m_enabled= true; - mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK); + mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1, PSI_MUTEX_LOCK); ok(mutex_locker == NULL, "no locker"); - rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK); + rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK); ok(rwlock_locker == NULL, "no locker"); - cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT); + cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT); ok(cond_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx", NULL); + file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL); ok(file_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ); + file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ); ok(file_locker == NULL, "no locker"); - file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ); ok(file_locker == NULL, "no locker"); shutdown_performance_schema(); @@ -1102,6 +1106,7 @@ void test_file_instrumentation_leak() PFS_file_class *file_class_A; PFS_file_class *file_class_B; + PSI_file_locker_state file_state; PSI_thread *thread_1; /* Preparation */ @@ -1130,24 +1135,24 @@ void test_file_instrumentation_leak() /* Simulate OPEN + READ of 100 bytes + CLOSE on descriptor 12 */ - file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "AAA", NULL); + file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "AAA", NULL); ok(file_locker != NULL, "locker"); psi->start_file_open_wait(file_locker, __FILE__, __LINE__); psi->end_file_open_wait_and_bind_to_descriptor(file_locker, 12); - file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ); ok(file_locker != NULL, "locker"); psi->start_file_wait(file_locker, 100, __FILE__, __LINE__); psi->end_file_wait(file_locker, 100); - file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_CLOSE); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_CLOSE); ok(file_locker != NULL, "locker"); psi->start_file_wait(file_locker, 0, __FILE__, __LINE__); psi->end_file_wait(file_locker, 0); /* Simulate uninstrumented-OPEN + WRITE on descriptor 24 */ - file_locker= psi->get_thread_file_descriptor_locker((File) 24, PSI_FILE_WRITE); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 24, PSI_FILE_WRITE); ok(file_locker == NULL, "no locker, since the open was not instrumented"); /* @@ -1155,7 +1160,7 @@ void test_file_instrumentation_leak() the instrumentation should not leak (don't charge the file io on unknown B to "AAA") */ - file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_WRITE); + file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_WRITE); ok(file_locker == NULL, "no locker, no leak"); shutdown_performance_schema(); --===============2567393122922207139== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/marc.alff@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: marc.alff@stripped # target_branch: file:///home/malff/BZR_TREE/mysql-trunk-bugfixing-\ # 55087/ # testament_sha1: f22c5fa051647155bbe9b717d2dde47c409ac3ff # timestamp: 2010-07-14 10:24:06 -0600 # base_revision_id: davi.arnaut@stripped\ # 6wwm8ynbhfm2jtt0 # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWS5EhTQAHuR/gFEwAcp7d/// fy/e5L////pgJn3kPtl2eLqVjQImO97mDjZrad221MNOa73e9t5uLeb3e97m5Ttpm0CFrKkCRU3i i8rabRqK2XLRrWI2YbSWZZGtXQwpWWpVQoC0a7auamoolBJJoCGgjUxA1NGKaj1MgDIABtQ0AABp oAiQJMoekATIDEZGAIwhoyBpoaY5hNGRoaGQwjQyGmjQAYjJkAwgGASaSQJCk9qJ6j9KP1QNAaAN GgGgDQA0HqNBEkKaamTCGTIRqegqfiT2kap+kDUaDamj1HqMEZAKkiBNAJok8U8hpqPUGhlNJpoe jSANA02oek08tCHcSoSDA3PbQUoMZ+siFIAzjJxGwNi4wgwKHIXQRe8gNBBIQKGh58oZeJ5fVJ5e roroxh/sNSa5tiyMkiSD4UqSoUQrVFRa0ZbSooWlr+cbW1qRYsUUXTVVNo0X+9FG1tUttagVIqgp gjLSjVQRFWKqwUFG1QT+vwftnd6PW+xfc9z4TiXb3Xe9s2VmzedaGNSScUSiwpkpSxf4QSRH/1JE gJheX85I0KnelK0miG0FVVqqiHkDQyDB4QQyHww0BYaqqiKqsGHdCw2g4rBgwiSRIlzNOZ8pzN0M GyPObqokG/y0TkZWw2+8pTtN4YTsuLMyAwZIB2qyEkWGEBxrAUUWSZqwhOzDtxQJ1zDbdTzGcSd8 2VG9DrbrbbOHtbztq3DW4nHPcsYrBhCyEAdQwIJJkiyS2ZTRAsWYDOCMIs2aIWgqZGZiIsFFUxGO JESpYpc1kiIUKNgQ8ZlRarjlsskwzGHbS0zyXJLqgq8eysmdg7dHPQePju1re/kuaa19qIGwIG8O hIlAniKiaBFhBCRVCQWEYIQgiIwAEREiIiIySR3kn5CRDFhTj/Xq0wXuSAhb8l8mBCg/gUFgSwGC 43XMWOZ4RUfNX0q9asEBQkiiMBYQVSIkiyAiARVJAJBTY7MfvBAePPs525bMYxztrvXde9Vpq+PG QuS1ustoD0ug4EhVQmsDijwRnCoxA2XuW4lQxFkvRt0GFlUUcIZaZTOKGtms/lKYcudOsKg0RDsy OchU01NqM9EAOIhXIW1qll3dDu7JpxN03dJranbLd7MdkxJm1j0V57VIxYLnWLQCDVqiXLWIm7pW mtMKbVTTMamqqafBLzMu7hr1rNPV4IA0JVSKjWrnDTmrfKck3QzFwSYIuMEO7u+9aoRpioV8diYS iLKxMLWSK2giMneK73L4+VD3ExqodtRjkKXwijGRojTLJ1lsLxQQyphuIZ6esuhViFEZLTYa8zGr QGTb1ACpJ1ctR0p0yYhvNFHizZNt7Uus40cWnB2vZmMDtxcTZ2SDzeky3l67UM5aGJb1k5TVzc0a y7q8J1zZwcFNxNhN3pJw6tOeqHF4zFKQLphDLBSnVoypYQFsLEKHMFRhVKNGiGKY6phEkPauYIYj AQYdoIgiyGwyGqKJ+8O1Q3i+reHFQsRTgP6BapVeAF3M1FhP5EC5CKty5YW5ggyhMODBYTBiFCYQ wYLCXMQyESwYxJQl4DxqkqghhGPvDo3dn4wshpxRCX95pbRF+mZUFbDJP4/y3OkcIy/LZrGLFGMW om+P1rYGCUOd9aYc0hVGAMObCyRJuEKUdmH1LWski+v4h1pbPnCQkkldm/QnUNXvp05dGDOJrBMz ySyGpNEikIUmqUEXUBQui3t3W4hhDkiyOSOUYtOp7+VzNSOUZcC6ekkrdhHS2UZxtiwxkwMqFUpp GUa46atZJZL4o5Wjnui0eMgoZyGme2N8YzCt34GC+6PCTlF5EmZN8XyPlKKKNVLFFFFFE4I29++b K1iuCSbIm3brGzXKSMwIuiPGCMcUMjOsoNYQFVvY3REF0DFGT9fT2+w8/bJz19Zxkev2blqVbCIp Ml/mAzQtyMYHqw7NBj3h0S2ZmBup1230rk3RpZUnYD0/QweYJOm/o4c8IsAiDE8z/Xx609wH+YQc w6ho7jtLpgfuhNtQj9RRPgonKA/X5ksT0+jf6tZDvkXFqXzXSL+DC3xRht5uVMss0l5zQXEe6sPi fz+39Lj97jjwiRgfFSeh8cIGmmhQ1xtWVrKywyyYOysFN26y174w+Isbi/BPhHXA/VFBuVcSIrdB fJIiHASCDv2/hC/rCDFewiy3i7s3bqQ5fNYJtVqtpu7oVYApHaUrWg6ewCJdTrnAe9Pr8zYnwG14 aI0HWYbw05W+GWjJ3MJGEIYMtm2ycSJqIO4jEQJ8ZKDIqyA8lOoMDc8b58lh3DCd5xk+2E8n21G6 O1Nx+n7t+ZeJDIzbECH5kHHxCHyvROTD7EH3Jx6tSURCCQYAwQjBGCB4Q9RqSiqKqwvqEowko4Jm Sd5kbZJ0Mflk7T7OJ+hibPBD4ZZXibE3J0pesfXSWDCaKtvN9HoSJYumcZd8b+XC1vUgdg1TPSU2 OqMFhSCpQAYmuEKOzUw+XRNAQqqqVwHofrFX4P1JFRrjwhJJZXGy2kGqkkpi6+/lXYvzW3ha3j3E kd3zvnoIHLCctSQKzZ3ZslzW271vArDlhymuMwFnTKlvWTq786JWaQ4YVxA5YBwwIpDydnlFBGGy BjDsgaQnCQqYDOpHnrQHJAEhWBDKKoNH8kaNhnktWREap2Ql7UujuIj70mtcJ27J4d9Um0k3IBzs 8OOtqfkZiGk7W8nfmTshhmjDdVvOGySwJ5mE44UmUYkEkzSO4gUb0GLlmsMO9QSPoeCQmdpDf6fO RCL5ZyRHE9CyThRmBuBmJ6NG16LEM8boLLMVUvdjJGEMScXF6tW5sfXtgcD24mX/O+MFbQ2KBKgW zLnNAmKmKDt2S8h9nk6ENSaFU4REQoiJIJu6StsA8BBIRFUJ5Y8rPPk8dLa3qcPaqW4YQrzoBobH u3rJtRhrh1J0xke+E1RwvNq19HcXkwKVUhAZ3iepJRgdUsiqHgJA9LDXF2Q9AO89AiiKrsNA+dlV iSGuDBcUoE0xjN5JdHSr1dQ6XWNxk3myE8cZsvvtsrdiMDxh395NapYZVlqL3CZ1Q8Vmaya69Pf3 ca7c/Tsm/XJbPhZNGeOjdswrHHXhtUvGQoIGIUWaCmHUdFburfmGS43qmdHzOBoFtBLum7YlaMlm LJ7z1HE7Mtmbg22wYKspdtsvmJMQSdtzY1etLXtwDiUjjxLlhFCrTpIeLA8IfUBzYAhLMyDNR5vb SJj53UpyvOIfJUj5pKLvRlQi3PWL8DcmG48JMwbgMMmDtSXgCcvCZK+Rs5djJk6mH1Jgw7Hgs00U 8e7N752x6IUrE5LvOsDLy56ri36qXw10lRUJg2cHSSHEpeggncVb9+3WDOjsmF07XEXQpoBdXZ0x Q742LDYGjQQXrifO2AHS0RKTkuoG9sGG1tG0SqkQqTM6Nra3KRhrGGF8ymtSeSdIexrc1oPC9/Z2 kmx2EySOx528CbmXyNvqW6N9BcQKtoE3ErCsV6qbVboECw5RiUTDN4QXeShWQndGFGGIqUpQq5KN fDhMc4aGDSRw2yyunY7BJQkglPyAeHnix2kTnhGzfTtm61YtrWM9bY6wng4Nut2j5aOpDQSuie6Q hI/iiPU8DLtOJtoL1b3r1ajeX8ArhmVfMh1E8x0L6Ofamsgc91KaEbUliujhk2nRi1YxUzD9IK4L sgluzutHJhlBe97ADSXCABsQDRoDM+/R8c7WfG010aAMqQwldPKIjhpGR0DtooyZczEsQMuAgNCt DPjH6A1ng0FSaWKisjkh3dqAgcxqFNRBTgFXOmjvC2iJzHIVHoSkwReqZkuSBcDl1mFzQY1wIq7t q21CCccuOaNOUNI0ll2TwsNtPBArk1TmX3GMjM4HAkcRyrDlF2jWQdTXW6pPQ+TVfr6k252WvCzj bG+GyzqIffa6ZhkzDtURi9cd5uDCxbUcmomHuiMaLWnbLLGKTAItgEBrJQG5XVxnSRc1ccvWWJQI lpiNbUOVWK5xRvDSi4DIo4rqOK59htNajnm4hE8OVwVqiafr3xYwQJ0Rc2wdErV240wWnPD0NDBl OdrnU/Z0Y6NvClcddXNx3umB4UWkKODratrshMJ9iDDoyctLODgxXyqn0GD/uSOymTnAKwB3HcYM Yyksuyrhja9aQpZseIxbqHswhWwRdzWrdw+PTuWS3OSHJqpYO9qQrglkRCNCyOMHMiuUIxbuIG6P lXkomhkaFYNCr+GmAHRkzJhtyk67JMsyPAB8YvqSiSvzMjTcypPHi+MSAxKfPtYJCWOVaQWQ1jgQ VGc0YptU2SmlsS9DbBtoKdZu5hNAoO25hkOceuw5Q12OD7ktdZPQrIdUzIcCpEuYlIm2xgUMdiyB UGoMZDZnt02WGTkL0TaVg0DWmXCkXhedIjlpVjGen1Joqz3oqC9O8RBZi1B72OmRxw2tu7gQsjhQ aGxI7Da4b4ZJA8dtJG4G1DuDAdERQEp3CHAQOkCuSxA8AbBwdRe8wT0BdVFni3i4UcBhbjkQ4Igb EJDSWMMD6R5chzqqRxymxXVjUgMgUKjBJl02ImKrbTKoZDQbrpZdXmwYcWuNMrcVOTV0vxW+RzNS NhwUsvdzQ1NECxoYExnG4HMaN7bUPBK3Rui+YVs9zedxBhe9TzpYkN5vTuyH1D4unxsmYWVZwTdq HgMVZLSptrIl4d4w4HBTJfMMmdCxAUaHeSBI49pCbVwqWBt2kmBgFcJPnK8ZzzM8HtzZeEASbfCT GHhMCixFWHseJHIcPFOieaiZBxCqBdOBKVFZaNhW7EyQzmkatSEWqE0PpBmTljOtRpQhzkOWipDq 8TiRSLtYNQoGqSGLxyUbEUJDiNgcwOPIKdOvq3wM6Ex5jdi1inlW41ygaWZazZFkkQZEG6mHXAzZ i3UQDcxkYuNd5mslBCAIqELC9uhASUAQiAQ4wZsLtoQWZoAhwyjFdAZBokj8BPU8hqxvWYmiGsQG YOo2zwCFyEJIrk6hXCE26Zl83kjBLJwNDWl3qqOloigesALURW4TYITyc98Jg3zg9CsSyMI1sFeI MX5d1dDW5c1OWpS5hhsaHAwK5lTMzOBrM3RBJYi/N3KGAUbs23rmXeEIMsq0iKg5cGom6TLgWK6y wU2shlYysHLhcvKnvQBNpWi+UkdDM3MuKEjAgHUGUd147xIYPPPn48nIbczAQAXsUMDOMiAfJfAK EHaAJAjkpEREc97uYGF76YNTI00RkMEZGN8Yj1ICyG8oIOwtgQKGw29SaPFP3DmFEAjefnftPUcb GIuLIeRJh6Fo0iE2yJ7GY/aGQwU0HtA1iQzsXseojrvxiTyRBLky45yB9gdBBEQZwGHA3FaHQxjR DNcxkKMypIoxK3kDcCcbcBQ5ANe6e8T2T4iZCqxRjEWMWCKsVRASCxVJFRVVGCoiCixS2iyoFirC g+g9FWKfditZ33TG/1F484wZUxxMyZRQwxLMNjjNs4hvpm5OQEA+xtBUFVV6/BIHmH6AEmoSB6dw 4OhMVKEZVWjYgchMjHFWKMiqrB3A+kfVCIz5vMqJJO87jsDOPP4HtAukpxjrlT9P/yrNn6UT+qfr az++jnYNgcAsEikJCEAJJKv8cj+ajrEy0qGsWxFwn9NT/3CUUV+Ym/Dd/ayn5jKfOvChG0R/3vf4 Q6kjkgjn/QBN6ak2CIp15qf6DuiJw2olj/cCH/SpA8faVWfFowxXiBzPCagPcG8hm7Y3EbpE0jQW l8BpaQPyo65Uh+dB60P7BNSlFYRAYsn+/gpIGkn/NjMAih60MDLYiwJskINUSmyaYAdKJ6NpT1pE LbWu4RFIGhXtTfyo4WlWxs7YY3yjwUR7SPbC+EYeELJ/PbCr6Ox7PxH7k9aRP0J9qdDvSBAE1ARC l2wX+KxshBv60puaP+R/cP3JCW8z6HQh+HyosWwthCMKL7kSySzj8BJoRPtA0KCUgUlIWQPd0Q4O SIInYEqMGOeyNlP9oK9AligOrNP1oXS48E0pV0LgyyYBo2MMCwoQyGQRChMy4zEzLDFYExXFRFFU VVYIYGBgVuXHMsMEwwpgmGFjmYZmZRKYUWmMYxe8xjGL3lrVrRp0BhbAkYlroFzcpM23zMzByltL aG0DYkZ4KMkEVFK/10GUYNIlyFSovSE3STQwtI4BNKgN0LpFM0yS5aFrXvcUCKH3rCJpTIiuGNF6 E3NhM0AYCUXQYszZWynSUTEi0zR62+S1sVNSVlulFGB+c/TOegkH6z4n5DmflPxUQL6SJkfvWND9 o4Od1SlCf02NTrPjoZkV/GepWFz4C7BIOBI0ORgDwkns7gOyQ7KkRPKUc3Z+3JDwKE2E7hPx/gp7 E4ESR/IQDy6rzNdihoRCjiYRjHgMIl/bFdcWfJSLI+oyQLsYqYIjsm8ayTZGW6Oc3TXWSKO2DQRp UkRG3AtC9FI8aSVa0TmchpoK3fVxidt4IZAu8Z91yHO3zGKObnkWPIwM14wMSDJuvkxbLtF38Nvm 9zZbyawmrizZNrpdtY+5Gu4DecXMeo9itCh60dP/mv8Qi2PL2Ej9BEHsP4xeTBQp1unVYqMkDlLw n7+HjNSJQmgrPoUHO6p6oiSOhjWJU69xYwTl4l/DqN9cggUi1HYigVCJ5ezx3BGGJ713iqp7oE3H jgYxOYqIFqP2DbjkIJaCG5gcDfsx9s0luycuWw7ukk+qXh3eoa0RkUCScpM/FiBmhcdiEVqYyLPy LKlLRQqKE/+i1lCdFf7zhEeaDoIm2KR3oCl3ENglCb5AZKiFRtR3UBQkO8ikByPcLvPd3Zg+HcdT r4jYGrmZHCXkchxzYOBQsFyXXvyNwRoXL/CRqcUkdcn2zxCRmTKmPLFsc9MEqjqQWi1VIFQKRSgq SpTNsdR3wdQ9klVsZOjMz9TWdsJdm0TdVR3Jz52Jh5MMOrJNGhHJ7o3UjGPXEdE2QmPSnNdq98h5 s34Vu4G+N5z+xDxwk2FloPV2498SYiQHnrsmThIrhyTJIuLzgBCqIlEPFJj3UrVHwsipWCGRBESc 3Kysot005pQHZAdAP1wITQKd6WpCyxIkECQQIkSoDSOSZUuq6WGwAFGSF7OwePlCA54Pk3u9fZb0 6+R7DzGmOciWHl4sedM89HXe8PwQZu94tw4TYzwJMYnYROyQ/iXoadBITkc/QlA1SWAOpXwVrveT FKJIFGQpwoFCUMUlSElVVVQRkrJIm5u5tqSSdmHouJxZTo3sXnr3JSdnkax8eqtx5dDYxBHU6Hs9 +x8Ni5gjDr2uG4TBEsfEc6CXES7El0S8Q69mE9g7ud5RDTLSPyhIDuR4LxS6qetPFLuJeKQYB7SV aSPSQ6vjJ2xUXCbommyIlCRc7ULmIMTCaO7AUJdFC5YXISwopqFDCXApf757w0I24owLITgL1ThN IjiZmFFeuBLMSTDQ7+1BnA0lKUqpEjqcCTYbUfMcOsig7tkJ3O5wk8MfFT5WOerzYMmUuljgUrse beuIgDMrGhyAyKljBAuu9A0Mie1texgyVIew5KQNp3CbY+uP5yS0j7oSSDaCGGmD7laBskRIrFIP 7QssRUkifAiyxFOKvaXR+UeM8sUhzAifEPFRtCgslwH5RfUroDwbeIMEmEQUCWm/zJPGlkC2klpY BbZLRSNUSGkNoLoROD9ryToE8x9sHyCD631r7y/uFDZT+EBsn3JmIYOt2lj9qQF9vLMHaJrcDmmR REiRNyvWrYVWL3DxBFdog2CKB5gRwkHMdvYntwFCX5nXInqPWg1JrFzZDYYekh09DOfVnH/EoKhU gR3diNUk9SZlPNJmh5CXcTbGqkerZs4cfvLbG0/haHkkok+jx8I+s9hwMuY4kOJRKKhUh8TwiPpk ehySQiRIJ79j9F7FHkL47xO8ZxPtC/d2qLtOcHf9P3o98fT80fNJM0HgfXOOaME+PpI5hWwUFivV R4UCSeufLKqH3VFD4qwB+CB88L9Qgce9GTcr6UPzAHUqYm+S4ZYqoffHkj1oylR1yTOPCOMedIFi xgIwCoE8uAALITTILCBFAIgwVSIjFYwYEUBBRGklN36jegYHZHWi+VfOU39p4M/cJAfcUFAZkQXw CJBi2X/EboUBFIffSWkP3SJ++kl4SJ9JG0jqalHYIdLYcYUNq7RUPc83lvC4fnHcLkoUFKfnVaKB IAwSCd78QNh8j9SMBqSlrFlrFlipb4FMIcRrENkmkXJEm3vFfaOHSFgyIGAh8Xanmua6AmSmSfso vHvR37aJVTqFnsouUipKigvpSqzD70scOEJKNo6ybEiLEoWwWHGidIlHagoTklHYjvmfNWNSTjBi M5JtiNqGsawvUS4lESkpaloKM7WRVIqTWYFyL4vgUC6LjePAbsEjsxF1CUSkUjKpBhFwLifNW4Nl gD5xQ1jtNP0NAOxPH7Ft0i0eNx0n2zzkkkkyHmMPgcIODyk75E+EYDrknHZJEbyIokMPt9xwEfAw TlGSRxvJHBKqSKKhYs1iOqI9oFIj7IzYQWuc5KH3vGinjrp/ciwnFsdRkhY1MD2W4Yxwks8fmLSS pI+vKQ6eZGgf5VImcnOx2nfJd6V2pPfC9/TRG4On9SfPzMYNRGkWkFbKVSq3vVEcth/cvJX9Ige1 5rxUNodacl7CJRBekYRbSWCA5EBSSQwh9OhIGR6ggqYRIAI+JQiOhD7kaSrihBQMwTMS5YpIkSPs FVyUOxMk/tWok1bVDJFLdofQKUMhX1M50idKBYTIOM3ZfKWonmjvd8k6pDSSbDXSSQWQe0egDpie Y1REiBEgCfJKrITSkQ5mOHkiAEmSdDAHulkB8ku9D98VRP8+KCqjJs+yNM7RaxpJGvpJgccKxhOg 1v380J7LDIEiEpAtDkKpvSvbdP3b1G6tjwEfgnNHyUVUVSqfRO2MvSQ0IvOo3ktXWUUGhMAhFiq9 698FoWkPXAaUYFSe6wFmEEJsQ04MWQqxS2iqqoLIosUFJWKxEkA9sPLqSYIfIJjIaFzJZZZSZrLp dZSUQpSlEKJgYYYUSJSlECeEG2zviaP65PbPce5St0nPtESo9ZNwYKiHKovha1oLGEfNHrxd0+5M EaI0OwZGav1CvWgDhA1J1pyaQckU80gISNEZIhGhSRL3THOLRo3mKS6He2xqFUgr5hnXNIImwedD rEgwVHAe2BvCwJzA9ZpwJIqzilIbVc06JIGhE3CJcHqKUKIormAcQqw64yPjN0bkYtpG4/RJOPu1 Qk6kPjH4+86I3dvsCwJSjkh0o3TeY9OATj7y9UFbJpyCwncJ+xQwurj1geYqnZYTWCvmRU+wNan0 vpzF3CDQGwHyqKPpyXftRxHxE9fKTTYmqUnFGWBmnJMoE4/CY6P6JaCeUUjypF0qAsnkg6RzkwIZ R3xyaw8EiYYPoGXRsoUFyyUEX5rG4w/FHi+P1IKm4lyPD1yG6enh0dv42qVBVe8w3I4nJO5BZH0i P/xdyRThQkC5EhTQ --===============2567393122922207139==--