aboutsummaryrefslogtreecommitdiff
path: root/winsup/cygwin/sync.h
blob: f8019a8fe1ce8e835506e3a2af0516a0f4fbcc77 (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
68
69
70
71
/* sync.h: Header file for cygwin synchronization primitives.

   Copyright 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc.

   Written by Christopher Faylor <cgf@cygnus.com>

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. */

#ifndef _SYNC_H
#define _SYNC_H
/* FIXME: Note that currently this class cannot be allocated via `new' since
   there are issues with malloc and fork. */
class muto
{
public:
  const char *name;
private:
  static DWORD exiting_thread;
  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 *init (const char *) __attribute__ ((regparm (2)));

#if 0	/* FIXME: See comment in sync.cc */
  ~muto ()
#endif
  int acquire (DWORD ms = INFINITE) __attribute__ ((regparm (2))); /* Acquire the lock. */
  int release () __attribute__ ((regparm (1)));		     /* Release the lock. */

  bool acquired () __attribute__ ((regparm (1)));
  void upforgrabs () {tls = this;}  // just set to an invalid address
  void grab () __attribute__ ((regparm (1)));
  operator int () const {return !!name;}
  static void set_exiting_thread () {exiting_thread = GetCurrentThreadId ();}
};

class lock_process
{
  bool skip_unlock;
  static muto locker;
public:
  static void init () {locker.init ("lock_process");}
  lock_process (bool exiting = false)
  {
    locker.acquire ();
    skip_unlock = exiting;
    if (exiting && exit_state < ES_SET_MUTO)
      {
	exit_state = ES_SET_MUTO;
	muto::set_exiting_thread ();
      }
  }
  ~lock_process ()
  {
    if (!skip_unlock)
      locker.release ();
  }
  friend class dtable;
};

#endif /*_SYNC_H*/