blob: e11a2294bd5324dce7a8a7b4254525c202043444 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
/* sync.h: Header file for cygwin synchronization primitives.
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
#pragma once
/* FIXME: Note that currently this class cannot be allocated via `new' since
there are issues with malloc and fork. */
class muto
{
public:
char *name;
private:
LONG sync; /* Used to serialize access to this class. */
LONG waiters; /* Number of threads waiting for lock. */
HANDLE bruteforce; /* event handle used to control waiting for lock. */
public:
LONG visits; /* Count of number of times a thread has called acquire. */
void *tls; /* Tls of lock owner. */
// class muto *next;
/* The real constructor. */
muto __reg2 *init (const char *);
#if 0 /* FIXME: See comment in sync.cc */
~muto ()
#endif
int __reg2 acquire (DWORD ms = INFINITE); /* Acquire the lock. */
int __reg2 release (_cygtls * = &_my_tls); /* Release the lock. */
bool __reg1 acquired ();
void upforgrabs () {tls = this;} // just set to an invalid address
void __reg1 grab ();
operator int () const {return !!name;}
};
class lock_process
{
bool skip_unlock;
static muto locker;
public:
static void init () {locker.init ("lock_process");}
void dont_bother () {skip_unlock = true;}
lock_process (bool exiting = false)
{
locker.acquire ();
skip_unlock = exiting;
}
void release ()
{
locker.release ();
skip_unlock = true;
}
~lock_process ()
{
if (!skip_unlock)
release ();
}
operator LONG () const {return locker.visits; }
static void force_release (_cygtls *tid) {locker.release (tid);}
friend class dtable;
friend class fhandler_fifo;
};
|
