thr_lock.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:40k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /*
  14. Read and write locks for Posix threads. All tread must acquire
  15. all locks it needs through thr_multi_lock() to avoid dead-locks.
  16. A lock consists of a master lock (THR_LOCK), and lock instances
  17. (THR_LOCK_DATA).
  18. Any thread can have any number of lock instances (read and write:s) on
  19. any lock. All lock instances must be freed.
  20. Locks are prioritized according to:
  21. The current lock types are:
  22. TL_READ   # Low priority read
  23. TL_READ_WITH_SHARED_LOCKS
  24. TL_READ_HIGH_PRIORITY # High priority read
  25. TL_READ_NO_INSERT # Read without concurrent inserts
  26. TL_WRITE_ALLOW_WRITE # Write lock that allows other writers
  27. TL_WRITE_ALLOW_READ # Write lock, but allow reading
  28. TL_WRITE_CONCURRENT_INSERT
  29. # Insert that can be mixed when selects
  30. TL_WRITE_DELAYED # Used by delayed insert
  31. # Allows lower locks to take over
  32. TL_WRITE_LOW_PRIORITY # Low priority write
  33. TL_WRITE # High priority write
  34. TL_WRITE_ONLY # High priority write
  35. # Abort all new lock request with an error
  36. Locks are prioritized according to:
  37. WRITE_ALLOW_WRITE, WRITE_ALLOW_READ, WRITE_CONCURRENT_INSERT, WRITE_DELAYED,
  38. WRITE_LOW_PRIORITY, READ, WRITE, READ_HIGH_PRIORITY and WRITE_ONLY
  39. Locks in the same privilege level are scheduled in first-in-first-out order.
  40. To allow concurrent read/writes locks, with 'WRITE_CONCURRENT_INSERT' one
  41. should put a pointer to the following functions in the lock structure:
  42. (If the pointer is zero (default), the function is not called)
  43. check_status:
  44.  Before giving a lock of type TL_WRITE_CONCURRENT_INSERT,
  45.          we check if this function exists and returns 0.
  46.  If not, then the lock is upgraded to TL_WRITE_LOCK
  47.  In MyISAM this is a simple check if the insert can be done
  48.  at the end of the datafile.
  49. update_status:
  50. Before a write lock is released, this function is called.
  51. In MyISAM this functions updates the count and length of the datafile
  52. get_status:
  53. When one gets a lock this functions is called.
  54. In MyISAM this stores the number of rows and size of the datafile
  55. for concurrent reads.
  56. The lock algorithm allows one to have one TL_WRITE_ALLOW_READ,
  57. TL_WRITE_CONCURRENT_INSERT or one TL_WRITE_DELAYED lock at the same time as
  58. multiple read locks.
  59. */
  60. #if !defined(MAIN) && !defined(DBUG_OFF) && !defined(EXTRA_DEBUG)
  61. #define DBUG_OFF
  62. #endif
  63. #include "mysys_priv.h"
  64. #ifdef THREAD
  65. #include "thr_lock.h"
  66. #include <m_string.h>
  67. #include <errno.h>
  68. my_bool thr_lock_inited=0;
  69. ulong locks_immediate = 0L, locks_waited = 0L;
  70. enum thr_lock_type thr_upgraded_concurrent_insert_lock = TL_WRITE;
  71. /* The following constants are only for debug output */
  72. #define MAX_THREADS 100
  73. #define MAX_LOCKS   100
  74. LIST *thr_lock_thread_list; /* List of threads in use */
  75. ulong max_write_lock_count= ~(ulong) 0L;
  76. static inline pthread_cond_t *get_cond(void)
  77. {
  78.   return &my_thread_var->suspend;
  79. }
  80. /*
  81. ** For the future (now the thread specific cond is alloced by my_pthread.c)
  82. */
  83. my_bool init_thr_lock()
  84. {
  85.   thr_lock_inited=1;
  86.   return 0;
  87. }
  88. #ifdef EXTRA_DEBUG
  89. #define MAX_FOUND_ERRORS 10 /* Report 10 first errors */
  90. static uint found_errors=0;
  91. static int check_lock(struct st_lock_list *list, const char* lock_type,
  92.       const char *where, my_bool same_thread, bool no_cond)
  93. {
  94.   THR_LOCK_DATA *data,**prev;
  95.   uint count=0;
  96.   pthread_t first_thread;
  97.   LINT_INIT(first_thread);
  98.   prev= &list->data;
  99.   if (list->data)
  100.   {
  101.     enum thr_lock_type last_lock_type=list->data->type;
  102.     if (same_thread && list->data)
  103.       first_thread=list->data->thread;
  104.     for (data=list->data; data && count++ < MAX_LOCKS ; data=data->next)
  105.     {
  106.       if (data->type != last_lock_type)
  107. last_lock_type=TL_IGNORE;
  108.       if (data->prev != prev)
  109.       {
  110. fprintf(stderr,
  111. "Warning: prev link %d didn't point at previous lock at %s: %sn",
  112. count, lock_type, where);
  113. return 1;
  114.       }
  115.       if (same_thread && ! pthread_equal(data->thread,first_thread) &&
  116.   last_lock_type != TL_WRITE_ALLOW_WRITE)
  117.       {
  118. fprintf(stderr,
  119. "Warning: Found locks from different threads in %s: %sn",
  120. lock_type,where);
  121. return 1;
  122.       }
  123.       if (no_cond && data->cond)
  124.       {
  125. fprintf(stderr,
  126. "Warning: Found active lock with not reset cond %s: %sn",
  127. lock_type,where);
  128. return 1;
  129.       }
  130.       prev= &data->next;
  131.     }
  132.     if (data)
  133.     {
  134.       fprintf(stderr,"Warning: found too many locks at %s: %sn",
  135.       lock_type,where);
  136.       return 1;
  137.     }
  138.   }
  139.   if (prev != list->last)
  140.   {
  141.     fprintf(stderr,"Warning: last didn't point at last lock at %s: %sn",
  142.     lock_type, where);
  143.     return 1;
  144.   }
  145.   return 0;
  146. }
  147. static void check_locks(THR_LOCK *lock, const char *where,
  148. my_bool allow_no_locks)
  149. {
  150.   uint old_found_errors=found_errors;
  151.   DBUG_ENTER("check_locks");
  152.   if (found_errors < MAX_FOUND_ERRORS)
  153.   {
  154.     if (check_lock(&lock->write,"write",where,1,1) |
  155. check_lock(&lock->write_wait,"write_wait",where,0,0) |
  156. check_lock(&lock->read,"read",where,0,1) |
  157. check_lock(&lock->read_wait,"read_wait",where,0,0))
  158.       found_errors++;
  159.     if (found_errors < MAX_FOUND_ERRORS)
  160.     {
  161.       uint count=0;
  162.       THR_LOCK_DATA *data;
  163.       for (data=lock->read.data ; data ; data=data->next)
  164.       {
  165. if ((int) data->type == (int) TL_READ_NO_INSERT)
  166.   count++;
  167.       }
  168.       if (count != lock->read_no_write_count)
  169.       {
  170. found_errors++;
  171. fprintf(stderr,
  172. "Warning at '%s': Locks read_no_write_count was %u when it should have been %un", where, lock->read_no_write_count,count);
  173.       }      
  174.       if (!lock->write.data)
  175.       {
  176. if (!allow_no_locks && !lock->read.data &&
  177.     (lock->write_wait.data || lock->read_wait.data))
  178. {
  179.   found_errors++;
  180.   fprintf(stderr,
  181.   "Warning at '%s': No locks in use but locks are in wait queuen",
  182.   where);
  183. }
  184. if (!lock->write_wait.data)
  185. {
  186.   if (!allow_no_locks && lock->read_wait.data)
  187.   {
  188.     found_errors++;
  189.     fprintf(stderr,
  190.     "Warning at '%s': No write locks and waiting read locksn",
  191.     where);
  192.   }
  193. }
  194. else
  195. {
  196.   if (!allow_no_locks &&
  197.       (((lock->write_wait.data->type == TL_WRITE_CONCURRENT_INSERT ||
  198.  lock->write_wait.data->type == TL_WRITE_ALLOW_WRITE) &&
  199. !lock->read_no_write_count) ||
  200.        lock->write_wait.data->type == TL_WRITE_ALLOW_READ ||
  201.        (lock->write_wait.data->type == TL_WRITE_DELAYED &&
  202. !lock->read.data)))
  203.   {
  204.     found_errors++;
  205.     fprintf(stderr,
  206.     "Warning at '%s': Write lock %d waiting while no exclusive read locksn",where,(int) lock->write_wait.data->type);
  207.   }
  208. }       
  209.       }
  210.       else
  211.       { /* Have write lock */
  212. if (lock->write_wait.data)
  213. {
  214.   if (!allow_no_locks && 
  215.       lock->write.data->type == TL_WRITE_ALLOW_WRITE &&
  216.       lock->write_wait.data->type == TL_WRITE_ALLOW_WRITE)
  217.   {
  218.     found_errors++;
  219.     fprintf(stderr,
  220.     "Warning at '%s': Found WRITE_ALLOW_WRITE lock waiting for WRITE_ALLOW_WRITE lockn",
  221.     where);
  222.   }
  223. }
  224. if (lock->read.data)
  225. {
  226.   if (!pthread_equal(lock->write.data->thread,
  227.      lock->read.data->thread) &&
  228.       ((lock->write.data->type > TL_WRITE_DELAYED &&
  229. lock->write.data->type != TL_WRITE_ONLY) ||
  230.        ((lock->write.data->type == TL_WRITE_CONCURRENT_INSERT ||
  231.  lock->write.data->type == TL_WRITE_ALLOW_WRITE) &&
  232. lock->read_no_write_count)))
  233.   {
  234.     found_errors++;
  235.     fprintf(stderr,
  236.     "Warning at '%s': Found lock of type %d that is write and read lockedn",
  237.     where, lock->write.data->type);
  238.     DBUG_PRINT("warning",("At '%s': Found lock of type %d that is write and read lockedn",
  239.     where, lock->write.data->type));
  240.   }
  241. }
  242. if (lock->read_wait.data)
  243. {
  244.   if (!allow_no_locks && lock->write.data->type <= TL_WRITE_DELAYED &&
  245.       lock->read_wait.data->type <= TL_READ_HIGH_PRIORITY)
  246.   {
  247.     found_errors++;
  248.     fprintf(stderr,
  249.     "Warning at '%s': Found read lock of type %d waiting for write lock of type %dn",
  250.     where,
  251.     (int) lock->read_wait.data->type,
  252.     (int) lock->write.data->type);
  253.   }
  254. }
  255.       }
  256.     }
  257.     if (found_errors != old_found_errors)
  258.     {
  259.       DBUG_PRINT("error",("Found wrong lock"));
  260.     }
  261.   }
  262.   DBUG_VOID_RETURN;
  263. }
  264. #else /* EXTRA_DEBUG */
  265. #define check_locks(A,B,C)
  266. #endif
  267. /* Initialize a lock */
  268. void thr_lock_init(THR_LOCK *lock)
  269. {
  270.   DBUG_ENTER("thr_lock_init");
  271.   bzero((char*) lock,sizeof(*lock));
  272.   VOID(pthread_mutex_init(&lock->mutex,MY_MUTEX_INIT_FAST));
  273.   lock->read.last= &lock->read.data;
  274.   lock->read_wait.last= &lock->read_wait.data;
  275.   lock->write_wait.last= &lock->write_wait.data;
  276.   lock->write.last= &lock->write.data;
  277.   pthread_mutex_lock(&THR_LOCK_lock); /* Add to locks in use */
  278.   lock->list.data=(void*) lock;
  279.   thr_lock_thread_list=list_add(thr_lock_thread_list,&lock->list);
  280.   pthread_mutex_unlock(&THR_LOCK_lock);
  281.   DBUG_VOID_RETURN;
  282. }
  283. void thr_lock_delete(THR_LOCK *lock)
  284. {
  285.   DBUG_ENTER("thr_lock_delete");
  286.   VOID(pthread_mutex_destroy(&lock->mutex));
  287.   pthread_mutex_lock(&THR_LOCK_lock);
  288.   thr_lock_thread_list=list_delete(thr_lock_thread_list,&lock->list);
  289.   pthread_mutex_unlock(&THR_LOCK_lock);
  290.   DBUG_VOID_RETURN;
  291. }
  292. /* Initialize a lock instance */
  293. void thr_lock_data_init(THR_LOCK *lock,THR_LOCK_DATA *data, void *param)
  294. {
  295.   data->lock=lock;
  296.   data->type=TL_UNLOCK;
  297.   data->thread=pthread_self();
  298.   data->thread_id=my_thread_id(); /* for debugging */
  299.   data->status_param=param;
  300.   data->cond=0;
  301. }
  302. static inline my_bool have_old_read_lock(THR_LOCK_DATA *data,pthread_t thread)
  303. {
  304.   for ( ; data ; data=data->next)
  305.   {
  306.     if ((pthread_equal(data->thread,thread)))
  307.       return 1; /* Already locked by thread */
  308.   }
  309.   return 0;
  310. }
  311. static inline my_bool have_specific_lock(THR_LOCK_DATA *data,
  312.  enum thr_lock_type type)
  313. {
  314.   for ( ; data ; data=data->next)
  315.   {
  316.     if (data->type == type)
  317.       return 1;
  318.   }
  319.   return 0;
  320. }
  321. static my_bool wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
  322.      my_bool in_wait_list)
  323. {
  324.   pthread_cond_t *cond=get_cond();
  325.   struct st_my_thread_var *thread_var=my_thread_var;
  326.   int result;
  327.   if (!in_wait_list)
  328.   {
  329.     (*wait->last)=data; /* Wait for lock */
  330.     data->prev= wait->last;
  331.     wait->last= &data->next;
  332.   }
  333.   /* Set up control struct to allow others to abort locks */
  334.   thread_var->current_mutex= &data->lock->mutex;
  335.   thread_var->current_cond=  cond;
  336.   data->cond=cond;
  337.   while (!thread_var->abort || in_wait_list)
  338.   {
  339.     pthread_cond_wait(cond,&data->lock->mutex);
  340.     if (data->cond != cond)
  341.       break;
  342.   }
  343.   if (data->cond || data->type == TL_UNLOCK)
  344.   {
  345.     if (data->cond) /* aborted */
  346.     {
  347.       if (((*data->prev)=data->next)) /* remove from wait-list */
  348. data->next->prev= data->prev;
  349.       else
  350. wait->last=data->prev;
  351.     }
  352.     data->type=TL_UNLOCK; /* No lock */
  353.     result=1; /* Didn't get lock */
  354.     check_locks(data->lock,"failed wait_for_lock",0);
  355.   }
  356.   else
  357.   {
  358.     result=0;
  359.     statistic_increment(locks_waited, &THR_LOCK_lock);
  360.     if (data->lock->get_status)
  361.       (*data->lock->get_status)(data->status_param);
  362.     check_locks(data->lock,"got wait_for_lock",0);
  363.   }
  364.   pthread_mutex_unlock(&data->lock->mutex);
  365.   /* The following must be done after unlock of lock->mutex */
  366.   pthread_mutex_lock(&thread_var->mutex);
  367.   thread_var->current_mutex= 0;
  368.   thread_var->current_cond=  0;
  369.   pthread_mutex_unlock(&thread_var->mutex);
  370.   return result;
  371. }
  372. int thr_lock(THR_LOCK_DATA *data,enum thr_lock_type lock_type)
  373. {
  374.   THR_LOCK *lock=data->lock;
  375.   int result=0;
  376.   DBUG_ENTER("thr_lock");
  377.   data->next=0;
  378.   data->cond=0; /* safety */
  379.   data->type=lock_type;
  380.   data->thread=pthread_self(); /* Must be reset ! */
  381.   data->thread_id=my_thread_id(); /* Must be reset ! */
  382.   VOID(pthread_mutex_lock(&lock->mutex));
  383.   DBUG_PRINT("lock",("data: 0x%lx  thread: %ld  lock: 0x%lx  type: %d",
  384.       data,data->thread_id,lock,(int) lock_type));
  385.   check_locks(lock,(uint) lock_type <= (uint) TL_READ_NO_INSERT ?
  386.       "enter read_lock" : "enter write_lock",0);
  387.   if ((int) lock_type <= (int) TL_READ_NO_INSERT)
  388.   {
  389.     /* Request for READ lock */
  390.     if (lock->write.data)
  391.     {
  392.       /* We can allow a read lock even if there is already a write lock
  393.  on the table in one the following cases:
  394.  - This thread alread have a write lock on the table
  395.  - The write lock is TL_WRITE_ALLOW_READ or TL_WRITE_DELAYED
  396.            and the read lock is TL_READ_HIGH_PRIORITY or TL_READ
  397.          - The write lock is TL_WRITE_CONCURRENT_INSERT or TL_WRITE_ALLOW_WRITE
  398.    and the read lock is not TL_READ_NO_INSERT
  399.       */
  400.       DBUG_PRINT("lock",("write locked by thread: %ld",
  401.  lock->write.data->thread_id));
  402.       if (pthread_equal(data->thread,lock->write.data->thread) ||
  403.   (lock->write.data->type <= TL_WRITE_DELAYED &&
  404.    (((int) lock_type <= (int) TL_READ_HIGH_PRIORITY) ||
  405.     (lock->write.data->type != TL_WRITE_CONCURRENT_INSERT &&
  406.      lock->write.data->type != TL_WRITE_ALLOW_READ))))
  407.       { /* Already got a write lock */
  408. (*lock->read.last)=data; /* Add to running FIFO */
  409. data->prev=lock->read.last;
  410. lock->read.last= &data->next;
  411. if ((int) lock_type == (int) TL_READ_NO_INSERT)
  412.   lock->read_no_write_count++;
  413. check_locks(lock,"read lock with old write lock",0);
  414. if (lock->get_status)
  415.   (*lock->get_status)(data->status_param);
  416. statistic_increment(locks_immediate,&THR_LOCK_lock);
  417. goto end;
  418.       }
  419.       if (lock->write.data->type == TL_WRITE_ONLY)
  420.       {
  421. /* We are not allowed to get a READ lock in this case */
  422. data->type=TL_UNLOCK;
  423. result=1; /* Can't wait for this one */
  424. goto end;
  425.       }
  426.     }
  427.     else if (!lock->write_wait.data ||
  428.      lock->write_wait.data->type <= TL_WRITE_LOW_PRIORITY ||
  429.      lock_type == TL_READ_HIGH_PRIORITY ||
  430.      have_old_read_lock(lock->read.data,data->thread))
  431.     { /* No important write-locks */
  432.       (*lock->read.last)=data; /* Add to running FIFO */
  433.       data->prev=lock->read.last;
  434.       lock->read.last= &data->next;
  435.       if (lock->get_status)
  436. (*lock->get_status)(data->status_param);
  437.       if ((int) lock_type == (int) TL_READ_NO_INSERT)
  438. lock->read_no_write_count++;
  439.       check_locks(lock,"read lock with no write locks",0);
  440.       statistic_increment(locks_immediate,&THR_LOCK_lock);
  441.       goto end;
  442.     }
  443.     /* Can't get lock yet;  Wait for it */
  444.     DBUG_RETURN(wait_for_lock(&lock->read_wait,data,0));
  445.   }
  446.   else /* Request for WRITE lock */
  447.   {
  448.     if (lock_type == TL_WRITE_DELAYED)
  449.     {
  450.       if (lock->write.data && lock->write.data->type == TL_WRITE_ONLY)
  451.       {
  452. data->type=TL_UNLOCK;
  453. result=1; /* Can't wait for this one */
  454. goto end;
  455.       }
  456.       /*
  457. if there is a TL_WRITE_ALLOW_READ lock, we have to wait for a lock
  458. (TL_WRITE_ALLOW_READ is used for ALTER TABLE in MySQL)
  459.       */
  460.       if ((!lock->write.data ||
  461.    lock->write.data->type != TL_WRITE_ALLOW_READ) &&
  462.   !have_specific_lock(lock->write_wait.data,TL_WRITE_ALLOW_READ) &&
  463.   (lock->write.data || lock->read.data))
  464.       {
  465. /* Add delayed write lock to write_wait queue, and return at once */
  466. (*lock->write_wait.last)=data;
  467. data->prev=lock->write_wait.last;
  468. lock->write_wait.last= &data->next;
  469. data->cond=get_cond();
  470. if (lock->get_status)
  471.   (*lock->get_status)(data->status_param);
  472. statistic_increment(locks_immediate,&THR_LOCK_lock);
  473. goto end;
  474.       }
  475.     }
  476.     else if (lock_type == TL_WRITE_CONCURRENT_INSERT && ! lock->check_status)
  477.       data->type=lock_type= thr_upgraded_concurrent_insert_lock;
  478.     if (lock->write.data) /* If there is a write lock */
  479.     {
  480.       if (lock->write.data->type == TL_WRITE_ONLY)
  481.       {
  482. /* We are not allowed to get a lock in this case */
  483. data->type=TL_UNLOCK;
  484. result=1; /* Can't wait for this one */
  485. goto end;
  486.       }
  487.       /*
  488. The following test will not work if the old lock was a
  489. TL_WRITE_ALLOW_WRITE, TL_WRITE_ALLOW_READ or TL_WRITE_DELAYED in
  490. the same thread, but this will never happen within MySQL.
  491.       */
  492.       if (pthread_equal(data->thread,lock->write.data->thread) ||
  493.   (lock_type == TL_WRITE_ALLOW_WRITE &&
  494.    !lock->write_wait.data &&
  495.    lock->write.data->type == TL_WRITE_ALLOW_WRITE))
  496.       {
  497. /*
  498.           We have already got a write lock or all locks are
  499.           TL_WRITE_ALLOW_WRITE
  500.         */
  501.         DBUG_PRINT("info", ("write_wait.data: 0x%lx  old_type: %d",
  502.                             (ulong) lock->write_wait.data,
  503.                             lock->write.data->type));
  504. (*lock->write.last)=data; /* Add to running fifo */
  505. data->prev=lock->write.last;
  506. lock->write.last= &data->next;
  507. check_locks(lock,"second write lock",0);
  508. if (data->lock->get_status)
  509.   (*data->lock->get_status)(data->status_param);
  510. statistic_increment(locks_immediate,&THR_LOCK_lock);
  511. goto end;
  512.       }
  513.       DBUG_PRINT("lock",("write locked by thread: %ld",
  514.  lock->write.data->thread_id));
  515.     }
  516.     else
  517.     {
  518.       DBUG_PRINT("info", ("write_wait.data: 0x%lx",
  519.                           (ulong) lock->write_wait.data));
  520.       if (!lock->write_wait.data)
  521.       { /* no scheduled write locks */
  522. if (lock_type == TL_WRITE_CONCURRENT_INSERT &&
  523.     (*lock->check_status)(data->status_param))
  524.   data->type=lock_type= thr_upgraded_concurrent_insert_lock;
  525. if (!lock->read.data ||
  526.     (lock_type <= TL_WRITE_DELAYED &&
  527.      ((lock_type != TL_WRITE_CONCURRENT_INSERT &&
  528.        lock_type != TL_WRITE_ALLOW_WRITE) ||
  529.       !lock->read_no_write_count)))
  530. {
  531.   (*lock->write.last)=data; /* Add as current write lock */
  532.   data->prev=lock->write.last;
  533.   lock->write.last= &data->next;
  534.   if (data->lock->get_status)
  535.     (*data->lock->get_status)(data->status_param);
  536.   check_locks(lock,"only write lock",0);
  537.   statistic_increment(locks_immediate,&THR_LOCK_lock);
  538.   goto end;
  539. }
  540.       }
  541.       DBUG_PRINT("lock",("write locked by thread: %ld, type: %ld",
  542.  lock->read.data->thread_id,data->type));
  543.     }
  544.     DBUG_RETURN(wait_for_lock(&lock->write_wait,data,0));
  545.   }
  546. end:
  547.   pthread_mutex_unlock(&lock->mutex);
  548.   DBUG_RETURN(result);
  549. }
  550. static inline void free_all_read_locks(THR_LOCK *lock,
  551.        bool using_concurrent_insert)
  552. {
  553.   THR_LOCK_DATA *data=lock->read_wait.data;
  554.   check_locks(lock,"before freeing read locks",1);
  555.   /* move all locks from read_wait list to read list */
  556.   (*lock->read.last)=data;
  557.   data->prev=lock->read.last;
  558.   lock->read.last=lock->read_wait.last;
  559.   /* Clear read_wait list */
  560.   lock->read_wait.last= &lock->read_wait.data;
  561.   do
  562.   {
  563.     pthread_cond_t *cond=data->cond;
  564.     if ((int) data->type == (int) TL_READ_NO_INSERT)
  565.     {
  566.       if (using_concurrent_insert)
  567.       {
  568. /*
  569.   We can't free this lock; 
  570.   Link lock away from read chain back into read_wait chain
  571. */
  572. if (((*data->prev)=data->next))
  573.   data->next->prev=data->prev;
  574. else
  575.   lock->read.last=data->prev;
  576. *lock->read_wait.last= data;
  577. data->prev= lock->read_wait.last;
  578. lock->read_wait.last= &data->next;
  579. continue;
  580.       }
  581.       lock->read_no_write_count++;
  582.     }      
  583.     DBUG_PRINT("lock",("giving read lock to thread: %ld",
  584.        data->thread_id));
  585.     data->cond=0; /* Mark thread free */
  586.     VOID(pthread_cond_signal(cond));
  587.   } while ((data=data->next));
  588.   *lock->read_wait.last=0;
  589.   if (!lock->read_wait.data)
  590.     lock->write_lock_count=0;
  591.   check_locks(lock,"after giving read locks",0);
  592. }
  593. /* Unlock lock and free next thread on same lock */
  594. void thr_unlock(THR_LOCK_DATA *data)
  595. {
  596.   THR_LOCK *lock=data->lock;
  597.   enum thr_lock_type lock_type=data->type;
  598.   DBUG_ENTER("thr_unlock");
  599.   DBUG_PRINT("lock",("data: 0x%lx  thread: %ld  lock: 0x%lx",
  600.      data,data->thread_id,lock));
  601.   pthread_mutex_lock(&lock->mutex);
  602.   check_locks(lock,"start of release lock",0);
  603.   if (((*data->prev)=data->next)) /* remove from lock-list */
  604.     data->next->prev= data->prev;
  605.   else if (lock_type <= TL_READ_NO_INSERT)
  606.     lock->read.last=data->prev;
  607.   else if (lock_type == TL_WRITE_DELAYED && data->cond)
  608.   {
  609.     /* This only happens in extreme circumstances when a 
  610.        write delayed lock that is waiting for a lock */
  611.     lock->write_wait.last=data->prev; /* Put it on wait queue */
  612.   }
  613.   else
  614.     lock->write.last=data->prev;
  615.   if (lock_type >= TL_WRITE_CONCURRENT_INSERT && lock->update_status)
  616.     (*lock->update_status)(data->status_param);
  617.   if (lock_type == TL_READ_NO_INSERT)
  618.     lock->read_no_write_count--;
  619.   data->type=TL_UNLOCK; /* Mark unlocked */
  620.   check_locks(lock,"after releasing lock",1);
  621.   if (!lock->write.data) /* If no active write locks */
  622.   {
  623.     data=lock->write_wait.data;
  624.     if (!lock->read.data) /* If no more locks in use */
  625.     {
  626.       /* Release write-locks with TL_WRITE or TL_WRITE_ONLY priority first */
  627.       if (data &&
  628.   (data->type != TL_WRITE_LOW_PRIORITY || !lock->read_wait.data ||
  629.    lock->read_wait.data->type < TL_READ_HIGH_PRIORITY))
  630.       {
  631. if (lock->write_lock_count++ > max_write_lock_count)
  632. {
  633.   /* Too many write locks in a row;  Release all waiting read locks */
  634.   lock->write_lock_count=0;
  635.   if (lock->read_wait.data)
  636.   {
  637.     DBUG_PRINT("info",("Freeing all read_locks because of max_write_lock_count"));
  638.     free_all_read_locks(lock,0);
  639.     goto end;
  640.   }
  641. }
  642. for (;;)
  643. {
  644.   if (((*data->prev)=data->next)) /* remove from wait-list */
  645.     data->next->prev= data->prev;
  646.   else
  647.     lock->write_wait.last=data->prev;
  648.   (*lock->write.last)=data; /* Put in execute list */
  649.   data->prev=lock->write.last;
  650.   data->next=0;
  651.   lock->write.last= &data->next;
  652.   if (data->type == TL_WRITE_CONCURRENT_INSERT &&
  653.       (*lock->check_status)(data->status_param))
  654.     data->type=TL_WRITE; /* Upgrade lock */
  655.   DBUG_PRINT("lock",("giving write lock of type %d to thread: %ld",
  656.      data->type,data->thread_id));
  657.   {
  658.     pthread_cond_t *cond=data->cond;
  659.     data->cond=0; /* Mark thread free */
  660.     VOID(pthread_cond_signal(cond)); /* Start waiting thread */
  661.   }
  662.   if (data->type != TL_WRITE_ALLOW_WRITE ||
  663.       !lock->write_wait.data ||
  664.       lock->write_wait.data->type != TL_WRITE_ALLOW_WRITE)
  665.     break;
  666.   data=lock->write_wait.data; /* Free this too */
  667. }
  668. if (data->type >= TL_WRITE_LOW_PRIORITY)
  669. {
  670.   check_locks(lock,"giving write lock",0);
  671.   pthread_mutex_unlock(&lock->mutex);
  672.   DBUG_VOID_RETURN;
  673. }
  674. /* Release possible read locks together with the write lock */
  675.       }
  676.       if (lock->read_wait.data)
  677. free_all_read_locks(lock,
  678.     data &&
  679.     (data->type == TL_WRITE_CONCURRENT_INSERT ||
  680.      data->type == TL_WRITE_ALLOW_WRITE));
  681.       else
  682.       {
  683. DBUG_PRINT("lock",("No waiting read locks to free"));
  684.       }
  685.     }
  686.     else if (data &&
  687.      (lock_type=data->type) <= TL_WRITE_DELAYED &&
  688.      ((lock_type != TL_WRITE_CONCURRENT_INSERT &&
  689.        lock_type != TL_WRITE_ALLOW_WRITE) ||
  690.       !lock->read_no_write_count))
  691.     {
  692.       /*
  693. For DELAYED, ALLOW_READ, WRITE_ALLOW_WRITE or CONCURRENT_INSERT locks
  694. start WRITE locks together with the READ locks
  695.       */
  696.       if (lock_type == TL_WRITE_CONCURRENT_INSERT &&
  697.   (*lock->check_status)(data->status_param))
  698.       {
  699. data->type=TL_WRITE; /* Upgrade lock */
  700. if (lock->read_wait.data)
  701.   free_all_read_locks(lock,0);
  702. goto end;
  703.       }
  704.       do {
  705. pthread_cond_t *cond=data->cond;
  706. if (((*data->prev)=data->next)) /* remove from wait-list */
  707.   data->next->prev= data->prev;
  708. else
  709.   lock->write_wait.last=data->prev;
  710. (*lock->write.last)=data; /* Put in execute list */
  711. data->prev=lock->write.last;
  712. lock->write.last= &data->next;
  713. data->next=0; /* Only one write lock */
  714. data->cond=0; /* Mark thread free */
  715. VOID(pthread_cond_signal(cond)); /* Start waiting thread */
  716.       } while (lock_type == TL_WRITE_ALLOW_WRITE &&
  717.        (data=lock->write_wait.data) &&
  718.        data->type == TL_WRITE_ALLOW_WRITE);
  719.       if (lock->read_wait.data)
  720. free_all_read_locks(lock,
  721.     (lock_type == TL_WRITE_CONCURRENT_INSERT ||
  722.      lock_type == TL_WRITE_ALLOW_WRITE));
  723.     }
  724.     else if (!data && lock->read_wait.data)
  725.       free_all_read_locks(lock,0);
  726.   }
  727. end:
  728.   check_locks(lock,"thr_unlock",0);
  729.   pthread_mutex_unlock(&lock->mutex);
  730.   DBUG_VOID_RETURN;
  731. }
  732. /*
  733. ** Get all locks in a specific order to avoid dead-locks
  734. ** Sort acording to lock position and put write_locks before read_locks if
  735. ** lock on same lock.
  736. */
  737. #define LOCK_CMP(A,B) ((byte*) (A->lock) - (uint) ((A)->type) < (byte*) (B->lock)- (uint) ((B)->type))
  738. static void sort_locks(THR_LOCK_DATA **data,uint count)
  739. {
  740.   THR_LOCK_DATA **pos,**end,**prev,*tmp;
  741.   /* Sort locks with insertion sort (fast because almost always few locks) */
  742.   for (pos=data+1,end=data+count; pos < end ; pos++)
  743.   {
  744.     tmp= *pos;
  745.     if (LOCK_CMP(tmp,pos[-1]))
  746.     {
  747.       prev=pos;
  748.       do {
  749. prev[0]=prev[-1];
  750.       } while (--prev != data && LOCK_CMP(tmp,prev[-1]));
  751.       prev[0]=tmp;
  752.     }
  753.   }
  754. }
  755. int thr_multi_lock(THR_LOCK_DATA **data,uint count)
  756. {
  757.   THR_LOCK_DATA **pos,**end;
  758.   DBUG_ENTER("thr_multi_lock");
  759.   DBUG_PRINT("lock",("data: 0x%lx  count: %d",data,count));
  760.   if (count > 1)
  761.     sort_locks(data,count);
  762.   /* lock everything */
  763.   for (pos=data,end=data+count; pos < end ; pos++)
  764.   {
  765.     if (thr_lock(*pos,(*pos)->type))
  766.     { /* Aborted */
  767.       thr_multi_unlock(data,(uint) (pos-data));
  768.       DBUG_RETURN(1);
  769.     }
  770. #ifdef MAIN
  771.     printf("Thread: %s  Got lock: 0x%lx  type: %dn",my_thread_name(),
  772.    (long) pos[0]->lock, pos[0]->type); fflush(stdout);
  773. #endif
  774.   }
  775.   /*
  776.     Ensure that all get_locks() have the same status
  777.     If we lock the same table multiple times, we must use the same
  778.     status_param!
  779.   */
  780. #if !defined(DONT_USE_RW_LOCKS)
  781.   if (count > 1)
  782.   {
  783.     THR_LOCK_DATA *last_lock= end[-1];
  784.     pos=end-1;
  785.     do
  786.     {
  787.       pos--;
  788.       if (last_lock->lock == (*pos)->lock &&
  789.   last_lock->lock->copy_status)
  790.       {
  791. if (last_lock->type <= TL_READ_NO_INSERT)
  792. {
  793.   THR_LOCK_DATA **read_lock;
  794.   /*
  795.     If we are locking the same table with read locks we must ensure
  796.     that all tables share the status of the last write lock or
  797.     the same read lock.
  798.   */
  799.   for (;
  800.        (*pos)->type <= TL_READ_NO_INSERT &&
  801.  pos != data &&
  802.  pos[-1]->lock == (*pos)->lock ;
  803.        pos--) ;
  804.   read_lock = pos+1;
  805.   do
  806.   {
  807.     (last_lock->lock->copy_status)((*read_lock)->status_param,
  808.    (*pos)->status_param);
  809.   } while (*(read_lock++) != last_lock);
  810.   last_lock= (*pos); /* Point at last write lock */
  811. }
  812. else
  813.   (*last_lock->lock->copy_status)((*pos)->status_param,
  814.   last_lock->status_param);
  815.       }
  816.       else
  817. last_lock=(*pos);
  818.     } while (pos != data);
  819.   }
  820. #endif
  821.   DBUG_RETURN(0);
  822. }
  823.   /* free all locks */
  824. void thr_multi_unlock(THR_LOCK_DATA **data,uint count)
  825. {
  826.   THR_LOCK_DATA **pos,**end;
  827.   DBUG_ENTER("thr_multi_unlock");
  828.   DBUG_PRINT("lock",("data: 0x%lx  count: %d",data,count));
  829.   for (pos=data,end=data+count; pos < end ; pos++)
  830.   {
  831. #ifdef MAIN
  832.     printf("Thread: %s  Rel lock: 0x%lx  type: %dn",
  833.    my_thread_name(), (long) pos[0]->lock, pos[0]->type);
  834.     fflush(stdout);
  835. #endif
  836.     if ((*pos)->type != TL_UNLOCK)
  837.       thr_unlock(*pos);
  838.     else
  839.     {
  840.       DBUG_PRINT("lock",("Free lock: data: 0x%lx  thread: %ld  lock: 0x%lx",
  841.  *pos,(*pos)->thread_id,(*pos)->lock));
  842.     }
  843.   }
  844.   DBUG_VOID_RETURN;
  845. }
  846. /*
  847.   Abort all threads waiting for a lock. The lock will be upgraded to
  848.   TL_WRITE_ONLY to abort any new accesses to the lock
  849. */
  850. void thr_abort_locks(THR_LOCK *lock)
  851. {
  852.   THR_LOCK_DATA *data;
  853.   DBUG_ENTER("thr_abort_locks");
  854.   pthread_mutex_lock(&lock->mutex);
  855.   for (data=lock->read_wait.data; data ; data=data->next)
  856.   {
  857.     data->type=TL_UNLOCK; /* Mark killed */
  858.     pthread_cond_signal(data->cond);
  859.     data->cond=0; /* Removed from list */
  860.   }
  861.   for (data=lock->write_wait.data; data ; data=data->next)
  862.   {
  863.     data->type=TL_UNLOCK;
  864.     pthread_cond_signal(data->cond);
  865.     data->cond=0;
  866.   }
  867.   lock->read_wait.last= &lock->read_wait.data;
  868.   lock->write_wait.last= &lock->write_wait.data;
  869.   lock->read_wait.data=lock->write_wait.data=0;
  870.   if (lock->write.data)
  871.     lock->write.data->type=TL_WRITE_ONLY;
  872.   pthread_mutex_unlock(&lock->mutex);
  873.   DBUG_VOID_RETURN;
  874. }
  875. /*
  876.   Abort all locks for specific table/thread combination
  877.   This is used to abort all locks for a specific thread
  878. */
  879. my_bool thr_abort_locks_for_thread(THR_LOCK *lock, pthread_t thread)
  880. {
  881.   THR_LOCK_DATA *data;
  882.   my_bool found= FALSE;
  883.   DBUG_ENTER("thr_abort_locks_for_thread");
  884.   pthread_mutex_lock(&lock->mutex);
  885.   for (data= lock->read_wait.data; data ; data= data->next)
  886.   {
  887.     if (pthread_equal(thread, data->thread))
  888.     {
  889.       DBUG_PRINT("info",("Aborting read-wait lock"));
  890.       data->type= TL_UNLOCK; /* Mark killed */
  891.       found= TRUE;
  892.       pthread_cond_signal(data->cond);
  893.       data->cond= 0; /* Removed from list */
  894.       if (((*data->prev)= data->next))
  895. data->next->prev= data->prev;
  896.       else
  897. lock->read_wait.last= data->prev;
  898.     }
  899.   }
  900.   for (data= lock->write_wait.data; data ; data= data->next)
  901.   {
  902.     if (pthread_equal(thread, data->thread))
  903.     {
  904.       DBUG_PRINT("info",("Aborting write-wait lock"));
  905.       data->type= TL_UNLOCK;
  906.       found= TRUE;
  907.       pthread_cond_signal(data->cond);
  908.       data->cond= 0;
  909.       if (((*data->prev)= data->next))
  910. data->next->prev= data->prev;
  911.       else
  912. lock->write_wait.last= data->prev;
  913.     }
  914.   }
  915.   pthread_mutex_unlock(&lock->mutex);
  916.   DBUG_RETURN(found);
  917. }
  918. /* Upgrade a WRITE_DELAY lock to a WRITE_LOCK */
  919. my_bool thr_upgrade_write_delay_lock(THR_LOCK_DATA *data)
  920. {
  921.   THR_LOCK *lock=data->lock;
  922.   DBUG_ENTER("thr_upgrade_write_delay_lock");
  923.   pthread_mutex_lock(&lock->mutex);
  924.   if (data->type == TL_UNLOCK || data->type >= TL_WRITE_LOW_PRIORITY)
  925.   {
  926.     pthread_mutex_unlock(&lock->mutex);
  927.     DBUG_RETURN(data->type == TL_UNLOCK); /* Test if Aborted */
  928.   }
  929.   check_locks(lock,"before upgrading lock",0);
  930.   /* TODO:  Upgrade to TL_WRITE_CONCURRENT_INSERT in some cases */
  931.   data->type=TL_WRITE; /* Upgrade lock */
  932.   /* Check if someone has given us the lock */
  933.   if (!data->cond)
  934.   {
  935.     if (!lock->read.data) /* No read locks */
  936.     { /* We have the lock */
  937.       if (data->lock->get_status)
  938. (*data->lock->get_status)(data->status_param);
  939.       pthread_mutex_unlock(&lock->mutex);
  940.       DBUG_RETURN(0);
  941.     }
  942.     if (((*data->prev)=data->next)) /* remove from lock-list */
  943.       data->next->prev= data->prev;
  944.     else
  945.       lock->write.last=data->prev;
  946.     if ((data->next=lock->write_wait.data)) /* Put first in lock_list */
  947.       data->next->prev= &data->next;
  948.     else
  949.       lock->write_wait.last= &data->next;
  950.     data->prev= &lock->write_wait.data;
  951.     lock->write_wait.data=data;
  952.     check_locks(lock,"upgrading lock",0);
  953.   }
  954.   else
  955.   {
  956.     check_locks(lock,"waiting for lock",0);
  957.   }
  958.   DBUG_RETURN(wait_for_lock(&lock->write_wait,data,1));
  959. }
  960. /* downgrade a WRITE lock to a WRITE_DELAY lock if there is pending locks */
  961. my_bool thr_reschedule_write_lock(THR_LOCK_DATA *data)
  962. {
  963.   THR_LOCK *lock=data->lock;
  964.   DBUG_ENTER("thr_reschedule_write_lock");
  965.   pthread_mutex_lock(&lock->mutex);
  966.   if (!lock->read_wait.data) /* No waiting read locks */
  967.   {
  968.     pthread_mutex_unlock(&lock->mutex);
  969.     DBUG_RETURN(0);
  970.   }
  971.   data->type=TL_WRITE_DELAYED;
  972.   if (lock->update_status)
  973.     (*lock->update_status)(data->status_param);
  974.   if (((*data->prev)=data->next)) /* remove from lock-list */
  975.     data->next->prev= data->prev;
  976.   else
  977.     lock->write.last=data->prev;
  978.   if ((data->next=lock->write_wait.data)) /* Put first in lock_list */
  979.     data->next->prev= &data->next;
  980.   else
  981.     lock->write_wait.last= &data->next;
  982.   data->prev= &lock->write_wait.data;
  983.   data->cond=get_cond(); /* This was zero */
  984.   lock->write_wait.data=data;
  985.   free_all_read_locks(lock,0);
  986.   pthread_mutex_unlock(&lock->mutex);
  987.   DBUG_RETURN(thr_upgrade_write_delay_lock(data));
  988. }
  989. #include <my_sys.h>
  990. static void thr_print_lock(const char* name,struct st_lock_list *list)
  991. {
  992.   THR_LOCK_DATA *data,**prev;
  993.   uint count=0;
  994.   if (list->data)
  995.   {
  996.     printf("%-10s: ",name);
  997.     prev= &list->data;
  998.     for (data=list->data; data && count++ < MAX_LOCKS ; data=data->next)
  999.     {
  1000.       printf("0x%lx (%lu:%d); ",(ulong) data,data->thread_id,(int) data->type);
  1001.       if (data->prev != prev)
  1002. printf("nWarning: prev didn't point at previous lockn");
  1003.       prev= &data->next;
  1004.     }
  1005.     puts("");
  1006.     if (prev != list->last)
  1007.       printf("Warning: last didn't point at last lockn");
  1008.   }
  1009. }
  1010. void thr_print_locks(void)
  1011. {
  1012.   LIST *list;
  1013.   uint count=0;
  1014.   pthread_mutex_lock(&THR_LOCK_lock);
  1015.   puts("Current locks:");
  1016.   for (list= thr_lock_thread_list; list && count++ < MAX_THREADS;
  1017.        list= list_rest(list))
  1018.   {
  1019.     THR_LOCK *lock=(THR_LOCK*) list->data;
  1020.     VOID(pthread_mutex_lock(&lock->mutex));
  1021.     printf("lock: 0x%lx:",(ulong) lock);
  1022.     if ((lock->write_wait.data || lock->read_wait.data) &&
  1023. (! lock->read.data && ! lock->write.data))
  1024.       printf(" WARNING: ");
  1025.     if (lock->write.data)
  1026.       printf(" write");
  1027.     if (lock->write_wait.data)
  1028.       printf(" write_wait");
  1029.     if (lock->read.data)
  1030.       printf(" read");
  1031.     if (lock->read_wait.data)
  1032.       printf(" read_wait");
  1033.     puts("");
  1034.     thr_print_lock("write",&lock->write);
  1035.     thr_print_lock("write_wait",&lock->write_wait);
  1036.     thr_print_lock("read",&lock->read);
  1037.     thr_print_lock("read_wait",&lock->read_wait);
  1038.     VOID(pthread_mutex_unlock(&lock->mutex));
  1039.     puts("");
  1040.   }
  1041.   fflush(stdout);
  1042.   pthread_mutex_unlock(&THR_LOCK_lock);
  1043. }
  1044. #endif /* THREAD */
  1045. /*****************************************************************************
  1046. ** Test of thread locks
  1047. ****************************************************************************/
  1048. #ifdef MAIN
  1049. #ifdef THREAD
  1050. struct st_test {
  1051.   uint lock_nr;
  1052.   enum thr_lock_type lock_type;
  1053. };
  1054. THR_LOCK locks[5]; /* 4 locks */
  1055. struct st_test test_0[] = {{0,TL_READ}}; /* One lock */
  1056. struct st_test test_1[] = {{0,TL_READ},{0,TL_WRITE}}; /* Read and write lock of lock 0 */
  1057. struct st_test test_2[] = {{1,TL_WRITE},{0,TL_READ},{2,TL_READ}};
  1058. struct st_test test_3[] = {{2,TL_WRITE},{1,TL_READ},{0,TL_READ}}; /* Deadlock with test_2 ? */
  1059. struct st_test test_4[] = {{0,TL_WRITE},{0,TL_READ},{0,TL_WRITE},{0,TL_READ}};
  1060. struct st_test test_5[] = {{0,TL_READ},{1,TL_READ},{2,TL_READ},{3,TL_READ}}; /* Many reads */
  1061. struct st_test test_6[] = {{0,TL_WRITE},{1,TL_WRITE},{2,TL_WRITE},{3,TL_WRITE}}; /* Many writes */
  1062. struct st_test test_7[] = {{3,TL_READ}};
  1063. struct st_test test_8[] = {{1,TL_READ_NO_INSERT},{2,TL_READ_NO_INSERT},{3,TL_READ_NO_INSERT}}; /* Should be quick */
  1064. struct st_test test_9[] = {{4,TL_READ_HIGH_PRIORITY}};
  1065. struct st_test test_10[] ={{4,TL_WRITE}};
  1066. struct st_test test_11[] = {{0,TL_WRITE_LOW_PRIORITY},{1,TL_WRITE_LOW_PRIORITY},{2,TL_WRITE_LOW_PRIORITY},{3,TL_WRITE_LOW_PRIORITY}}; /* Many writes */
  1067. struct st_test test_12[] = {{0,TL_WRITE_ALLOW_READ},{1,TL_WRITE_ALLOW_READ},{2,TL_WRITE_ALLOW_READ},{3,TL_WRITE_ALLOW_READ}}; /* Many writes */
  1068. struct st_test test_13[] = {{0,TL_WRITE_CONCURRENT_INSERT},{1,TL_WRITE_CONCURRENT_INSERT},{2,TL_WRITE_CONCURRENT_INSERT},{3,TL_WRITE_CONCURRENT_INSERT}};
  1069. struct st_test test_14[] = {{0,TL_WRITE_CONCURRENT_INSERT},{1,TL_READ}};
  1070. struct st_test test_15[] = {{0,TL_WRITE_ALLOW_WRITE},{1,TL_READ}};
  1071. struct st_test test_16[] = {{0,TL_WRITE_ALLOW_WRITE},{1,TL_WRITE_ALLOW_WRITE}};
  1072. struct st_test *tests[] = {test_0,test_1,test_2,test_3,test_4,test_5,test_6,
  1073.    test_7,test_8,test_9,test_10,test_11,test_12,
  1074.    test_13,test_14,test_15,test_16};
  1075. int lock_counts[]= {sizeof(test_0)/sizeof(struct st_test),
  1076.     sizeof(test_1)/sizeof(struct st_test),
  1077.     sizeof(test_2)/sizeof(struct st_test),
  1078.     sizeof(test_3)/sizeof(struct st_test),
  1079.     sizeof(test_4)/sizeof(struct st_test),
  1080.     sizeof(test_5)/sizeof(struct st_test),
  1081.     sizeof(test_6)/sizeof(struct st_test),
  1082.     sizeof(test_7)/sizeof(struct st_test),
  1083.     sizeof(test_8)/sizeof(struct st_test),
  1084.     sizeof(test_9)/sizeof(struct st_test),
  1085.     sizeof(test_10)/sizeof(struct st_test),
  1086.     sizeof(test_11)/sizeof(struct st_test),
  1087.     sizeof(test_12)/sizeof(struct st_test),
  1088.     sizeof(test_13)/sizeof(struct st_test),
  1089.     sizeof(test_14)/sizeof(struct st_test),
  1090.     sizeof(test_15)/sizeof(struct st_test),
  1091.     sizeof(test_16)/sizeof(struct st_test)
  1092. };
  1093. static pthread_cond_t COND_thread_count;
  1094. static pthread_mutex_t LOCK_thread_count;
  1095. static uint thread_count;
  1096. static ulong sum=0;
  1097. #define MAX_LOCK_COUNT 8
  1098. /* The following functions is for WRITE_CONCURRENT_INSERT */
  1099. static void test_get_status(void* param __attribute__((unused)))
  1100. {
  1101. }
  1102. static void test_copy_status(void* to __attribute__((unused)) ,
  1103.      void *from __attribute__((unused)))
  1104. {
  1105. }
  1106. static my_bool test_check_status(void* param __attribute__((unused)))
  1107. {
  1108.   return 0;
  1109. }
  1110. static void *test_thread(void *arg)
  1111. {
  1112.   int i,j,param=*((int*) arg);
  1113.   THR_LOCK_DATA data[MAX_LOCK_COUNT];
  1114.   THR_LOCK_DATA *multi_locks[MAX_LOCK_COUNT];
  1115.   my_thread_init();
  1116.   printf("Thread %s (%d) startedn",my_thread_name(),param); fflush(stdout);
  1117.   for (i=0; i < lock_counts[param] ; i++)
  1118.     thr_lock_data_init(locks+tests[param][i].lock_nr,data+i,NULL);
  1119.   for (j=1 ; j < 10 ; j++) /* try locking 10 times */
  1120.   {
  1121.     for (i=0; i < lock_counts[param] ; i++)
  1122.     { /* Init multi locks */
  1123.       multi_locks[i]= &data[i];
  1124.       data[i].type= tests[param][i].lock_type;
  1125.     }
  1126.     thr_multi_lock(multi_locks,lock_counts[param]);
  1127.     pthread_mutex_lock(&LOCK_thread_count);
  1128.     {
  1129.       int tmp=rand() & 7; /* Do something from 0-2 sec */
  1130.       if (tmp == 0)
  1131. sleep(1);
  1132.       else if (tmp == 1)
  1133. sleep(2);
  1134.       else
  1135.       {
  1136. ulong k;
  1137. for (k=0 ; k < (ulong) (tmp-2)*100000L ; k++)
  1138.   sum+=k;
  1139.       }
  1140.     }
  1141.     pthread_mutex_unlock(&LOCK_thread_count);
  1142.     thr_multi_unlock(multi_locks,lock_counts[param]);
  1143.   }
  1144.   printf("Thread %s (%d) endedn",my_thread_name(),param); fflush(stdout);
  1145.   thr_print_locks();
  1146.   pthread_mutex_lock(&LOCK_thread_count);
  1147.   thread_count--;
  1148.   VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
  1149.   pthread_mutex_unlock(&LOCK_thread_count);
  1150.   free((gptr) arg);
  1151.   return 0;
  1152. }
  1153. int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
  1154. {
  1155.   pthread_t tid;
  1156.   pthread_attr_t thr_attr;
  1157.   int i,*param,error;
  1158.   MY_INIT(argv[0]);
  1159.   if (argc > 1 && argv[1][0] == '-' && argv[1][1] == '#')
  1160.     DBUG_PUSH(argv[1]+2);
  1161.   printf("Main thread: %sn",my_thread_name());
  1162.   if ((error=pthread_cond_init(&COND_thread_count,NULL)))
  1163.   {
  1164.     fprintf(stderr,"Got error: %d from pthread_cond_init (errno: %d)",
  1165.     error,errno);
  1166.     exit(1);
  1167.   }
  1168.   if ((error=pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST)))
  1169.   {
  1170.     fprintf(stderr,"Got error: %d from pthread_cond_init (errno: %d)",
  1171.     error,errno);
  1172.     exit(1);
  1173.   }
  1174.   for (i=0 ; i < (int) array_elements(locks) ; i++)
  1175.   {
  1176.     thr_lock_init(locks+i);
  1177.     locks[i].check_status= test_check_status;
  1178.     locks[i].update_status=test_get_status;
  1179.     locks[i].copy_status=  test_copy_status;
  1180.     locks[i].get_status=   test_get_status;
  1181.   }
  1182.   if ((error=pthread_attr_init(&thr_attr)))
  1183.   {
  1184.     fprintf(stderr,"Got error: %d from pthread_attr_init (errno: %d)",
  1185.     error,errno);
  1186.     exit(1);
  1187.   }
  1188.   if ((error=pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED)))
  1189.   {
  1190.     fprintf(stderr,
  1191.     "Got error: %d from pthread_attr_setdetachstate (errno: %d)",
  1192.     error,errno);
  1193.     exit(1);
  1194.   }
  1195. #ifndef pthread_attr_setstacksize /* void return value */
  1196.   if ((error=pthread_attr_setstacksize(&thr_attr,65536L)))
  1197.   {
  1198.     fprintf(stderr,"Got error: %d from pthread_attr_setstacksize (errno: %d)",
  1199.     error,errno);
  1200.     exit(1);
  1201.   }
  1202. #endif
  1203. #ifdef HAVE_THR_SETCONCURRENCY
  1204.   VOID(thr_setconcurrency(2));
  1205. #endif
  1206.   for (i=0 ; i < (int) array_elements(lock_counts) ; i++)
  1207.   {
  1208.     param=(int*) malloc(sizeof(int));
  1209.     *param=i;
  1210.     if ((error=pthread_mutex_lock(&LOCK_thread_count)))
  1211.     {
  1212.       fprintf(stderr,"Got error: %d from pthread_mutex_lock (errno: %d)",
  1213.       error,errno);
  1214.       exit(1);
  1215.     }
  1216.     if ((error=pthread_create(&tid,&thr_attr,test_thread,(void*) param)))
  1217.     {
  1218.       fprintf(stderr,"Got error: %d from pthread_create (errno: %d)n",
  1219.       error,errno);
  1220.       pthread_mutex_unlock(&LOCK_thread_count);
  1221.       exit(1);
  1222.     }
  1223.     thread_count++;
  1224.     pthread_mutex_unlock(&LOCK_thread_count);
  1225.   }
  1226.   pthread_attr_destroy(&thr_attr);
  1227.   if ((error=pthread_mutex_lock(&LOCK_thread_count)))
  1228.     fprintf(stderr,"Got error: %d from pthread_mutex_lockn",error);
  1229.   while (thread_count)
  1230.   {
  1231.     if ((error=pthread_cond_wait(&COND_thread_count,&LOCK_thread_count)))
  1232.       fprintf(stderr,"Got error: %d from pthread_cond_waitn",error);
  1233.   }
  1234.   if ((error=pthread_mutex_unlock(&LOCK_thread_count)))
  1235.     fprintf(stderr,"Got error: %d from pthread_mutex_unlockn",error);
  1236.   for (i=0 ; i < (int) array_elements(locks) ; i++)
  1237.     thr_lock_delete(locks+i);
  1238. #ifdef EXTRA_DEBUG
  1239.   if (found_errors)
  1240.     printf("Got %d warningsn",found_errors);
  1241.   else
  1242. #endif
  1243.     printf("Test succeededn");
  1244.   return 0;
  1245. }
  1246. #else /* THREAD */
  1247. int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
  1248. {
  1249.   printf("thr_lock disabled because we are not using threadsn");
  1250.   exit(1);
  1251. }
  1252. #endif /* THREAD */
  1253. #endif /* MAIN */