← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/thr_lock.c

  • Committer: Monty Taylor
  • Date: 2008-09-15 00:46:33 UTC
  • mfrom: (383.1.55 client-split)
  • Revision ID: monty@inaugust.com-20080915004633-fmjw27fi41cxs35w
Merged from client-split.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/thr_lock.c
26
26
 
27
27
TL_READ                 # Low priority read
28
28
TL_READ_WITH_SHARED_LOCKS
 
29
TL_READ_HIGH_PRIORITY   # High priority read
29
30
TL_READ_NO_INSERT       # Read without concurrent inserts
30
31
TL_WRITE_ALLOW_WRITE    # Write lock that allows other writers
31
32
TL_WRITE_ALLOW_READ     # Write lock, but allow reading
32
33
TL_WRITE_CONCURRENT_INSERT
33
34
                        # Insert that can be mixed when selects
 
35
TL_WRITE_DELAYED        # Used by delayed insert
 
36
                        # Allows lower locks to take over
 
37
TL_WRITE_LOW_PRIORITY   # Low priority write
34
38
TL_WRITE                # High priority write
35
39
TL_WRITE_ONLY           # High priority write
36
40
                        # Abort all new lock request with an error
46
50
should put a pointer to the following functions in the lock structure:
47
51
(If the pointer is zero (default), the function is not called)
48
52
 
 
53
check_status:
 
54
         Before giving a lock of type TL_WRITE_CONCURRENT_INSERT,
 
55
         we check if this function exists and returns 0.
 
56
         If not, then the lock is upgraded to TL_WRITE_LOCK
 
57
         In MyISAM this is a simple check if the insert can be done
 
58
         at the end of the datafile.
 
59
update_status:
 
60
        Before a write lock is released, this function is called.
 
61
        In MyISAM this functions updates the count and length of the datafile
 
62
get_status:
 
63
        When one gets a lock this functions is called.
 
64
        In MyISAM this stores the number of rows and size of the datafile
 
65
        for concurrent reads.
49
66
 
50
67
The lock algorithm allows one to have one TL_WRITE_ALLOW_READ,
51
 
TL_WRITE_CONCURRENT_INSERT lock at the same time as multiple read locks.
 
68
TL_WRITE_CONCURRENT_INSERT or one TL_WRITE_DELAYED lock at the same time as
 
69
multiple read locks.
52
70
 
53
71
*/
54
72
 
55
 
#include "config.h"
56
 
#include "drizzled/internal/my_sys.h"
57
 
#include "drizzled/internal/thread_var.h"
58
 
#include "drizzled/statistics_variables.h"
59
 
 
60
 
#include "drizzled/session.h"
61
 
#include "drizzled/current_session.h"
 
73
#include "mysys_priv.h"
62
74
 
63
75
#include "thr_lock.h"
64
 
#include "drizzled/internal/m_string.h"
 
76
#include <mystrings/m_string.h>
65
77
#include <errno.h>
66
 
#include <list>
67
 
 
68
 
#if TIME_WITH_SYS_TIME
69
 
# include <sys/time.h>
70
 
# include <time.h>
71
 
#else
72
 
# if HAVE_SYS_TIME_H
73
 
#  include <sys/time.h>
74
 
# else
75
 
#  include <time.h>
76
 
# endif
77
 
#endif
78
 
 
79
 
#include <drizzled/util/test.h>
80
 
 
81
 
using namespace std;
82
 
 
83
 
namespace drizzled
 
78
 
 
79
bool thr_lock_inited=0;
 
80
uint32_t locks_immediate = 0L, locks_waited = 0L;
 
81
ulong table_lock_wait_timeout;
 
82
enum thr_lock_type thr_upgraded_concurrent_insert_lock = TL_WRITE;
 
83
 
 
84
/* The following constants are only for debug output */
 
85
#define MAX_THREADS 100
 
86
#define MAX_LOCKS   100
 
87
 
 
88
 
 
89
LIST *thr_lock_thread_list;                     /* List of threads in use */
 
90
ulong max_write_lock_count= ~(ulong) 0L;
 
91
 
 
92
static inline pthread_cond_t *get_cond(void)
84
93
{
85
 
 
86
 
uint64_t table_lock_wait_timeout;
87
 
static enum thr_lock_type thr_upgraded_concurrent_insert_lock = TL_WRITE;
88
 
 
89
 
 
90
 
uint64_t max_write_lock_count= ~(uint64_t) 0L;
 
94
  return &my_thread_var->suspend;
 
95
}
91
96
 
92
97
/*
93
98
** For the future (now the thread specific cond is alloced by my_pthread.c)
94
99
*/
95
100
 
 
101
bool init_thr_lock()
 
102
{
 
103
  thr_lock_inited=1;
 
104
  return 0;
 
105
}
 
106
 
96
107
static inline bool
97
108
thr_lock_owner_equal(THR_LOCK_OWNER *rhs, THR_LOCK_OWNER *lhs)
98
109
{
99
110
  return rhs == lhs;
100
111
}
101
112
 
 
113
#ifdef EXTRA_DEBUG
 
114
#define MAX_FOUND_ERRORS        10              /* Report 10 first errors */
 
115
static uint found_errors=0;
 
116
 
 
117
static int check_lock(struct st_lock_list *list, const char* lock_type,
 
118
                      const char *where, bool same_owner, bool no_cond)
 
119
{
 
120
  THR_LOCK_DATA *data,**prev;
 
121
  uint count=0;
 
122
  THR_LOCK_OWNER *first_owner;
 
123
 
 
124
  prev= &list->data;
 
125
  if (list->data)
 
126
  {
 
127
    enum thr_lock_type last_lock_type=list->data->type;
 
128
 
 
129
    if (same_owner && list->data)
 
130
      first_owner= list->data->owner;
 
131
    for (data=list->data; data && count++ < MAX_LOCKS ; data=data->next)
 
132
    {
 
133
      if (data->type != last_lock_type)
 
134
        last_lock_type=TL_IGNORE;
 
135
      if (data->prev != prev)
 
136
      {
 
137
        fprintf(stderr,
 
138
                "Warning: prev link %d didn't point at previous lock at %s: %s\n",
 
139
                count, lock_type, where);
 
140
        return 1;
 
141
      }
 
142
      if (same_owner &&
 
143
          !thr_lock_owner_equal(data->owner, first_owner) &&
 
144
          last_lock_type != TL_WRITE_ALLOW_WRITE)
 
145
      {
 
146
        fprintf(stderr,
 
147
                "Warning: Found locks from different threads in %s: %s\n",
 
148
                lock_type,where);
 
149
        return 1;
 
150
      }
 
151
      if (no_cond && data->cond)
 
152
      {
 
153
        fprintf(stderr,
 
154
                "Warning: Found active lock with not reset cond %s: %s\n",
 
155
                lock_type,where);
 
156
        return 1;
 
157
      }
 
158
      prev= &data->next;
 
159
    }
 
160
    if (data)
 
161
    {
 
162
      fprintf(stderr,"Warning: found too many locks at %s: %s\n",
 
163
              lock_type,where);
 
164
      return 1;
 
165
    }
 
166
  }
 
167
  if (prev != list->last)
 
168
  {
 
169
    fprintf(stderr,"Warning: last didn't point at last lock at %s: %s\n",
 
170
            lock_type, where);
 
171
    return 1;
 
172
  }
 
173
  return 0;
 
174
}
 
175
 
 
176
 
 
177
static void check_locks(THR_LOCK *lock, const char *where,
 
178
                        bool allow_no_locks)
 
179
{
 
180
  uint old_found_errors=found_errors;
 
181
 
 
182
  if (found_errors < MAX_FOUND_ERRORS)
 
183
  {
 
184
    if (check_lock(&lock->write,"write",where,1,1) |
 
185
        check_lock(&lock->write_wait,"write_wait",where,0,0) |
 
186
        check_lock(&lock->read,"read",where,0,1) |
 
187
        check_lock(&lock->read_wait,"read_wait",where,0,0))
 
188
      found_errors++;
 
189
 
 
190
    if (found_errors < MAX_FOUND_ERRORS)
 
191
    {
 
192
      uint count=0;
 
193
      THR_LOCK_DATA *data;
 
194
      for (data=lock->read.data ; data ; data=data->next)
 
195
      {
 
196
        if ((int) data->type == (int) TL_READ_NO_INSERT)
 
197
          count++;
 
198
        /* Protect against infinite loop. */
 
199
        assert(count <= lock->read_no_write_count);
 
200
      }
 
201
      if (count != lock->read_no_write_count)
 
202
      {
 
203
        found_errors++;
 
204
        fprintf(stderr,
 
205
                "Warning at '%s': Locks read_no_write_count was %u when it should have been %u\n", where, lock->read_no_write_count,count);
 
206
      }      
 
207
 
 
208
      if (!lock->write.data)
 
209
      {
 
210
        if (!allow_no_locks && !lock->read.data &&
 
211
            (lock->write_wait.data || lock->read_wait.data))
 
212
        {
 
213
          found_errors++;
 
214
          fprintf(stderr,
 
215
                  "Warning at '%s': No locks in use but locks are in wait queue\n",
 
216
                  where);
 
217
        }
 
218
        if (!lock->write_wait.data)
 
219
        {
 
220
          if (!allow_no_locks && lock->read_wait.data)
 
221
          {
 
222
            found_errors++;
 
223
            fprintf(stderr,
 
224
                    "Warning at '%s': No write locks and waiting read locks\n",
 
225
                    where);
 
226
          }
 
227
        }
 
228
        else
 
229
        {
 
230
          if (!allow_no_locks &&
 
231
              (((lock->write_wait.data->type == TL_WRITE_CONCURRENT_INSERT ||
 
232
                 lock->write_wait.data->type == TL_WRITE_ALLOW_WRITE) &&
 
233
                !lock->read_no_write_count) ||
 
234
               lock->write_wait.data->type == TL_WRITE_ALLOW_READ ||
 
235
               (lock->write_wait.data->type == TL_WRITE_DELAYED &&
 
236
                !lock->read.data)))
 
237
          {
 
238
            found_errors++;
 
239
            fprintf(stderr,
 
240
                    "Warning at '%s': Write lock %d waiting while no exclusive read locks\n",where,(int) lock->write_wait.data->type);
 
241
          }
 
242
        }             
 
243
      }
 
244
      else
 
245
      {                                         /* Have write lock */
 
246
        if (lock->write_wait.data)
 
247
        {
 
248
          if (!allow_no_locks && 
 
249
              lock->write.data->type == TL_WRITE_ALLOW_WRITE &&
 
250
              lock->write_wait.data->type == TL_WRITE_ALLOW_WRITE)
 
251
          {
 
252
            found_errors++;
 
253
            fprintf(stderr,
 
254
                    "Warning at '%s': Found WRITE_ALLOW_WRITE lock waiting for WRITE_ALLOW_WRITE lock\n",
 
255
                    where);
 
256
          }
 
257
        }
 
258
        if (lock->read.data)
 
259
        {
 
260
          if (!thr_lock_owner_equal(lock->write.data->owner,
 
261
                                    lock->read.data->owner) &&
 
262
              ((lock->write.data->type > TL_WRITE_DELAYED &&
 
263
                lock->write.data->type != TL_WRITE_ONLY) ||
 
264
               ((lock->write.data->type == TL_WRITE_CONCURRENT_INSERT ||
 
265
                 lock->write.data->type == TL_WRITE_ALLOW_WRITE) &&
 
266
                lock->read_no_write_count)))
 
267
          {
 
268
            found_errors++;
 
269
            fprintf(stderr,
 
270
                    "Warning at '%s': Found lock of type %d that is write and read locked\n",
 
271
                    where, lock->write.data->type);
 
272
          }
 
273
        }
 
274
        if (lock->read_wait.data)
 
275
        {
 
276
          if (!allow_no_locks && lock->write.data->type <= TL_WRITE_DELAYED &&
 
277
              lock->read_wait.data->type <= TL_READ_HIGH_PRIORITY)
 
278
          {
 
279
            found_errors++;
 
280
            fprintf(stderr,
 
281
                    "Warning at '%s': Found read lock of type %d waiting for write lock of type %d\n",
 
282
                    where,
 
283
                    (int) lock->read_wait.data->type,
 
284
                    (int) lock->write.data->type);
 
285
          }
 
286
        }
 
287
      }
 
288
    }
 
289
  }
 
290
  return;
 
291
}
 
292
 
 
293
#else /* EXTRA_DEBUG */
 
294
#define check_locks(A,B,C)
 
295
#endif
 
296
 
102
297
 
103
298
        /* Initialize a lock */
104
299
 
105
300
void thr_lock_init(THR_LOCK *lock)
106
301
{
107
 
  lock->init();
 
302
  memset(lock, 0, sizeof(*lock));
 
303
  VOID(pthread_mutex_init(&lock->mutex,MY_MUTEX_INIT_FAST));
108
304
  lock->read.last= &lock->read.data;
109
305
  lock->read_wait.last= &lock->read_wait.data;
110
306
  lock->write_wait.last= &lock->write_wait.data;
111
307
  lock->write.last= &lock->write.data;
112
 
}
113
 
 
114
 
 
115
 
void THR_LOCK_INFO::init()
116
 
{
117
 
  internal::st_my_thread_var *tmp= my_thread_var;
118
 
  thread= tmp->pthread_self;
119
 
  thread_id= tmp->id;
120
 
  n_cursors= 0;
 
308
 
 
309
  pthread_mutex_lock(&THR_LOCK_lock);           /* Add to locks in use */
 
310
  lock->list.data=(void*) lock;
 
311
  thr_lock_thread_list=list_add(thr_lock_thread_list,&lock->list);
 
312
  pthread_mutex_unlock(&THR_LOCK_lock);
 
313
  return;
 
314
}
 
315
 
 
316
 
 
317
void thr_lock_delete(THR_LOCK *lock)
 
318
{
 
319
  VOID(pthread_mutex_destroy(&lock->mutex));
 
320
  pthread_mutex_lock(&THR_LOCK_lock);
 
321
  thr_lock_thread_list=list_delete(thr_lock_thread_list,&lock->list);
 
322
  pthread_mutex_unlock(&THR_LOCK_lock);
 
323
  return;
 
324
}
 
325
 
 
326
 
 
327
void thr_lock_info_init(THR_LOCK_INFO *info)
 
328
{
 
329
  struct st_my_thread_var *tmp= my_thread_var;
 
330
  info->thread=    tmp->pthread_self;
 
331
  info->thread_id= tmp->id;
 
332
  info->n_cursors= 0;
121
333
}
122
334
 
123
335
        /* Initialize a lock instance */
124
336
 
125
 
void THR_LOCK_DATA::init(THR_LOCK *lock_arg, void *param_arg)
 
337
void thr_lock_data_init(THR_LOCK *lock,THR_LOCK_DATA *data, void *param)
126
338
{
127
 
  lock= lock_arg;
128
 
  type= TL_UNLOCK;
129
 
  owner= NULL;                               /* no owner yet */
130
 
  status_param= param_arg;
131
 
  cond= NULL;
 
339
  data->lock=lock;
 
340
  data->type=TL_UNLOCK;
 
341
  data->owner= 0;                               /* no owner yet */
 
342
  data->status_param=param;
 
343
  data->cond=0;
132
344
}
133
345
 
134
346
 
138
350
  for ( ; data ; data=data->next)
139
351
  {
140
352
    if (thr_lock_owner_equal(data->owner, owner))
141
 
      return true;                                      /* Already locked by thread */
142
 
  }
143
 
  return false;
144
 
}
 
353
      return 1;                                 /* Already locked by thread */
 
354
  }
 
355
  return 0;
 
356
}
 
357
 
 
358
static inline bool have_specific_lock(THR_LOCK_DATA *data,
 
359
                                         enum thr_lock_type type)
 
360
{
 
361
  for ( ; data ; data=data->next)
 
362
  {
 
363
    if (data->type == type)
 
364
      return 1;
 
365
  }
 
366
  return 0;
 
367
}
 
368
 
145
369
 
146
370
static void wake_up_waiters(THR_LOCK *lock);
147
371
 
148
372
 
149
 
static enum enum_thr_lock_result wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data, bool in_wait_list)
 
373
static enum enum_thr_lock_result
 
374
wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
 
375
              bool in_wait_list)
150
376
{
151
 
  Session *session= current_session;
152
 
  internal::st_my_thread_var *thread_var= session->getThreadVar();
153
 
 
154
 
  boost::condition_variable *cond= &thread_var->suspend;
 
377
  struct st_my_thread_var *thread_var= my_thread_var;
 
378
  pthread_cond_t *cond= &thread_var->suspend;
155
379
  struct timespec wait_timeout;
156
380
  enum enum_thr_lock_result result= THR_LOCK_ABORTED;
157
381
  bool can_deadlock= test(data->owner->info->n_cursors);
163
387
    wait->last= &data->next;
164
388
  }
165
389
 
166
 
  current_global_counters.locks_waited++;
 
390
  statistic_increment(locks_waited, &THR_LOCK_lock);
167
391
 
168
392
  /* Set up control struct to allow others to abort locks */
169
 
  thread_var->current_mutex= data->lock->native_handle();
170
 
  thread_var->current_cond=  &thread_var->suspend;
171
 
  data->cond= &thread_var->suspend;;
 
393
  thread_var->current_mutex= &data->lock->mutex;
 
394
  thread_var->current_cond=  cond;
 
395
  data->cond= cond;
172
396
 
173
397
  if (can_deadlock)
174
398
    set_timespec(wait_timeout, table_lock_wait_timeout);
175
399
  while (!thread_var->abort || in_wait_list)
176
400
  {
177
401
    int rc= (can_deadlock ?
178
 
             pthread_cond_timedwait(cond->native_handle(), data->lock->native_handle()->native_handle(), &wait_timeout) :
179
 
             pthread_cond_wait(cond->native_handle(), data->lock->native_handle()->native_handle()));
 
402
             pthread_cond_timedwait(cond, &data->lock->mutex,
 
403
                                    &wait_timeout) :
 
404
             pthread_cond_wait(cond, &data->lock->mutex));
180
405
    /*
181
406
      We must break the wait if one of the following occurs:
182
407
      - the connection has been aborted (!thread_var->abort), but
190
415
      Order of checks below is important to not report about timeout
191
416
      if the predicate is true.
192
417
    */
193
 
    if (data->cond == NULL)
 
418
    if (data->cond == 0)
194
419
    {
195
420
      break;
196
421
    }
197
422
    if (rc == ETIMEDOUT || rc == ETIME)
198
423
    {
 
424
      /* purecov: begin inspected */
199
425
      result= THR_LOCK_WAIT_TIMEOUT;
200
426
      break;
 
427
      /* purecov: end */
201
428
    }
202
429
  }
203
430
  if (data->cond || data->type == TL_UNLOCK)
209
436
      else
210
437
        wait->last=data->prev;
211
438
      data->type= TL_UNLOCK;                    /* No lock */
 
439
      check_locks(data->lock, "killed or timed out wait_for_lock", 1);
212
440
      wake_up_waiters(data->lock);
213
441
    }
 
442
    else
 
443
    {
 
444
      check_locks(data->lock, "aborted wait_for_lock", 0);
 
445
    }
214
446
  }
215
447
  else
216
448
  {
217
449
    result= THR_LOCK_SUCCESS;
 
450
    if (data->lock->get_status)
 
451
      (*data->lock->get_status)(data->status_param, 0);
 
452
    check_locks(data->lock,"got wait_for_lock",0);
218
453
  }
219
 
  data->lock->unlock();
 
454
  pthread_mutex_unlock(&data->lock->mutex);
220
455
 
221
456
  /* The following must be done after unlock of lock->mutex */
222
 
  boost::mutex::scoped_lock scopedLock(thread_var->mutex);
223
 
  thread_var->current_mutex= NULL;
224
 
  thread_var->current_cond= NULL;
 
457
  pthread_mutex_lock(&thread_var->mutex);
 
458
  thread_var->current_mutex= 0;
 
459
  thread_var->current_cond=  0;
 
460
  pthread_mutex_unlock(&thread_var->mutex);
225
461
  return(result);
226
462
}
227
463
 
228
464
 
229
 
static enum enum_thr_lock_result thr_lock(THR_LOCK_DATA *data, THR_LOCK_OWNER *owner, enum thr_lock_type lock_type)
 
465
enum enum_thr_lock_result
 
466
thr_lock(THR_LOCK_DATA *data, THR_LOCK_OWNER *owner,
 
467
         enum thr_lock_type lock_type)
230
468
{
231
 
  THR_LOCK *lock= data->lock;
 
469
  THR_LOCK *lock=data->lock;
232
470
  enum enum_thr_lock_result result= THR_LOCK_SUCCESS;
233
471
  struct st_lock_list *wait_queue;
234
472
  THR_LOCK_DATA *lock_owner;
237
475
  data->cond=0;                                 /* safety */
238
476
  data->type=lock_type;
239
477
  data->owner= owner;                           /* Must be reset ! */
240
 
  lock->lock();
 
478
  VOID(pthread_mutex_lock(&lock->mutex));
 
479
  check_locks(lock,(uint) lock_type <= (uint) TL_READ_NO_INSERT ?
 
480
              "enter read_lock" : "enter write_lock",0);
241
481
  if ((int) lock_type <= (int) TL_READ_NO_INSERT)
242
482
  {
243
483
    /* Request for READ lock */
253
493
      */
254
494
 
255
495
      if (thr_lock_owner_equal(data->owner, lock->write.data->owner) ||
256
 
          (lock->write.data->type <= TL_WRITE_CONCURRENT_INSERT &&
257
 
           (((int) lock_type <= (int) TL_READ_WITH_SHARED_LOCKS) ||
 
496
          (lock->write.data->type <= TL_WRITE_DELAYED &&
 
497
           (((int) lock_type <= (int) TL_READ_HIGH_PRIORITY) ||
258
498
            (lock->write.data->type != TL_WRITE_CONCURRENT_INSERT &&
259
499
             lock->write.data->type != TL_WRITE_ALLOW_READ))))
260
500
      {                                         /* Already got a write lock */
263
503
        lock->read.last= &data->next;
264
504
        if (lock_type == TL_READ_NO_INSERT)
265
505
          lock->read_no_write_count++;
266
 
        current_global_counters.locks_immediate++;
 
506
        check_locks(lock,"read lock with old write lock",0);
 
507
        if (lock->get_status)
 
508
          (*lock->get_status)(data->status_param, 0);
 
509
        statistic_increment(locks_immediate,&THR_LOCK_lock);
267
510
        goto end;
268
511
      }
269
512
      if (lock->write.data->type == TL_WRITE_ONLY)
275
518
      }
276
519
    }
277
520
    else if (!lock->write_wait.data ||
278
 
             lock->write_wait.data->type <= TL_WRITE_DEFAULT ||
 
521
             lock->write_wait.data->type <= TL_WRITE_LOW_PRIORITY ||
 
522
             lock_type == TL_READ_HIGH_PRIORITY ||
279
523
             have_old_read_lock(lock->read.data, data->owner))
280
524
    {                                           /* No important write-locks */
281
525
      (*lock->read.last)=data;                  /* Add to running FIFO */
282
526
      data->prev=lock->read.last;
283
527
      lock->read.last= &data->next;
 
528
      if (lock->get_status)
 
529
        (*lock->get_status)(data->status_param, 0);
284
530
      if (lock_type == TL_READ_NO_INSERT)
285
531
        lock->read_no_write_count++;
286
 
      current_global_counters.locks_immediate++;
 
532
      check_locks(lock,"read lock with no write locks",0);
 
533
      statistic_increment(locks_immediate,&THR_LOCK_lock);
287
534
      goto end;
288
535
    }
289
536
    /*
295
542
  }
296
543
  else                                          /* Request for WRITE lock */
297
544
  {
298
 
    if (lock_type == TL_WRITE_CONCURRENT_INSERT)
 
545
    if (lock_type == TL_WRITE_DELAYED)
 
546
    {
 
547
      if (lock->write.data && lock->write.data->type == TL_WRITE_ONLY)
 
548
      {
 
549
        data->type=TL_UNLOCK;
 
550
        result= THR_LOCK_ABORTED;               /* Can't wait for this one */
 
551
        goto end;
 
552
      }
 
553
      /*
 
554
        if there is a TL_WRITE_ALLOW_READ lock, we have to wait for a lock
 
555
        (TL_WRITE_ALLOW_READ is used for ALTER TABLE in MySQL)
 
556
      */
 
557
      if ((!lock->write.data ||
 
558
           lock->write.data->type != TL_WRITE_ALLOW_READ) &&
 
559
          !have_specific_lock(lock->write_wait.data,TL_WRITE_ALLOW_READ) &&
 
560
          (lock->write.data || lock->read.data))
 
561
      {
 
562
        /* Add delayed write lock to write_wait queue, and return at once */
 
563
        (*lock->write_wait.last)=data;
 
564
        data->prev=lock->write_wait.last;
 
565
        lock->write_wait.last= &data->next;
 
566
        data->cond=get_cond();
 
567
        /*
 
568
          We don't have to do get_status here as we will do it when we change
 
569
          the delayed lock to a real write lock
 
570
        */
 
571
        statistic_increment(locks_immediate,&THR_LOCK_lock);
 
572
        goto end;
 
573
      }
 
574
    }
 
575
    else if (lock_type == TL_WRITE_CONCURRENT_INSERT && ! lock->check_status)
299
576
      data->type=lock_type= thr_upgraded_concurrent_insert_lock;
300
577
 
301
578
    if (lock->write.data)                       /* If there is a write lock */
330
607
        (*lock->write.last)=data;       /* Add to running fifo */
331
608
        data->prev=lock->write.last;
332
609
        lock->write.last= &data->next;
333
 
        current_global_counters.locks_immediate++;
 
610
        check_locks(lock,"second write lock",0);
 
611
        if (data->lock->get_status)
 
612
          (*data->lock->get_status)(data->status_param, 0);
 
613
        statistic_increment(locks_immediate,&THR_LOCK_lock);
334
614
        goto end;
335
615
      }
336
616
    }
342
622
        if (lock_type == TL_WRITE_CONCURRENT_INSERT)
343
623
        {
344
624
          concurrent_insert= 1;
 
625
          if ((*lock->check_status)(data->status_param))
 
626
          {
 
627
            concurrent_insert= 0;
 
628
            data->type=lock_type= thr_upgraded_concurrent_insert_lock;
 
629
          }
345
630
        }
346
631
 
347
632
        if (!lock->read.data ||
348
 
            (lock_type <= TL_WRITE_CONCURRENT_INSERT &&
 
633
            (lock_type <= TL_WRITE_DELAYED &&
349
634
             ((lock_type != TL_WRITE_CONCURRENT_INSERT &&
350
635
               lock_type != TL_WRITE_ALLOW_WRITE) ||
351
636
              !lock->read_no_write_count)))
353
638
          (*lock->write.last)=data;             /* Add as current write lock */
354
639
          data->prev=lock->write.last;
355
640
          lock->write.last= &data->next;
356
 
          current_global_counters.locks_immediate++;
 
641
          if (data->lock->get_status)
 
642
            (*data->lock->get_status)(data->status_param, concurrent_insert);
 
643
          check_locks(lock,"only write lock",0);
 
644
          statistic_increment(locks_immediate,&THR_LOCK_lock);
357
645
          goto end;
358
646
        }
359
647
      }
372
660
    result= THR_LOCK_DEADLOCK;
373
661
    goto end;
374
662
  }
375
 
 
376
663
  /* Can't get lock yet;  Wait for it */
377
664
  return(wait_for_lock(wait_queue, data, 0));
378
665
end:
379
 
  lock->unlock();
380
 
 
 
666
  pthread_mutex_unlock(&lock->mutex);
381
667
  return(result);
382
668
}
383
669
 
384
670
 
385
 
static void free_all_read_locks(THR_LOCK *lock, bool using_concurrent_insert)
 
671
static inline void free_all_read_locks(THR_LOCK *lock,
 
672
                                       bool using_concurrent_insert)
386
673
{
387
 
  THR_LOCK_DATA *data= lock->read_wait.data;
 
674
  THR_LOCK_DATA *data=lock->read_wait.data;
 
675
 
 
676
  check_locks(lock,"before freeing read locks",1);
388
677
 
389
678
  /* move all locks from read_wait list to read list */
390
679
  (*lock->read.last)=data;
396
685
 
397
686
  do
398
687
  {
399
 
    boost::condition_variable *cond= data->cond;
 
688
    pthread_cond_t *cond=data->cond;
400
689
    if ((int) data->type == (int) TL_READ_NO_INSERT)
401
690
    {
402
691
      if (using_concurrent_insert)
403
692
      {
404
693
        /*
405
 
          We can't free this lock;
 
694
          We can't free this lock; 
406
695
          Link lock away from read chain back into read_wait chain
407
696
        */
408
697
        if (((*data->prev)=data->next))
415
704
        continue;
416
705
      }
417
706
      lock->read_no_write_count++;
418
 
    }
419
 
    data->cond= NULL;                           /* Mark thread free */
420
 
    cond->notify_one();
 
707
    }      
 
708
    data->cond=0;                               /* Mark thread free */
 
709
    VOID(pthread_cond_signal(cond));
421
710
  } while ((data=data->next));
422
711
  *lock->read_wait.last=0;
423
712
  if (!lock->read_wait.data)
424
713
    lock->write_lock_count=0;
 
714
  check_locks(lock,"after giving read locks",0);
425
715
}
426
716
 
427
 
/* Unlock lock and free next thread on same lock */
 
717
        /* Unlock lock and free next thread on same lock */
428
718
 
429
 
static void thr_unlock(THR_LOCK_DATA *data)
 
719
void thr_unlock(THR_LOCK_DATA *data)
430
720
{
431
721
  THR_LOCK *lock=data->lock;
432
722
  enum thr_lock_type lock_type=data->type;
433
 
  lock->lock();
 
723
  pthread_mutex_lock(&lock->mutex);
 
724
  check_locks(lock,"start of release lock",0);
434
725
 
435
726
  if (((*data->prev)=data->next))               /* remove from lock-list */
436
727
    data->next->prev= data->prev;
437
728
  else if (lock_type <= TL_READ_NO_INSERT)
438
729
    lock->read.last=data->prev;
 
730
  else if (lock_type == TL_WRITE_DELAYED && data->cond)
 
731
  {
 
732
    /*
 
733
      This only happens in extreme circumstances when a 
 
734
      write delayed lock that is waiting for a lock
 
735
    */
 
736
    lock->write_wait.last=data->prev;           /* Put it on wait queue */
 
737
  }
439
738
  else
440
739
    lock->write.last=data->prev;
441
740
  if (lock_type >= TL_WRITE_CONCURRENT_INSERT)
442
 
  { }
 
741
  {
 
742
    if (lock->update_status)
 
743
      (*lock->update_status)(data->status_param);
 
744
  }
443
745
  else
444
 
  { }
 
746
  {
 
747
    if (lock->restore_status)
 
748
      (*lock->restore_status)(data->status_param);
 
749
  }
445
750
  if (lock_type == TL_READ_NO_INSERT)
446
751
    lock->read_no_write_count--;
447
752
  data->type=TL_UNLOCK;                         /* Mark unlocked */
 
753
  check_locks(lock,"after releasing lock",1);
448
754
  wake_up_waiters(lock);
449
 
  lock->unlock();
 
755
  pthread_mutex_unlock(&lock->mutex);
 
756
  return;
450
757
}
451
758
 
452
759
 
470
777
    {
471
778
      /* Release write-locks with TL_WRITE or TL_WRITE_ONLY priority first */
472
779
      if (data &&
473
 
          (!lock->read_wait.data || lock->read_wait.data->type <= TL_READ_WITH_SHARED_LOCKS))
 
780
          (data->type != TL_WRITE_LOW_PRIORITY || !lock->read_wait.data ||
 
781
           lock->read_wait.data->type < TL_READ_HIGH_PRIORITY))
474
782
      {
475
783
        if (lock->write_lock_count++ > max_write_lock_count)
476
784
        {
492
800
          data->prev=lock->write.last;
493
801
          data->next=0;
494
802
          lock->write.last= &data->next;
495
 
 
 
803
          if (data->type == TL_WRITE_CONCURRENT_INSERT &&
 
804
              (*lock->check_status)(data->status_param))
 
805
            data->type=TL_WRITE;                        /* Upgrade lock */
496
806
          {
497
 
            boost::condition_variable *cond= data->cond;
498
 
            data->cond= NULL;                           /* Mark thread free */
499
 
            cond->notify_one(); /* Start waiting thred */
 
807
            pthread_cond_t *cond=data->cond;
 
808
            data->cond=0;                               /* Mark thread free */
 
809
            VOID(pthread_cond_signal(cond));    /* Start waiting thread */
500
810
          }
501
811
          if (data->type != TL_WRITE_ALLOW_WRITE ||
502
812
              !lock->write_wait.data ||
504
814
            break;
505
815
          data=lock->write_wait.data;           /* Free this too */
506
816
        }
507
 
        if (data->type >= TL_WRITE)
 
817
        if (data->type >= TL_WRITE_LOW_PRIORITY)
508
818
          goto end;
509
819
        /* Release possible read locks together with the write lock */
510
820
      }
515
825
                             data->type == TL_WRITE_ALLOW_WRITE));
516
826
    }
517
827
    else if (data &&
518
 
             (lock_type=data->type) <= TL_WRITE_CONCURRENT_INSERT &&
 
828
             (lock_type=data->type) <= TL_WRITE_DELAYED &&
519
829
             ((lock_type != TL_WRITE_CONCURRENT_INSERT &&
520
830
               lock_type != TL_WRITE_ALLOW_WRITE) ||
521
831
              !lock->read_no_write_count))
522
832
    {
 
833
      /*
 
834
        For DELAYED, ALLOW_READ, WRITE_ALLOW_WRITE or CONCURRENT_INSERT locks
 
835
        start WRITE locks together with the READ locks
 
836
      */
 
837
      if (lock_type == TL_WRITE_CONCURRENT_INSERT &&
 
838
          (*lock->check_status)(data->status_param))
 
839
      {
 
840
        data->type=TL_WRITE;                    /* Upgrade lock */
 
841
        if (lock->read_wait.data)
 
842
          free_all_read_locks(lock,0);
 
843
        goto end;
 
844
      }
523
845
      do {
524
 
        boost::condition_variable *cond= data->cond;
 
846
        pthread_cond_t *cond=data->cond;
525
847
        if (((*data->prev)=data->next))         /* remove from wait-list */
526
848
          data->next->prev= data->prev;
527
849
        else
530
852
        data->prev=lock->write.last;
531
853
        lock->write.last= &data->next;
532
854
        data->next=0;                           /* Only one write lock */
533
 
        data->cond= NULL;                               /* Mark thread free */
534
 
        cond->notify_one(); /* Start waiting thread */
 
855
        data->cond=0;                           /* Mark thread free */
 
856
        VOID(pthread_cond_signal(cond));        /* Start waiting thread */
535
857
      } while (lock_type == TL_WRITE_ALLOW_WRITE &&
536
858
               (data=lock->write_wait.data) &&
537
859
               data->type == TL_WRITE_ALLOW_WRITE);
541
863
                             lock_type == TL_WRITE_ALLOW_WRITE));
542
864
    }
543
865
    else if (!data && lock->read_wait.data)
544
 
    {
545
866
      free_all_read_locks(lock,0);
546
 
    }
547
867
  }
548
868
end:
 
869
  check_locks(lock, "after waking up waiters", 0);
549
870
  return;
550
871
}
551
872
 
557
878
*/
558
879
 
559
880
 
560
 
#define LOCK_CMP(A,B) ((unsigned char*) (A->lock) - (uint32_t) ((A)->type) < (unsigned char*) (B->lock)- (uint32_t) ((B)->type))
 
881
#define LOCK_CMP(A,B) ((uchar*) (A->lock) - (uint) ((A)->type) < (uchar*) (B->lock)- (uint) ((B)->type))
561
882
 
562
 
static void sort_locks(THR_LOCK_DATA **data,uint32_t count)
 
883
static void sort_locks(THR_LOCK_DATA **data,uint count)
563
884
{
564
885
  THR_LOCK_DATA **pos,**end,**prev,*tmp;
565
886
 
581
902
 
582
903
 
583
904
enum enum_thr_lock_result
584
 
thr_multi_lock(THR_LOCK_DATA **data, uint32_t count, THR_LOCK_OWNER *owner)
 
905
thr_multi_lock(THR_LOCK_DATA **data, uint count, THR_LOCK_OWNER *owner)
585
906
{
586
907
  THR_LOCK_DATA **pos,**end;
587
908
  if (count > 1)
592
913
    enum enum_thr_lock_result result= thr_lock(*pos, owner, (*pos)->type);
593
914
    if (result != THR_LOCK_SUCCESS)
594
915
    {                                           /* Aborted */
595
 
      thr_multi_unlock(data,(uint32_t) (pos-data));
 
916
      thr_multi_unlock(data,(uint) (pos-data));
596
917
      return(result);
597
918
    }
 
919
#ifdef MAIN
 
920
    printf("Thread: %s  Got lock: 0x%lx  type: %d\n",my_thread_name(),
 
921
           (long) pos[0]->lock, pos[0]->type); fflush(stdout);
 
922
#endif
598
923
  }
599
924
  /*
600
925
    Ensure that all get_locks() have the same status
609
934
    do
610
935
    {
611
936
      pos--;
612
 
      last_lock=(*pos);
 
937
      if (last_lock->lock == (*pos)->lock &&
 
938
          last_lock->lock->copy_status)
 
939
      {
 
940
        if (last_lock->type <= TL_READ_NO_INSERT)
 
941
        {
 
942
          THR_LOCK_DATA **read_lock;
 
943
          /*
 
944
            If we are locking the same table with read locks we must ensure
 
945
            that all tables share the status of the last write lock or
 
946
            the same read lock.
 
947
          */
 
948
          for (;
 
949
               (*pos)->type <= TL_READ_NO_INSERT &&
 
950
                 pos != data &&
 
951
                 pos[-1]->lock == (*pos)->lock ;
 
952
               pos--) ;
 
953
 
 
954
          read_lock = pos+1;
 
955
          do
 
956
          {
 
957
            (last_lock->lock->copy_status)((*read_lock)->status_param,
 
958
                                           (*pos)->status_param);
 
959
          } while (*(read_lock++) != last_lock);
 
960
          last_lock= (*pos);                    /* Point at last write lock */
 
961
        }
 
962
        else
 
963
          (*last_lock->lock->copy_status)((*pos)->status_param,
 
964
                                          last_lock->status_param);
 
965
      }
 
966
      else
 
967
        last_lock=(*pos);
613
968
    } while (pos != data);
614
969
  }
615
970
#endif
618
973
 
619
974
  /* free all locks */
620
975
 
621
 
void thr_multi_unlock(THR_LOCK_DATA **data,uint32_t count)
 
976
void thr_multi_unlock(THR_LOCK_DATA **data,uint count)
622
977
{
623
978
  THR_LOCK_DATA **pos,**end;
624
979
 
625
980
  for (pos=data,end=data+count; pos < end ; pos++)
626
981
  {
 
982
#ifdef MAIN
 
983
    printf("Thread: %s  Rel lock: 0x%lx  type: %d\n",
 
984
           my_thread_name(), (long) pos[0]->lock, pos[0]->type);
 
985
    fflush(stdout);
 
986
#endif
627
987
    if ((*pos)->type != TL_UNLOCK)
628
988
      thr_unlock(*pos);
629
989
  }
635
995
  TL_WRITE_ONLY to abort any new accesses to the lock
636
996
*/
637
997
 
638
 
void THR_LOCK::abort_locks()
 
998
void thr_abort_locks(THR_LOCK *lock, bool upgrade_lock)
639
999
{
640
 
  boost::mutex::scoped_lock scopedLock(mutex);
 
1000
  THR_LOCK_DATA *data;
 
1001
  pthread_mutex_lock(&lock->mutex);
641
1002
 
642
 
  for (THR_LOCK_DATA *local_data= read_wait.data; local_data ; local_data= local_data->next)
 
1003
  for (data=lock->read_wait.data; data ; data=data->next)
643
1004
  {
644
 
    local_data->type= TL_UNLOCK;                        /* Mark killed */
 
1005
    data->type=TL_UNLOCK;                       /* Mark killed */
645
1006
    /* It's safe to signal the cond first: we're still holding the mutex. */
646
 
    local_data->cond->notify_one();
647
 
    local_data->cond= NULL;                             /* Removed from list */
 
1007
    pthread_cond_signal(data->cond);
 
1008
    data->cond=0;                               /* Removed from list */
648
1009
  }
649
 
  for (THR_LOCK_DATA *local_data= write_wait.data; local_data ; local_data= local_data->next)
 
1010
  for (data=lock->write_wait.data; data ; data=data->next)
650
1011
  {
651
 
    local_data->type= TL_UNLOCK;
652
 
    local_data->cond->notify_one();
653
 
    local_data->cond= NULL;
 
1012
    data->type=TL_UNLOCK;
 
1013
    pthread_cond_signal(data->cond);
 
1014
    data->cond=0;
654
1015
  }
655
 
  read_wait.last= &read_wait.data;
656
 
  write_wait.last= &write_wait.data;
657
 
  read_wait.data= write_wait.data=0;
658
 
  if (write.data)
659
 
    write.data->type=TL_WRITE_ONLY;
 
1016
  lock->read_wait.last= &lock->read_wait.data;
 
1017
  lock->write_wait.last= &lock->write_wait.data;
 
1018
  lock->read_wait.data=lock->write_wait.data=0;
 
1019
  if (upgrade_lock && lock->write.data)
 
1020
    lock->write.data->type=TL_WRITE_ONLY;
 
1021
  pthread_mutex_unlock(&lock->mutex);
 
1022
  return;
660
1023
}
661
1024
 
662
1025
 
666
1029
  This is used to abort all locks for a specific thread
667
1030
*/
668
1031
 
669
 
bool THR_LOCK::abort_locks_for_thread(uint64_t thread_id_arg)
 
1032
bool thr_abort_locks_for_thread(THR_LOCK *lock, my_thread_id thread_id)
670
1033
{
 
1034
  THR_LOCK_DATA *data;
671
1035
  bool found= false;
672
1036
 
673
 
  boost::mutex::scoped_lock scopedLock(mutex);
674
 
  for (THR_LOCK_DATA *local_data= read_wait.data; local_data ; local_data= local_data->next)
 
1037
  pthread_mutex_lock(&lock->mutex);
 
1038
  for (data= lock->read_wait.data; data ; data= data->next)
675
1039
  {
676
 
    if (local_data->owner->info->thread_id == thread_id_arg)
 
1040
    if (data->owner->info->thread_id == thread_id)    /* purecov: tested */
677
1041
    {
678
 
      local_data->type= TL_UNLOCK;                      /* Mark killed */
 
1042
      data->type= TL_UNLOCK;                    /* Mark killed */
679
1043
      /* It's safe to signal the cond first: we're still holding the mutex. */
680
1044
      found= true;
681
 
      local_data->cond->notify_one();
682
 
      local_data->cond= 0;                              /* Removed from list */
 
1045
      pthread_cond_signal(data->cond);
 
1046
      data->cond= 0;                            /* Removed from list */
683
1047
 
684
 
      if (((*local_data->prev)= local_data->next))
685
 
        local_data->next->prev= local_data->prev;
 
1048
      if (((*data->prev)= data->next))
 
1049
        data->next->prev= data->prev;
686
1050
      else
687
 
        read_wait.last= local_data->prev;
 
1051
        lock->read_wait.last= data->prev;
688
1052
    }
689
1053
  }
690
 
  for (THR_LOCK_DATA *local_data= write_wait.data; local_data ; local_data= local_data->next)
 
1054
  for (data= lock->write_wait.data; data ; data= data->next)
691
1055
  {
692
 
    if (local_data->owner->info->thread_id == thread_id_arg)
 
1056
    if (data->owner->info->thread_id == thread_id) /* purecov: tested */
693
1057
    {
694
 
      local_data->type= TL_UNLOCK;
 
1058
      data->type= TL_UNLOCK;
695
1059
      found= true;
696
 
      local_data->cond->notify_one();
697
 
      local_data->cond= NULL;
698
 
 
699
 
      if (((*local_data->prev)= local_data->next))
700
 
        local_data->next->prev= local_data->prev;
701
 
      else
702
 
        write_wait.last= local_data->prev;
703
 
    }
704
 
  }
705
 
  wake_up_waiters(this);
706
 
 
707
 
  return found;
708
 
}
709
 
 
710
 
} /* namespace drizzled */
 
1060
      pthread_cond_signal(data->cond);
 
1061
      data->cond= 0;
 
1062
 
 
1063
      if (((*data->prev)= data->next))
 
1064
        data->next->prev= data->prev;
 
1065
      else
 
1066
        lock->write_wait.last= data->prev;
 
1067
    }
 
1068
  }
 
1069
  wake_up_waiters(lock);
 
1070
  pthread_mutex_unlock(&lock->mutex);
 
1071
  return(found);
 
1072
}
 
1073
 
 
1074
 
 
1075
/*
 
1076
  Downgrade a WRITE_* to a lower WRITE level
 
1077
  SYNOPSIS
 
1078
    thr_downgrade_write_lock()
 
1079
    in_data                   Lock data of thread downgrading its lock
 
1080
    new_lock_type             New write lock type
 
1081
  RETURN VALUE
 
1082
    NONE
 
1083
  DESCRIPTION
 
1084
    This can be used to downgrade a lock already owned. When the downgrade
 
1085
    occurs also other waiters, both readers and writers can be allowed to
 
1086
    start.
 
1087
    The previous lock is often TL_WRITE_ONLY but can also be
 
1088
    TL_WRITE and TL_WRITE_ALLOW_READ. The normal downgrade variants are
 
1089
    TL_WRITE_ONLY => TL_WRITE_ALLOW_READ After a short exclusive lock
 
1090
    TL_WRITE_ALLOW_READ => TL_WRITE_ALLOW_WRITE After discovering that the
 
1091
    operation didn't need such a high lock.
 
1092
    TL_WRITE_ONLY => TL_WRITE after a short exclusive lock while holding a
 
1093
    write table lock
 
1094
    TL_WRITE_ONLY => TL_WRITE_ALLOW_WRITE After a short exclusive lock after
 
1095
    already earlier having dongraded lock to TL_WRITE_ALLOW_WRITE
 
1096
    The implementation is conservative and rather don't start rather than
 
1097
    go on unknown paths to start, the common cases are handled.
 
1098
 
 
1099
    NOTE:
 
1100
    In its current implementation it is only allowed to downgrade from
 
1101
    TL_WRITE_ONLY. In this case there are no waiters. Thus no wake up
 
1102
    logic is required.
 
1103
*/
 
1104
 
 
1105
void thr_downgrade_write_lock(THR_LOCK_DATA *in_data,
 
1106
                              enum thr_lock_type new_lock_type)
 
1107
{
 
1108
  THR_LOCK *lock=in_data->lock;
 
1109
 
 
1110
  pthread_mutex_lock(&lock->mutex);
 
1111
  in_data->type= new_lock_type;
 
1112
  check_locks(lock,"after downgrading lock",0);
 
1113
 
 
1114
  pthread_mutex_unlock(&lock->mutex);
 
1115
  return;
 
1116
}
 
1117
 
 
1118
/* Upgrade a WRITE_DELAY lock to a WRITE_LOCK */
 
1119
 
 
1120
bool thr_upgrade_write_delay_lock(THR_LOCK_DATA *data)
 
1121
{
 
1122
  THR_LOCK *lock=data->lock;
 
1123
 
 
1124
  pthread_mutex_lock(&lock->mutex);
 
1125
  if (data->type == TL_UNLOCK || data->type >= TL_WRITE_LOW_PRIORITY)
 
1126
  {
 
1127
    pthread_mutex_unlock(&lock->mutex);
 
1128
    return(data->type == TL_UNLOCK);    /* Test if Aborted */
 
1129
  }
 
1130
  check_locks(lock,"before upgrading lock",0);
 
1131
  /* TODO:  Upgrade to TL_WRITE_CONCURRENT_INSERT in some cases */
 
1132
  data->type=TL_WRITE;                          /* Upgrade lock */
 
1133
 
 
1134
  /* Check if someone has given us the lock */
 
1135
  if (!data->cond)
 
1136
  {
 
1137
    if (!lock->read.data)                       /* No read locks */
 
1138
    {                                           /* We have the lock */
 
1139
      if (data->lock->get_status)
 
1140
        (*data->lock->get_status)(data->status_param, 0);
 
1141
      pthread_mutex_unlock(&lock->mutex);
 
1142
      return(0);
 
1143
    }
 
1144
 
 
1145
    if (((*data->prev)=data->next))             /* remove from lock-list */
 
1146
      data->next->prev= data->prev;
 
1147
    else
 
1148
      lock->write.last=data->prev;
 
1149
 
 
1150
    if ((data->next=lock->write_wait.data))     /* Put first in lock_list */
 
1151
      data->next->prev= &data->next;
 
1152
    else
 
1153
      lock->write_wait.last= &data->next;
 
1154
    data->prev= &lock->write_wait.data;
 
1155
    lock->write_wait.data=data;
 
1156
    check_locks(lock,"upgrading lock",0);
 
1157
  }
 
1158
  else
 
1159
  {
 
1160
    check_locks(lock,"waiting for lock",0);
 
1161
  }
 
1162
  return(wait_for_lock(&lock->write_wait,data,1));
 
1163
}
 
1164
 
 
1165
 
 
1166
/* downgrade a WRITE lock to a WRITE_DELAY lock if there is pending locks */
 
1167
 
 
1168
bool thr_reschedule_write_lock(THR_LOCK_DATA *data)
 
1169
{
 
1170
  THR_LOCK *lock=data->lock;
 
1171
 
 
1172
  pthread_mutex_lock(&lock->mutex);
 
1173
  if (!lock->read_wait.data)                    /* No waiting read locks */
 
1174
  {
 
1175
    pthread_mutex_unlock(&lock->mutex);
 
1176
    return(0);
 
1177
  }
 
1178
 
 
1179
  data->type=TL_WRITE_DELAYED;
 
1180
  if (lock->update_status)
 
1181
    (*lock->update_status)(data->status_param);
 
1182
  if (((*data->prev)=data->next))               /* remove from lock-list */
 
1183
    data->next->prev= data->prev;
 
1184
  else
 
1185
    lock->write.last=data->prev;
 
1186
 
 
1187
  if ((data->next=lock->write_wait.data))       /* Put first in lock_list */
 
1188
    data->next->prev= &data->next;
 
1189
  else
 
1190
    lock->write_wait.last= &data->next;
 
1191
  data->prev= &lock->write_wait.data;
 
1192
  data->cond=get_cond();                        /* This was zero */
 
1193
  lock->write_wait.data=data;
 
1194
  free_all_read_locks(lock,0);
 
1195
 
 
1196
  pthread_mutex_unlock(&lock->mutex);
 
1197
  return(thr_upgrade_write_delay_lock(data));
 
1198
}
 
1199
 
 
1200
 
 
1201
#include <my_sys.h>
 
1202
 
 
1203
/*****************************************************************************
 
1204
** Test of thread locks
 
1205
****************************************************************************/
 
1206
 
 
1207
#ifdef MAIN
 
1208
 
 
1209
struct st_test {
 
1210
  uint lock_nr;
 
1211
  enum thr_lock_type lock_type;
 
1212
};
 
1213
 
 
1214
THR_LOCK locks[5];                      /* 4 locks */
 
1215
 
 
1216
struct st_test test_0[] = {{0,TL_READ}};        /* One lock */
 
1217
struct st_test test_1[] = {{0,TL_READ},{0,TL_WRITE}}; /* Read and write lock of lock 0 */
 
1218
struct st_test test_2[] = {{1,TL_WRITE},{0,TL_READ},{2,TL_READ}};
 
1219
struct st_test test_3[] = {{2,TL_WRITE},{1,TL_READ},{0,TL_READ}}; /* Deadlock with test_2 ? */
 
1220
struct st_test test_4[] = {{0,TL_WRITE},{0,TL_READ},{0,TL_WRITE},{0,TL_READ}};
 
1221
struct st_test test_5[] = {{0,TL_READ},{1,TL_READ},{2,TL_READ},{3,TL_READ}}; /* Many reads */
 
1222
struct st_test test_6[] = {{0,TL_WRITE},{1,TL_WRITE},{2,TL_WRITE},{3,TL_WRITE}}; /* Many writes */
 
1223
struct st_test test_7[] = {{3,TL_READ}};
 
1224
struct st_test test_8[] = {{1,TL_READ_NO_INSERT},{2,TL_READ_NO_INSERT},{3,TL_READ_NO_INSERT}};  /* Should be quick */
 
1225
struct st_test test_9[] = {{4,TL_READ_HIGH_PRIORITY}};
 
1226
struct st_test test_10[] ={{4,TL_WRITE}};
 
1227
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 */
 
1228
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 */
 
1229
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}};
 
1230
struct st_test test_14[] = {{0,TL_WRITE_CONCURRENT_INSERT},{1,TL_READ}};
 
1231
struct st_test test_15[] = {{0,TL_WRITE_ALLOW_WRITE},{1,TL_READ}};
 
1232
struct st_test test_16[] = {{0,TL_WRITE_ALLOW_WRITE},{1,TL_WRITE_ALLOW_WRITE}};
 
1233
 
 
1234
struct st_test *tests[] = {test_0,test_1,test_2,test_3,test_4,test_5,test_6,
 
1235
                           test_7,test_8,test_9,test_10,test_11,test_12,
 
1236
                           test_13,test_14,test_15,test_16};
 
1237
int lock_counts[]= {sizeof(test_0)/sizeof(struct st_test),
 
1238
                    sizeof(test_1)/sizeof(struct st_test),
 
1239
                    sizeof(test_2)/sizeof(struct st_test),
 
1240
                    sizeof(test_3)/sizeof(struct st_test),
 
1241
                    sizeof(test_4)/sizeof(struct st_test),
 
1242
                    sizeof(test_5)/sizeof(struct st_test),
 
1243
                    sizeof(test_6)/sizeof(struct st_test),
 
1244
                    sizeof(test_7)/sizeof(struct st_test),
 
1245
                    sizeof(test_8)/sizeof(struct st_test),
 
1246
                    sizeof(test_9)/sizeof(struct st_test),
 
1247
                    sizeof(test_10)/sizeof(struct st_test),
 
1248
                    sizeof(test_11)/sizeof(struct st_test),
 
1249
                    sizeof(test_12)/sizeof(struct st_test),
 
1250
                    sizeof(test_13)/sizeof(struct st_test),
 
1251
                    sizeof(test_14)/sizeof(struct st_test),
 
1252
                    sizeof(test_15)/sizeof(struct st_test),
 
1253
                    sizeof(test_16)/sizeof(struct st_test)
 
1254
};
 
1255
 
 
1256
 
 
1257
static pthread_cond_t COND_thread_count;
 
1258
static pthread_mutex_t LOCK_thread_count;
 
1259
static uint thread_count;
 
1260
static uint32_t sum=0;
 
1261
 
 
1262
#define MAX_LOCK_COUNT 8
 
1263
 
 
1264
/* The following functions is for WRITE_CONCURRENT_INSERT */
 
1265
 
 
1266
static void test_get_status(void* param __attribute__((unused)),
 
1267
                            int concurrent_insert __attribute__((unused)))
 
1268
{
 
1269
}
 
1270
 
 
1271
static void test_update_status(void* param __attribute__((unused)))
 
1272
{
 
1273
}
 
1274
 
 
1275
static void test_copy_status(void* to __attribute__((unused)) ,
 
1276
                             void *from __attribute__((unused)))
 
1277
{
 
1278
}
 
1279
 
 
1280
static bool test_check_status(void* param __attribute__((unused)))
 
1281
{
 
1282
  return 0;
 
1283
}
 
1284
 
 
1285
 
 
1286
static void *test_thread(void *arg)
 
1287
{
 
1288
  int i,j,param=*((int*) arg);
 
1289
  THR_LOCK_DATA data[MAX_LOCK_COUNT];
 
1290
  THR_LOCK_OWNER owner;
 
1291
  THR_LOCK_INFO lock_info;
 
1292
  THR_LOCK_DATA *multi_locks[MAX_LOCK_COUNT];
 
1293
  my_thread_init();
 
1294
 
 
1295
  printf("Thread %s (%d) started\n",my_thread_name(),param); fflush(stdout);
 
1296
 
 
1297
 
 
1298
  thr_lock_info_init(&lock_info);
 
1299
  thr_lock_owner_init(&owner, &lock_info);
 
1300
  for (i=0; i < lock_counts[param] ; i++)
 
1301
    thr_lock_data_init(locks+tests[param][i].lock_nr,data+i,NULL);
 
1302
  for (j=1 ; j < 10 ; j++)              /* try locking 10 times */
 
1303
  {
 
1304
    for (i=0; i < lock_counts[param] ; i++)
 
1305
    {                                   /* Init multi locks */
 
1306
      multi_locks[i]= &data[i];
 
1307
      data[i].type= tests[param][i].lock_type;
 
1308
    }
 
1309
    thr_multi_lock(multi_locks, lock_counts[param], &owner);
 
1310
    pthread_mutex_lock(&LOCK_thread_count);
 
1311
    {
 
1312
      int tmp=rand() & 7;                       /* Do something from 0-2 sec */
 
1313
      if (tmp == 0)
 
1314
        sleep(1);
 
1315
      else if (tmp == 1)
 
1316
        sleep(2);
 
1317
      else
 
1318
      {
 
1319
        uint32_t k;
 
1320
        for (k=0 ; k < (uint32_t) (tmp-2)*100000L ; k++)
 
1321
          sum+=k;
 
1322
      }
 
1323
    }
 
1324
    pthread_mutex_unlock(&LOCK_thread_count);
 
1325
    thr_multi_unlock(multi_locks,lock_counts[param]);
 
1326
  }
 
1327
 
 
1328
  printf("Thread %s (%d) ended\n",my_thread_name(),param); fflush(stdout);
 
1329
  thr_print_locks();
 
1330
  pthread_mutex_lock(&LOCK_thread_count);
 
1331
  thread_count--;
 
1332
  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
 
1333
  pthread_mutex_unlock(&LOCK_thread_count);
 
1334
  free((uchar*) arg);
 
1335
  return 0;
 
1336
}
 
1337
 
 
1338
 
 
1339
int main(int argc __attribute__((unused)),char **argv __attribute__((unused)))
 
1340
{
 
1341
  pthread_t tid;
 
1342
  pthread_attr_t thr_attr;
 
1343
  int i,*param,error;
 
1344
  MY_INIT(argv[0]);
 
1345
 
 
1346
  printf("Main thread: %s\n",my_thread_name());
 
1347
 
 
1348
  if ((error=pthread_cond_init(&COND_thread_count,NULL)))
 
1349
  {
 
1350
    fprintf(stderr,"Got error: %d from pthread_cond_init (errno: %d)",
 
1351
            error,errno);
 
1352
    exit(1);
 
1353
  }
 
1354
  if ((error=pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST)))
 
1355
  {
 
1356
    fprintf(stderr,"Got error: %d from pthread_cond_init (errno: %d)",
 
1357
            error,errno);
 
1358
    exit(1);
 
1359
  }
 
1360
 
 
1361
  for (i=0 ; i < (int) array_elements(locks) ; i++)
 
1362
  {
 
1363
    thr_lock_init(locks+i);
 
1364
    locks[i].check_status= test_check_status;
 
1365
    locks[i].update_status=test_update_status;
 
1366
    locks[i].copy_status=  test_copy_status;
 
1367
    locks[i].get_status=   test_get_status;
 
1368
  }
 
1369
  if ((error=pthread_attr_init(&thr_attr)))
 
1370
  {
 
1371
    fprintf(stderr,"Got error: %d from pthread_attr_init (errno: %d)",
 
1372
            error,errno);
 
1373
    exit(1);
 
1374
  }
 
1375
  if ((error=pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED)))
 
1376
  {
 
1377
    fprintf(stderr,
 
1378
            "Got error: %d from pthread_attr_setdetachstate (errno: %d)",
 
1379
            error,errno);
 
1380
    exit(1);
 
1381
  }
 
1382
#ifndef pthread_attr_setstacksize               /* void return value */
 
1383
  if ((error=pthread_attr_setstacksize(&thr_attr,65536L)))
 
1384
  {
 
1385
    fprintf(stderr,"Got error: %d from pthread_attr_setstacksize (errno: %d)",
 
1386
            error,errno);
 
1387
    exit(1);
 
1388
  }
 
1389
#endif
 
1390
#ifdef HAVE_THR_SETCONCURRENCY
 
1391
  VOID(thr_setconcurrency(2));
 
1392
#endif
 
1393
  for (i=0 ; i < (int) array_elements(lock_counts) ; i++)
 
1394
  {
 
1395
    param=(int*) malloc(sizeof(int));
 
1396
    *param=i;
 
1397
 
 
1398
    if ((error=pthread_mutex_lock(&LOCK_thread_count)))
 
1399
    {
 
1400
      fprintf(stderr,"Got error: %d from pthread_mutex_lock (errno: %d)",
 
1401
              error,errno);
 
1402
      exit(1);
 
1403
    }
 
1404
    if ((error=pthread_create(&tid,&thr_attr,test_thread,(void*) param)))
 
1405
    {
 
1406
      fprintf(stderr,"Got error: %d from pthread_create (errno: %d)\n",
 
1407
              error,errno);
 
1408
      pthread_mutex_unlock(&LOCK_thread_count);
 
1409
      exit(1);
 
1410
    }
 
1411
    thread_count++;
 
1412
    pthread_mutex_unlock(&LOCK_thread_count);
 
1413
  }
 
1414
 
 
1415
  pthread_attr_destroy(&thr_attr);
 
1416
  if ((error=pthread_mutex_lock(&LOCK_thread_count)))
 
1417
    fprintf(stderr,"Got error: %d from pthread_mutex_lock\n",error);
 
1418
  while (thread_count)
 
1419
  {
 
1420
    if ((error=pthread_cond_wait(&COND_thread_count,&LOCK_thread_count)))
 
1421
      fprintf(stderr,"Got error: %d from pthread_cond_wait\n",error);
 
1422
  }
 
1423
  if ((error=pthread_mutex_unlock(&LOCK_thread_count)))
 
1424
    fprintf(stderr,"Got error: %d from pthread_mutex_unlock\n",error);
 
1425
  for (i=0 ; i < (int) array_elements(locks) ; i++)
 
1426
    thr_lock_delete(locks+i);
 
1427
#ifdef EXTRA_DEBUG
 
1428
  if (found_errors)
 
1429
    printf("Got %d warnings\n",found_errors);
 
1430
  else
 
1431
#endif
 
1432
    printf("Test succeeded\n");
 
1433
  return 0;
 
1434
}
 
1435
 
 
1436
#endif /* MAIN */