Commit 5c1b91f1 authored by unknown's avatar unknown
Browse files

Merge bk-internal:/home/bk/mysql-5.0 

into serg.mylan:/usr/home/serg/Abk/mysql-5.0


sql/handler.cc:
  Auto merged
sql/lock.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_table.cc:
  Auto merged
parents 2bbde22d 5cb5a11b

mysql-test/r/flush.result

+1 −1
Original line number Diff line number Diff line
@@ -8,7 +8,7 @@ n 
3

flush tables with read lock;

drop table t2;

ERROR HY000: Table 't2' was locked with a READ lock and can't be updated

ERROR HY000: Can't execute the query because you have a conflicting read lock

 drop table t2;

unlock tables;

create database mysqltest;

mysql-test/t/flush.test

+1 −1
Original line number Diff line number Diff line
@@ -37,7 +37,7 @@ connection con1; 
select * from t1;

connection con2;

flush tables with read lock;

--error 1099;

--error 1223

drop table t2;

connection con1;

send drop table t2;

sql/handler.cc

+20 −6
Original line number Diff line number Diff line
@@ -762,6 +762,14 @@ static char* xid_to_str(char *buf, XID *xid) 
  for (i=0; i < xid->gtrid_length+xid->bqual_length; i++)

  {

    uchar c=(uchar)xid->data[i];

    bool is_next_dig;

    if (i < XIDDATASIZE)

    {

      char ch=xid->data[i+1];

      is_next_dig=(c >= '0' && c <='9');

    }

    else

      is_next_dig=FALSE;

    if (i == xid->gtrid_length)

    {

      *s++='\'';
@@ -774,9 +782,11 @@ static char* xid_to_str(char *buf, XID *xid) 
    if (c < 32 || c > 126)

    {

      *s++='\\';

      *s++='x';

      *s++=_dig_vec_lower[c >> 4];

      *s++=_dig_vec_lower[c & 15];

      if (c > 077 || is_next_dig)

        *s++=_dig_vec_lower[c >> 6];

      if (c > 007 || is_next_dig)

        *s++=_dig_vec_lower[(c >> 3) & 7];

      *s++=_dig_vec_lower[c & 7];

    }

    else

    {
@@ -862,6 +872,10 @@ int ha_recover(HASH *commit_list) 
        my_xid x=list[i].get_my_xid();

        if (!x) // not "mine" - that is generated by external TM

        {

#ifndef DBUG_OFF

          char buf[XIDDATASIZE*4+6]; // see xid_to_str

          sql_print_information("ignore xid %s", xid_to_str(buf, list+i));

#endif

          found_foreign_xids++;

          continue;

        }
@@ -962,9 +976,9 @@ bool mysql_xa_recover(THD *thd) 
        if (xid->get_my_xid())

          continue; // skip "our" xids

        protocol->prepare_for_resend();

        protocol->store_long((longlong)xid->formatID);

        protocol->store_long((longlong)xid->gtrid_length);

        protocol->store_long((longlong)xid->bqual_length);

        protocol->store_longlong((longlong)xid->formatID, FALSE);

        protocol->store_longlong((longlong)xid->gtrid_length, FALSE);

        protocol->store_longlong((longlong)xid->bqual_length, FALSE);

        protocol->store(xid->data, xid->gtrid_length+xid->bqual_length,

                        &my_charset_bin);

        if (protocol->write())

sql/lock.cc

+15 −15
Original line number Diff line number Diff line
@@ -800,8 +800,8 @@ bool lock_global_read_lock(THD *thd) 


  if (!thd->global_read_lock)

  {

    (void) pthread_mutex_lock(&LOCK_open);

    const char *old_message=thd->enter_cond(&COND_refresh, &LOCK_open,

    (void) pthread_mutex_lock(&LOCK_global_read_lock);

    const char *old_message=thd->enter_cond(&COND_refresh, &LOCK_global_read_lock,

					    "Waiting to get readlock");

    DBUG_PRINT("info",

	       ("waiting_for: %d  protect_against: %d",
@@ -809,7 +809,7 @@ bool lock_global_read_lock(THD *thd) 


    waiting_for_read_lock++;

    while (protect_against_global_read_lock && !thd->killed)

      pthread_cond_wait(&COND_refresh, &LOCK_open);

      pthread_cond_wait(&COND_refresh, &LOCK_global_read_lock);

    waiting_for_read_lock--;

    if (thd->killed)

    {
@@ -834,11 +834,11 @@ bool lock_global_read_lock(THD *thd) 
void unlock_global_read_lock(THD *thd)

{

  uint tmp;

  pthread_mutex_lock(&LOCK_open);

  pthread_mutex_lock(&LOCK_global_read_lock);

  tmp= --global_read_lock;

  if (thd->global_read_lock == MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT)

    --global_read_lock_blocks_commit;

  pthread_mutex_unlock(&LOCK_open);

  pthread_mutex_unlock(&LOCK_global_read_lock);

  /* Send the signal outside the mutex to avoid a context switch */

  if (!tmp)

    pthread_cond_broadcast(&COND_refresh);
@@ -857,7 +857,7 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh, 
  DBUG_ENTER("wait_if_global_read_lock");



  LINT_INIT(old_message);

  (void) pthread_mutex_lock(&LOCK_open);

  (void) pthread_mutex_lock(&LOCK_global_read_lock);

  if ((need_exit_cond= must_wait))

  {

    if (thd->global_read_lock)		// This thread had the read locks
@@ -865,7 +865,7 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh, 
      if (is_not_commit)

        my_message(ER_CANT_UPDATE_WITH_READLOCK,

                   ER(ER_CANT_UPDATE_WITH_READLOCK), MYF(0));

      (void) pthread_mutex_unlock(&LOCK_open);

      (void) pthread_mutex_unlock(&LOCK_global_read_lock);

      /*

        We allow FLUSHer to COMMIT; we assume FLUSHer knows what it does.

        This allowance is needed to not break existing versions of innobackup
@@ -873,11 +873,11 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh, 
      */

      DBUG_RETURN(is_not_commit);

    }

    old_message=thd->enter_cond(&COND_refresh, &LOCK_open,

    old_message=thd->enter_cond(&COND_refresh, &LOCK_global_read_lock,

				"Waiting for release of readlock");

    while (must_wait && ! thd->killed &&

	   (!abort_on_refresh || thd->version == refresh_version))

      (void) pthread_cond_wait(&COND_refresh,&LOCK_open);

      (void) pthread_cond_wait(&COND_refresh,&LOCK_global_read_lock);

    if (thd->killed)

      result=1;

  }
@@ -890,7 +890,7 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh, 
  if (unlikely(need_exit_cond)) 

    thd->exit_cond(old_message);

  else

    pthread_mutex_unlock(&LOCK_open);

    pthread_mutex_unlock(&LOCK_global_read_lock);

  DBUG_RETURN(result);

}
@@ -901,10 +901,10 @@ void start_waiting_global_read_lock(THD *thd) 
  DBUG_ENTER("start_waiting_global_read_lock");

  if (unlikely(thd->global_read_lock))

    DBUG_VOID_RETURN;

  (void) pthread_mutex_lock(&LOCK_open);

  (void) pthread_mutex_lock(&LOCK_global_read_lock);

  tmp= (!--protect_against_global_read_lock &&

        (waiting_for_read_lock || global_read_lock_blocks_commit));

  (void) pthread_mutex_unlock(&LOCK_open);

  (void) pthread_mutex_unlock(&LOCK_global_read_lock);

  if (tmp)

    pthread_cond_broadcast(&COND_refresh);

  DBUG_VOID_RETURN;
@@ -922,16 +922,16 @@ bool make_global_read_lock_block_commit(THD *thd) 
  */

  if (thd->global_read_lock != GOT_GLOBAL_READ_LOCK)

    DBUG_RETURN(1);

  pthread_mutex_lock(&LOCK_open);

  pthread_mutex_lock(&LOCK_global_read_lock);

  /* increment this BEFORE waiting on cond (otherwise race cond) */

  global_read_lock_blocks_commit++;

  /* For testing we set up some blocking, to see if we can be killed */

  DBUG_EXECUTE_IF("make_global_read_lock_block_commit_loop",

                  protect_against_global_read_lock++;);

  old_message= thd->enter_cond(&COND_refresh, &LOCK_open,

  old_message= thd->enter_cond(&COND_refresh, &LOCK_global_read_lock,

                               "Waiting for all running commits to finish");

  while (protect_against_global_read_lock && !thd->killed)

    pthread_cond_wait(&COND_refresh, &LOCK_open);

    pthread_cond_wait(&COND_refresh, &LOCK_global_read_lock);

  DBUG_EXECUTE_IF("make_global_read_lock_block_commit_loop",

                  protect_against_global_read_lock--;);

  if (error= thd->killed)

sql/mysql_priv.h

+1 −1
Original line number Diff line number Diff line
@@ -1102,7 +1102,7 @@ extern pthread_mutex_t LOCK_mysql_create_db,LOCK_Acl,LOCK_open, 
       LOCK_thread_count,LOCK_mapped_file,LOCK_user_locks, LOCK_status,

       LOCK_error_log, LOCK_delayed_insert, LOCK_uuid_generator,

       LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone,

       LOCK_slave_list, LOCK_active_mi, LOCK_manager,

       LOCK_slave_list, LOCK_active_mi, LOCK_manager, LOCK_global_read_lock,

       LOCK_global_system_variables, LOCK_user_conn;

extern rw_lock_t LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;

extern pthread_cond_t COND_refresh, COND_thread_count, COND_manager;