home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1997 April / macformat-049.iso / mac / Shareware Plus / Developers / dropg++ / usr / include / vm / lock.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-20  |  5.8 KB  |  173 lines  |  [TEXT/R*ch]
  1. /* 
  2.  * Copyright (c) 1991, 1993
  3.  *    The Regents of the University of California.  All rights reserved.
  4.  *
  5.  * This code is derived from software contributed to Berkeley by
  6.  * The Mach Operating System project at Carnegie-Mellon University.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  * 2. Redistributions in binary form must reproduce the above copyright
  14.  *    notice, this list of conditions and the following disclaimer in the
  15.  *    documentation and/or other materials provided with the distribution.
  16.  * 3. All advertising materials mentioning features or use of this software
  17.  *    must display the following acknowledgement:
  18.  *    This product includes software developed by the University of
  19.  *    California, Berkeley and its contributors.
  20.  * 4. Neither the name of the University nor the names of its contributors
  21.  *    may be used to endorse or promote products derived from this software
  22.  *    without specific prior written permission.
  23.  *
  24.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34.  * SUCH DAMAGE.
  35.  *
  36.  *    @(#)lock.h    8.1 (Berkeley) 6/11/93
  37.  *
  38.  *
  39.  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
  40.  * All rights reserved.
  41.  *
  42.  * Authors: Avadis Tevanian, Jr., Michael Wayne Young
  43.  * 
  44.  * Permission to use, copy, modify and distribute this software and
  45.  * its documentation is hereby granted, provided that both the copyright
  46.  * notice and this permission notice appear in all copies of the
  47.  * software, derivative works or modified versions, and any portions
  48.  * thereof, and that both notices appear in supporting documentation.
  49.  * 
  50.  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 
  51.  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 
  52.  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  53.  * 
  54.  * Carnegie Mellon requests users of this software to return to
  55.  *
  56.  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  57.  *  School of Computer Science
  58.  *  Carnegie Mellon University
  59.  *  Pittsburgh PA 15213-3890
  60.  *
  61.  * any improvements or extensions that they make and grant Carnegie the
  62.  * rights to redistribute these changes.
  63.  */
  64.  
  65. /*
  66.  *    Locking primitives definitions
  67.  */
  68.  
  69. #ifndef    _LOCK_H_
  70. #define    _LOCK_H_
  71.  
  72. #define    NCPUS    1        /* XXX */
  73.  
  74. /*
  75.  *    A simple spin lock.
  76.  */
  77.  
  78. struct slock {
  79.     int        lock_data;    /* in general 1 bit is sufficient */
  80. };
  81.  
  82. typedef struct slock    simple_lock_data_t;
  83. typedef struct slock    *simple_lock_t;
  84.  
  85. /*
  86.  *    The general lock structure.  Provides for multiple readers,
  87.  *    upgrading from read to write, and sleeping until the lock
  88.  *    can be gained.
  89.  */
  90.  
  91. struct lock {
  92. #ifdef    vax
  93.     /*
  94.      *    Efficient VAX implementation -- see field description below.
  95.      */
  96.     unsigned int    read_count:16,
  97.             want_upgrade:1,
  98.             want_write:1,
  99.             waiting:1,
  100.             can_sleep:1,
  101.             :0;
  102.  
  103.     simple_lock_data_t    interlock;
  104. #else /* vax */
  105. #ifdef    ns32000
  106.     /*
  107.      *    Efficient ns32000 implementation --
  108.      *    see field description below.
  109.      */
  110.     simple_lock_data_t    interlock;
  111.     unsigned int    read_count:16,
  112.             want_upgrade:1,
  113.             want_write:1,
  114.             waiting:1,
  115.             can_sleep:1,
  116.             :0;
  117.  
  118. #else /* ns32000 */
  119.     /*    Only the "interlock" field is used for hardware exclusion;
  120.      *    other fields are modified with normal instructions after
  121.      *    acquiring the interlock bit.
  122.      */
  123.     simple_lock_data_t
  124.             interlock;    /* Interlock for remaining fields */
  125.     boolean_t    want_write;    /* Writer is waiting, or locked for write */
  126.     boolean_t    want_upgrade;    /* Read-to-write upgrade waiting */
  127.     boolean_t    waiting;    /* Someone is sleeping on lock */
  128.     boolean_t    can_sleep;    /* Can attempts to lock go to sleep */
  129.     int        read_count;    /* Number of accepted readers */
  130. #endif    /* ns32000 */
  131. #endif    /* vax */
  132.     char        *thread;    /* Thread that has lock, if recursive locking allowed */
  133.                     /* (should be thread_t, but but we then have mutually
  134.                        recursive definitions) */
  135.     int        recursion_depth;/* Depth of recursion */
  136. };
  137.  
  138. typedef struct lock    lock_data_t;
  139. typedef struct lock    *lock_t;
  140.  
  141. #if NCPUS > 1
  142. __BEGIN_DECLS
  143. void        simple_lock __P((simple_lock_t));
  144. void        simple_lock_init __P((simple_lock_t));
  145. boolean_t    simple_lock_try __P((simple_lock_t));
  146. void        simple_unlock __P((simple_lock_t));
  147. __END_DECLS
  148. #else        /* No multiprocessor locking is necessary. */
  149. #define    simple_lock(l)
  150. #define    simple_lock_init(l)
  151. #define    simple_lock_try(l)    (1)    /* Always succeeds. */
  152. #define    simple_unlock(l)
  153. #endif
  154.  
  155. /* Sleep locks must work even if no multiprocessing. */
  156.  
  157. #define    lock_read_done(l)    lock_done(l)
  158. #define    lock_write_done(l)    lock_done(l)
  159.  
  160. void        lock_clear_recursive __P((lock_t));
  161. void        lock_done __P((lock_t));
  162. void        lock_init __P((lock_t, boolean_t));
  163. void        lock_read __P((lock_t));
  164. boolean_t    lock_read_to_write __P((lock_t));
  165. void        lock_set_recursive __P((lock_t));
  166. void        lock_sleepable __P((lock_t, boolean_t));
  167. boolean_t    lock_try_read __P((lock_t));
  168. boolean_t    lock_try_read_to_write __P((lock_t));
  169. boolean_t    lock_try_write __P((lock_t));
  170. void        lock_write __P((lock_t));
  171. void        lock_write_to_read __P((lock_t));
  172. #endif /* !_LOCK_H_ */
  173.