os0sync.c 15.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/******************************************************
The interface to the operating system
synchronization primitives.

(c) 1995 Innobase Oy

Created 9/6/1995 Heikki Tuuri
*******************************************************/

#include "os0sync.h"
#ifdef UNIV_NONINL
#include "os0sync.ic"
#endif

#ifdef __WIN__
#include <windows.h>
#endif

#include "ut0mem.h"
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
20
#include "srv0start.h"
21 22

/* Type definition for an operating system mutex struct */
23
struct os_mutex_struct{ 
24
	os_event_t	event;	/* Used by sync0arr.c for queing threads */
25 26 27 28 29 30
	void*		handle;	/* OS handle to mutex */
	ulint		count;	/* we use this counter to check
				that the same thread does not
				recursively lock the mutex: we
				do not assume that the OS mutex
				supports recursive locking, though
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
31
				NT seems to do that */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
32 33
	UT_LIST_NODE_T(os_mutex_str_t) os_mutex_list;
				/* list of all 'slow' OS mutexes created */
34 35
};

36
/* Mutex protecting counts and the lists of OS mutexes and events */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
37 38
os_mutex_t	os_sync_mutex;
ibool		os_sync_mutex_inited	= FALSE;
39
ibool		os_sync_free_called	= FALSE;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
40 41 42

/* This is incremented by 1 in os_thread_create and decremented by 1 in
os_thread_exit */
43
ulint	os_thread_count		= 0;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
44

45
/* The list of all events created */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
46 47 48 49 50
UT_LIST_BASE_NODE_T(os_event_struct_t)	os_event_list;

/* The list of all OS 'slow' mutexes */
UT_LIST_BASE_NODE_T(os_mutex_str_t)	os_mutex_list;

51 52 53
ulint	os_event_count		= 0;
ulint	os_mutex_count		= 0;
ulint	os_fast_mutex_count	= 0;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
54

55 56 57 58
/* Because a mutex is embedded inside an event and there is an
event embedded inside a mutex, on free, this generates a recursive call.
This version of the free event function doesn't acquire the global lock */
static void os_event_free_internal(os_event_t	event);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

/*************************************************************
Initializes global event and OS 'slow' mutex lists. */

void
os_sync_init(void)
/*==============*/
{
	UT_LIST_INIT(os_event_list);
	UT_LIST_INIT(os_mutex_list);

	os_sync_mutex = os_mutex_create(NULL);

	os_sync_mutex_inited = TRUE;
}

/*************************************************************
76
Frees created events and OS 'slow' mutexes. */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
77 78 79 80 81 82 83 84

void
os_sync_free(void)
/*==============*/
{
	os_event_t	event;
	os_mutex_t	mutex;

85
	os_sync_free_called = TRUE;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
86 87 88 89 90 91 92 93 94 95 96 97
	event = UT_LIST_GET_FIRST(os_event_list);

	while (event) {

	      os_event_free(event);

	      event = UT_LIST_GET_FIRST(os_event_list);
	}

	mutex = UT_LIST_GET_FIRST(os_mutex_list);

	while (mutex) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
98 99 100 101 102 103
	      if (mutex == os_sync_mutex) {
		      /* Set the flag to FALSE so that we do not try to
		      reserve os_sync_mutex any more in remaining freeing
		      operations in shutdown */
		      os_sync_mutex_inited = FALSE;
	      }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
104 105 106 107 108

	      os_mutex_free(mutex);

	      mutex = UT_LIST_GET_FIRST(os_mutex_list);
	}
109
	os_sync_free_called = FALSE;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
110
}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
111

112
/*************************************************************
113 114 115
Creates an event semaphore, i.e., a semaphore which may just have two
states: signaled and nonsignaled. The created event is manual reset: it
must be reset explicitly by calling sync_os_reset_event. */
116 117 118 119

os_event_t
os_event_create(
/*============*/
120 121 122
				/* out: the event handle */
	const char*	name)	/* in: the name of the event, if NULL
				the event is created without a name */
123 124
{
#ifdef __WIN__
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
125 126
        os_event_t event;

127 128 129
	event = ut_malloc(sizeof(struct os_event_struct));

	event->handle = CreateEvent(NULL,/* No security attributes */
130 131 132
			TRUE,		/* Manual reset */
			FALSE,		/* Initial state nonsignaled */
			name);
133
	if (!event->handle) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
134 135
	        fprintf(stderr,
"InnoDB: Could not create a Windows event semaphore; Windows error %lu\n",
136
		  (ulong) GetLastError());
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
137
	}
138
#else /* Unix */
139 140 141 142 143 144 145 146
	os_event_t	event;

	UT_NOT_USED(name);

	event = ut_malloc(sizeof(struct os_event_struct));

	os_fast_mutex_init(&(event->os_mutex));

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
147
#if defined(UNIV_HOTBACKUP) && defined(UNIV_HPUX10)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
148 149
	ut_a(0 == pthread_cond_init(&(event->cond_var),
					pthread_condattr_default));
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
150
#else
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
151
	ut_a(0 == pthread_cond_init(&(event->cond_var), NULL));
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
152
#endif
153
	event->is_set = FALSE;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
154
	event->signal_count = 0;
155
#endif /* __WIN__ */
156

157 158 159 160 161 162
	/* The os_sync_mutex can be NULL because during startup an event
	can be created [ because it's embedded in the mutex/rwlock ] before
	this module has been initialized */
	if (os_sync_mutex != NULL) {
		os_mutex_enter(os_sync_mutex);
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
163

164
	/* Put to the list of events */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
165 166 167 168
	UT_LIST_ADD_FIRST(os_event_list, os_event_list, event);

	os_event_count++;

169 170 171
	if (os_sync_mutex != NULL) {
		os_mutex_exit(os_sync_mutex);
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
172

173 174 175
	return(event);
}

176
#ifdef __WIN__
177
/*************************************************************
178 179
Creates an auto-reset event semaphore, i.e., an event which is automatically
reset when a single thread is released. Works only in Windows. */
180 181 182 183

os_event_t
os_event_create_auto(
/*=================*/
184 185 186
				/* out: the event handle */
	const char*	name)	/* in: the name of the event, if NULL
				the event is created without a name */
187
{
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
188
        os_event_t event;
189

190 191 192
	event = ut_malloc(sizeof(struct os_event_struct));

	event->handle = CreateEvent(NULL,/* No security attributes */
193 194 195 196
			FALSE,		/* Auto-reset */
			FALSE,		/* Initial state nonsignaled */
			name);

197 198 199
	if (!event->handle) {
	        fprintf(stderr,
"InnoDB: Could not create a Windows auto event semaphore; Windows error %lu\n",
200
		  (ulong) GetLastError());
201
	}
202

203 204 205 206
        /* Put to the list of events */
	os_mutex_enter(os_sync_mutex);

	UT_LIST_ADD_FIRST(os_event_list, os_event_list, event);
207

208
	os_event_count++;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
209

210 211 212
	os_mutex_exit(os_sync_mutex);

	return(event);
213
}
214
#endif
215 216 217 218 219 220 221 222 223 224

/**************************************************************
Sets an event semaphore to the signaled state: lets waiting threads
proceed. */

void
os_event_set(
/*=========*/
	os_event_t	event)	/* in: event to set */
{
225
#ifdef __WIN__	
226
	ut_a(event);
227
	ut_a(SetEvent(event->handle));
228 229 230 231 232 233 234 235 236
#else
	ut_a(event);

	os_fast_mutex_lock(&(event->os_mutex));

	if (event->is_set) {
		/* Do nothing */
	} else {
		event->is_set = TRUE;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
237
		event->signal_count += 1;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
238
		ut_a(0 == pthread_cond_broadcast(&(event->cond_var)));
239 240 241
	}

	os_fast_mutex_unlock(&(event->os_mutex));
242
#endif		
243 244 245 246 247 248 249 250 251 252 253 254 255 256
}

/**************************************************************
Resets an event semaphore to the nonsignaled state. Waiting threads will
stop to wait for the event. */

void
os_event_reset(
/*===========*/
	os_event_t	event)	/* in: event to reset */
{
#ifdef __WIN__
	ut_a(event);

257
	ut_a(ResetEvent(event->handle));
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
#else
	ut_a(event);

	os_fast_mutex_lock(&(event->os_mutex));

	if (!event->is_set) {
		/* Do nothing */
	} else {
		event->is_set = FALSE;
	}

	os_fast_mutex_unlock(&(event->os_mutex));
#endif
}

273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
/**************************************************************
Frees an event object, without acquiring the global lock. */
static
void
os_event_free_internal(
/*===================*/
	os_event_t	event)	/* in: event to free */
{
#ifdef __WIN__
	ut_a(event);

	ut_a(CloseHandle(event->handle));
#else
	ut_a(event);

	/* This is to avoid freeing the mutex twice */
	os_fast_mutex_free(&(event->os_mutex));

	ut_a(0 == pthread_cond_destroy(&(event->cond_var)));
#endif
	/* Remove from the list of events */

	UT_LIST_REMOVE(os_event_list, os_event_list, event);

	os_event_count--;

	ut_free(event);
}

302 303 304 305 306 307 308
/**************************************************************
Frees an event object. */

void
os_event_free(
/*==========*/
	os_event_t	event)	/* in: event to free */
309
	
310 311 312 313
{
#ifdef __WIN__
	ut_a(event);

314
	ut_a(CloseHandle(event->handle));
315 316 317 318
#else
	ut_a(event);

	os_fast_mutex_free(&(event->os_mutex));
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
319
	ut_a(0 == pthread_cond_destroy(&(event->cond_var)));
320 321
#endif
        /* Remove from the list of events */
322

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
323 324 325 326 327 328 329 330
	os_mutex_enter(os_sync_mutex);

	UT_LIST_REMOVE(os_event_list, os_event_list, event);

	os_event_count--;

	os_mutex_exit(os_sync_mutex);

331 332 333 334
	ut_free(event);
}

/**************************************************************
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
335 336 337 338
Waits for an event object until it is in the signaled state. If
srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS this also exits the
waiting thread when the event becomes signaled (or immediately if the
event is already in the signaled state). */
339 340 341 342 343 344 345 346 347 348 349 350

void
os_event_wait(
/*==========*/
	os_event_t	event)	/* in: event to wait */
{
#ifdef __WIN__
	DWORD	err;

	ut_a(event);

	/* Specify an infinite time limit for waiting */
351
	err = WaitForSingleObject(event->handle, INFINITE);
352 353

	ut_a(err == WAIT_OBJECT_0);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
354 355 356 357

	if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {
	        os_thread_exit(NULL);
	}
358
#else
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
359 360
	ib_longlong	old_signal_count;

361
	os_fast_mutex_lock(&(event->os_mutex));
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
362 363

	old_signal_count = event->signal_count;
364
loop:
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
365 366 367
	if (event->is_set == TRUE
            || event->signal_count != old_signal_count) {

368 369
		os_fast_mutex_unlock(&(event->os_mutex));

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
370 371 372 373
		if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {

		        os_thread_exit(NULL);
		}
374 375 376 377 378 379 380
		/* Ok, we may return */

		return;
	}

	pthread_cond_wait(&(event->cond_var), &(event->os_mutex));

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
381 382 383
	/* Solaris manual said that spurious wakeups may occur: we have to
	check if the event really has been signaled after we came here to
	wait */
384 385

	goto loop;
386 387 388 389 390
#endif
}

/**************************************************************
Waits for an event object until it is in the signaled state or
391
a timeout is exceeded. In Unix the timeout is always infinite. */
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407

ulint
os_event_wait_time(
/*===============*/
				/* out: 0 if success, OS_SYNC_TIME_EXCEEDED if
				timeout was exceeded */
	os_event_t	event,	/* in: event to wait */
	ulint		time)	/* in: timeout in microseconds, or
				OS_SYNC_INFINITE_TIME */
{
#ifdef __WIN__
	DWORD	err;

	ut_a(event);

	if (time != OS_SYNC_INFINITE_TIME) {
408
		err = WaitForSingleObject(event->handle, (DWORD) time / 1000);
409
	} else {
410
		err = WaitForSingleObject(event->handle, INFINITE);
411
	}
412
	
413 414 415 416 417 418 419 420
	if (err == WAIT_OBJECT_0) {

		return(0);
	} else if (err == WAIT_TIMEOUT) {

		return(OS_SYNC_TIME_EXCEEDED);
	} else {
		ut_error;
421
		return(1000000); /* dummy value to eliminate compiler warn. */
422 423 424
	}
#else
	UT_NOT_USED(time);
425
	
426 427 428 429 430 431 432 433
	/* In Posix this is just an ordinary, infinite wait */

	os_event_wait(event);

	return(0);
#endif
}

434
#ifdef __WIN__
435
/**************************************************************
436
Waits for any event in an OS native event array. Returns if even a single
437 438 439 440 441 442 443
one is signaled or becomes signaled. */

ulint
os_event_wait_multiple(
/*===================*/
					/* out: index of the event
					which was signaled */
444
	ulint			n,	/* in: number of events in the
445
					array */
446 447
	os_native_event_t*	native_event_array)
					/* in: pointer to an array of event
448 449 450 451
					handles */
{
	DWORD	index;

452
	ut_a(native_event_array);
453 454
	ut_a(n > 0);

455
	index = WaitForMultipleObjects((DWORD) n, native_event_array,
456 457 458
					FALSE,	   /* Wait for any 1 event */
					INFINITE); /* Infinite wait time
						   limit */
459
	ut_a(index >= WAIT_OBJECT_0);	/* NOTE: Pointless comparision */
460 461
	ut_a(index < WAIT_OBJECT_0 + n);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
462 463 464 465
	if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {
	        os_thread_exit(NULL);
	}

466 467
	return(index - WAIT_OBJECT_0);
}
468
#endif
469 470

/*************************************************************
471 472
Creates an operating system mutex semaphore. Because these are slow, the
mutex semaphore of InnoDB itself (mutex_t) should be used where possible. */
473 474 475 476

os_mutex_t
os_mutex_create(
/*============*/
477 478 479
				/* out: the mutex handle */
	const char*	name)	/* in: the name of the mutex, if NULL
				the mutex is created without a name */
480 481 482 483 484 485 486 487 488 489
{
#ifdef __WIN__
	HANDLE		mutex;
	os_mutex_t	mutex_str;

	mutex = CreateMutex(NULL,	/* No security attributes */
			FALSE,		/* Initial state: no owner */
			name);
	ut_a(mutex);
#else
490
	os_fast_mutex_t*	mutex;
491 492 493
	os_mutex_t		mutex_str;

	UT_NOT_USED(name);
494
	
495
	mutex = ut_malloc(sizeof(os_fast_mutex_t));
496

497 498
	os_fast_mutex_init(mutex);
#endif	
499 500
	mutex_str = ut_malloc(sizeof(os_mutex_str_t));

501
	mutex_str->handle = mutex;
502
	mutex_str->count = 0;
503
	mutex_str->event = os_event_create(NULL);
504

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
505
	if (os_sync_mutex_inited) {
506
		/* When creating os_sync_mutex itself we cannot reserve it */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
507 508 509 510 511
	        os_mutex_enter(os_sync_mutex);
	}

	UT_LIST_ADD_FIRST(os_mutex_list, os_mutex_list, mutex_str);

512 513
	os_mutex_count++;

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
514 515 516 517
	if (os_sync_mutex_inited) {
		os_mutex_exit(os_sync_mutex);
	}

518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
	return(mutex_str);
}

/**************************************************************
Acquires ownership of a mutex semaphore. */

void
os_mutex_enter(
/*===========*/
	os_mutex_t	mutex)	/* in: mutex to acquire */
{
#ifdef __WIN__
	DWORD	err;

	ut_a(mutex);

	/* Specify infinite time limit for waiting */
	err = WaitForSingleObject(mutex->handle, INFINITE);

	ut_a(err == WAIT_OBJECT_0);

	(mutex->count)++;
	ut_a(mutex->count == 1);
#else
	os_fast_mutex_lock(mutex->handle);

	(mutex->count)++;

	ut_a(mutex->count == 1);
#endif
}

/**************************************************************
Releases ownership of a mutex. */

void
os_mutex_exit(
/*==========*/
	os_mutex_t	mutex)	/* in: mutex to release */
{
	ut_a(mutex);

	ut_a(mutex->count == 1);

	(mutex->count)--;
563
#ifdef __WIN__
564 565 566
	ut_a(ReleaseMutex(mutex->handle));
#else
	os_fast_mutex_unlock(mutex->handle);
567
#endif	
568 569 570 571 572 573 574 575 576 577 578 579
}

/**************************************************************
Frees a mutex object. */

void
os_mutex_free(
/*==========*/
	os_mutex_t	mutex)	/* in: mutex to free */
{
	ut_a(mutex);

580 581 582 583
	if (!os_sync_free_called) {
		os_event_free_internal(mutex->event);
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
584 585 586
	if (os_sync_mutex_inited) {
		os_mutex_enter(os_sync_mutex);
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
587 588

	UT_LIST_REMOVE(os_mutex_list, os_mutex_list, mutex);
589 590
	
	os_mutex_count--;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
591

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
592 593 594
	if (os_sync_mutex_inited) {
		os_mutex_exit(os_sync_mutex);
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
595

596
#ifdef __WIN__
597
	ut_a(CloseHandle(mutex->handle));
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
598

599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
	ut_free(mutex);
#else
	os_fast_mutex_free(mutex->handle);
	ut_free(mutex->handle);
	ut_free(mutex);
#endif
}

/*************************************************************
Initializes an operating system fast mutex semaphore. */

void
os_fast_mutex_init(
/*===============*/
	os_fast_mutex_t*	fast_mutex)	/* in: fast mutex */
{
#ifdef __WIN__
	ut_a(fast_mutex);
617
	
618
	InitializeCriticalSection((LPCRITICAL_SECTION) fast_mutex);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
619 620
#else
#if defined(UNIV_HOTBACKUP) && defined(UNIV_HPUX10)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
621
	ut_a(0 == pthread_mutex_init(fast_mutex, pthread_mutexattr_default));
622
#else
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
623
	ut_a(0 == pthread_mutex_init(fast_mutex, MY_MUTEX_INIT_FAST));
624
#endif
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
625
#endif
626 627 628 629 630 631 632 633 634 635 636 637
	if (os_sync_mutex_inited) {
		/* When creating os_sync_mutex itself (in Unix) we cannot
		reserve it */

		os_mutex_enter(os_sync_mutex);
	}

	os_fast_mutex_count++;

	if (os_sync_mutex_inited) {
	        os_mutex_exit(os_sync_mutex);
	}
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
}

/**************************************************************
Acquires ownership of a fast mutex. */

void
os_fast_mutex_lock(
/*===============*/
	os_fast_mutex_t*	fast_mutex)	/* in: mutex to acquire */
{
#ifdef __WIN__
	EnterCriticalSection((LPCRITICAL_SECTION) fast_mutex);
#else
	pthread_mutex_lock(fast_mutex);
#endif
}

heikki@donna.mysql.fi's avatar
heikki@donna.mysql.fi committed
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
/**************************************************************
Releases ownership of a fast mutex. */

void
os_fast_mutex_unlock(
/*=================*/
	os_fast_mutex_t*	fast_mutex)	/* in: mutex to release */
{
#ifdef __WIN__
	LeaveCriticalSection(fast_mutex);
#else
	pthread_mutex_unlock(fast_mutex);
#endif
}

670 671 672 673 674 675 676 677 678 679 680 681 682
/**************************************************************
Frees a mutex object. */

void
os_fast_mutex_free(
/*===============*/
	os_fast_mutex_t*	fast_mutex)	/* in: mutex to free */
{
#ifdef __WIN__
	ut_a(fast_mutex);

	DeleteCriticalSection((LPCRITICAL_SECTION) fast_mutex);
#else
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
	int	ret;
	
	ret = pthread_mutex_destroy(fast_mutex);

	if (ret != 0) {
		ut_print_timestamp(stderr);
		fprintf(stderr,
"  InnoDB: error: return value %lu when calling\n"
"InnoDB: pthread_mutex_destroy().\n", (ulint)ret);
		fprintf(stderr,
"InnoDB: Byte contents of the pthread mutex at %p:\n", fast_mutex);
		ut_print_buf(stderr, (const byte*)fast_mutex,
						sizeof(os_fast_mutex_t));
		fprintf(stderr, "\n");
	}
698
#endif
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
699 700 701 702 703 704
	if (os_sync_mutex_inited) {
		/* When freeing the last mutexes, we have
		already freed os_sync_mutex */

		os_mutex_enter(os_sync_mutex);
	}
705 706 707

	os_fast_mutex_count--;

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
708 709 710
	if (os_sync_mutex_inited) {
		os_mutex_exit(os_sync_mutex);
	}
711
}