← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/sync0rw.h

  • Committer: Brian Aker
  • Date: 2008-10-28 08:36:02 UTC
  • mfrom: (520.4.13 merge-innodb-plugin)
  • Revision ID: brian@tangent.org-20081028083602-0p3zzlhlxr5q2sqo
Merging Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/sync0rw.h
79
79
location (which must be appropriately aligned). The rw-lock is initialized
80
80
to the non-locked state. Explicit freeing of the rw-lock with rw_lock_free
81
81
is necessary only if the memory block containing it is freed. */
82
 
 
 
82
UNIV_INTERN
83
83
void
84
84
rw_lock_create_func(
85
85
/*================*/
96
96
Calling this function is obligatory only if the memory buffer containing
97
97
the rw-lock is freed. Removes an rw-lock object from the global list. The
98
98
rw-lock is checked to be in the non-locked state. */
99
 
 
 
99
UNIV_INTERN
100
100
void
101
101
rw_lock_free(
102
102
/*=========*/
105
105
/**********************************************************************
106
106
Checks that the rw-lock has been initialized and that there are no
107
107
simultaneous shared and exclusive locks. */
108
 
 
 
108
UNIV_INTERN
109
109
ibool
110
110
rw_lock_validate(
111
111
/*=============*/
224
224
on the rw-lock, locking succeed, with the following exception: if pass != 0,
225
225
only a single x-lock may be taken on the lock. NOTE: If the same thread has
226
226
an s-lock, locking does not succeed! */
227
 
 
 
227
UNIV_INTERN
228
228
void
229
229
rw_lock_x_lock_func(
230
230
/*================*/
293
293
thread is able to acquire a second x-latch which is stored in an mtr.
294
294
This, in turn, is needed to pass the debug checks of index page
295
295
operations. */
296
 
 
 
296
UNIV_INTERN
297
297
void
298
298
rw_lock_x_lock_move_ownership(
299
299
/*==========================*/
345
345
/**********************************************************************
346
346
Checks if the thread has locked the rw-lock in the specified mode, with
347
347
the pass value == 0. */
348
 
 
 
348
UNIV_INTERN
349
349
ibool
350
350
rw_lock_own(
351
351
/*========*/
355
355
#endif /* UNIV_SYNC_DEBUG */
356
356
/**********************************************************************
357
357
Checks if somebody has locked the rw-lock in the specified mode. */
358
 
 
 
358
UNIV_INTERN
359
359
ibool
360
360
rw_lock_is_locked(
361
361
/*==============*/
365
365
#ifdef UNIV_SYNC_DEBUG
366
366
/*******************************************************************
367
367
Prints debug info of an rw-lock. */
368
 
 
 
368
UNIV_INTERN
369
369
void
370
370
rw_lock_print(
371
371
/*==========*/
372
372
        rw_lock_t*      lock);  /* in: rw-lock */
373
373
/*******************************************************************
374
374
Prints debug info of currently locked rw-locks. */
375
 
 
 
375
UNIV_INTERN
376
376
void
377
377
rw_lock_list_print_info(
378
378
/*====================*/
380
380
/*******************************************************************
381
381
Returns the number of currently locked rw-locks.
382
382
Works only in the debug version. */
383
 
 
 
383
UNIV_INTERN
384
384
ulint
385
385
rw_lock_n_locked(void);
386
386
/*==================*/
393
393
mutex protecting the sync array, and the ordinary mutex_enter might
394
394
recursively call routines in sync0arr, leading to a deadlock on the OS
395
395
mutex. */
396
 
 
 
396
UNIV_INTERN
397
397
void
398
398
rw_lock_debug_mutex_enter(void);
399
399
/*==========================*/
400
400
/**********************************************************************
401
401
Releases the debug mutex. */
402
 
 
 
402
UNIV_INTERN
403
403
void
404
404
rw_lock_debug_mutex_exit(void);
405
405
/*==========================*/
406
406
/*************************************************************************
407
407
Prints info of a debug struct. */
408
 
 
 
408
UNIV_INTERN
409
409
void
410
410
rw_lock_debug_print(
411
411
/*================*/
421
421
field. Then no new readers are allowed in. */
422
422
 
423
423
struct rw_lock_struct {
 
424
        os_event_t      event;  /* Used by sync0arr.c for thread queueing */
 
425
 
 
426
#ifdef __WIN__
 
427
        os_event_t      wait_ex_event;  /* This windows specific event is
 
428
                                used by the thread which has set the
 
429
                                lock state to RW_LOCK_WAIT_EX. The
 
430
                                rw_lock design guarantees that this
 
431
                                thread will be the next one to proceed
 
432
                                once the current the event gets
 
433
                                signalled. See LEMMA 2 in sync0sync.c */
 
434
#endif
 
435
 
424
436
        ulint   reader_count;   /* Number of readers who have locked this
425
437
                                lock in the shared mode */
426
438
        ulint   writer;         /* This field is set to RW_LOCK_EX if there