home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / Portable Patmos / usr / include / vm / lock.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-08  |  5.6 KB  |  177 lines  |  [TEXT/R*ch]
  1. /* 
  2.  * Copyright (c) 1991 Regents of the University of California.
  3.  * 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.  *    from: @(#)lock.h    7.3 (Berkeley) 4/21/91
  37.  *    $Id: lock.h,v 1.4 1993/07/29 21:45:38 jtc Exp $
  38.  *
  39.  *
  40.  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
  41.  * All rights reserved.
  42.  *
  43.  * Authors: Avadis Tevanian, Jr., Michael Wayne Young
  44.  * 
  45.  * Permission to use, copy, modify and distribute this software and
  46.  * its documentation is hereby granted, provided that both the copyright
  47.  * notice and this permission notice appear in all copies of the
  48.  * software, derivative works or modified versions, and any portions
  49.  * thereof, and that both notices appear in supporting documentation.
  50.  * 
  51.  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 
  52.  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 
  53.  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  54.  * 
  55.  * Carnegie Mellon requests users of this software to return to
  56.  *
  57.  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  58.  *  School of Computer Science
  59.  *  Carnegie Mellon University
  60.  *  Pittsburgh PA 15213-3890
  61.  *
  62.  * any improvements or extensions that they make and grant Carnegie the
  63.  * rights to redistribute these changes.
  64.  */
  65.  
  66. #ifndef _VM_LOCK_H_
  67. #define _VM_LOCK_H_
  68.  
  69. /*
  70.  *    Locking primitives definitions
  71.  */
  72.  
  73. #define    NCPUS    1        /* XXX */
  74.  
  75. /*
  76.  *    A simple spin lock.
  77.  */
  78.  
  79. struct slock {
  80.     int        lock_data;    /* in general 1 bit is sufficient */
  81. };
  82.  
  83. typedef struct slock    simple_lock_data_t;
  84. typedef struct slock    *simple_lock_t;
  85.  
  86. /*
  87.  *    The general lock structure.  Provides for multiple readers,
  88.  *    upgrading from read to write, and sleeping until the lock
  89.  *    can be gained.
  90.  */
  91.  
  92. struct lock {
  93. #ifdef    vax
  94.     /*
  95.      *    Efficient VAX implementation -- see field description below.
  96.      */
  97.     unsigned int    read_count:16,
  98.             want_upgrade:1,
  99.             want_write:1,
  100.             waiting:1,
  101.             can_sleep:1,
  102.             :0;
  103.  
  104.     simple_lock_data_t    interlock;
  105. #else    /* vax */
  106. #ifdef    ns32000
  107.     /*
  108.      *    Efficient ns32000 implementation --
  109.      *    see field description below.
  110.      */
  111.     simple_lock_data_t    interlock;
  112.     unsigned int    read_count:16,
  113.             want_upgrade:1,
  114.             want_write:1,
  115.             waiting:1,
  116.             can_sleep:1,
  117.             :0;
  118.  
  119. #else    /* ns32000 */
  120.     /*    Only the "interlock" field is used for hardware exclusion;
  121.      *    other fields are modified with normal instructions after
  122.      *    acquiring the interlock bit.
  123.      */
  124.     simple_lock_data_t
  125.             interlock;    /* Interlock for remaining fields */
  126.     boolean_t    want_write;    /* Writer is waiting, or locked for write */
  127.     boolean_t    want_upgrade;    /* Read-to-write upgrade waiting */
  128.     boolean_t    waiting;    /* Someone is sleeping on lock */
  129.     boolean_t    can_sleep;    /* Can attempts to lock go to sleep */
  130.     int        read_count;    /* Number of accepted readers */
  131. #endif    /* ns32000 */
  132. #endif    /* vax */
  133.     char        *thread;    /* Thread that has lock, if recursive locking allowed */
  134.                     /* (should be thread_t, but but we then have mutually
  135.                        recursive definitions) */
  136.     int        recursion_depth;/* Depth of recursion */
  137. };
  138.  
  139. typedef struct lock    lock_data_t;
  140. typedef struct lock    *lock_t;
  141.  
  142. #if    NCPUS > 1
  143. void        simple_lock_init();
  144. void        simple_lock();
  145. void        simple_unlock();
  146. boolean_t    simple_lock_try();
  147. #else    /* NCPUS > 1 */
  148. /*
  149.  *    No multiprocessor locking is necessary.
  150.  */
  151. #define simple_lock_init(l)
  152. #define simple_lock(l)
  153. #define simple_unlock(l)
  154. #define simple_lock_try(l)    (1)    /* always succeeds */
  155. #endif    /* NCPUS > 1 */
  156.  
  157. /* Sleep locks must work even if no multiprocessing */
  158.  
  159. void        lock_init();
  160. void        lock_sleepable();
  161. void        lock_write();
  162. void        lock_read();
  163. void        lock_done();
  164. boolean_t    lock_read_to_write();
  165. void        lock_write_to_read();
  166. boolean_t    lock_try_write();
  167. boolean_t    lock_try_read();
  168. boolean_t    lock_try_read_to_write();
  169.  
  170. #define    lock_read_done(l)    lock_done(l)
  171. #define    lock_write_done(l)    lock_done(l)
  172.  
  173. void        lock_set_recursive();
  174. void        lock_clear_recursive();
  175.  
  176. #endif /* !_VM_LOCK_H_ */
  177.