home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 4 / hacker04 / 04_HACK04.ISO / darwin / darwinx86.iso / usr / include / sys / lock.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-09-30  |  9.4 KB  |  236 lines
  1. /*
  2.  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
  3.  *
  4.  * @APPLE_LICENSE_HEADER_START@
  5.  * 
  6.  * The contents of this file constitute Original Code as defined in and
  7.  * are subject to the Apple Public Source License Version 1.1 (the
  8.  * "License").  You may not use this file except in compliance with the
  9.  * License.  Please obtain a copy of the License at
  10.  * http://www.apple.com/publicsource and read it before using this file.
  11.  * 
  12.  * This Original Code and all software distributed under the License are
  13.  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14.  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16.  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17.  * License for the specific language governing rights and limitations
  18.  * under the License.
  19.  * 
  20.  * @APPLE_LICENSE_HEADER_END@
  21.  */
  22. /* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
  23. /* 
  24.  * Copyright (c) 1995
  25.  *    The Regents of the University of California.  All rights reserved.
  26.  *
  27.  * This code contains ideas from software contributed to Berkeley by
  28.  * Avadis Tevanian, Jr., Michael Wayne Young, and the Mach Operating
  29.  * System project at Carnegie-Mellon University.
  30.  *
  31.  * Redistribution and use in source and binary forms, with or without
  32.  * modification, are permitted provided that the following conditions
  33.  * are met:
  34.  * 1. Redistributions of source code must retain the above copyright
  35.  *    notice, this list of conditions and the following disclaimer.
  36.  * 2. Redistributions in binary form must reproduce the above copyright
  37.  *    notice, this list of conditions and the following disclaimer in the
  38.  *    documentation and/or other materials provided with the distribution.
  39.  * 3. All advertising materials mentioning features or use of this software
  40.  *    must display the following acknowledgement:
  41.  *    This product includes software developed by the University of
  42.  *    California, Berkeley and its contributors.
  43.  * 4. Neither the name of the University nor the names of its contributors
  44.  *    may be used to endorse or promote products derived from this software
  45.  *    without specific prior written permission.
  46.  *
  47.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  48.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  49.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  50.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  51.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  52.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  53.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  54.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  55.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  56.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  57.  * SUCH DAMAGE.
  58.  *
  59.  *    @(#)lock.h    8.12 (Berkeley) 5/19/95
  60.  */
  61.  
  62. #ifndef    _SYS_LOCK_H_
  63. #define    _SYS_LOCK_H_
  64. #ifdef KERNEL
  65.  
  66. #include <kern/simple_lock.h>
  67. #include <kern/simple_lock_types.h>
  68.  
  69. #if defined(simple_lock_init)
  70. #undef simple_lock_init
  71. #endif
  72. #define simple_lock_init(l)    usimple_lock_init((l),0)
  73.  
  74. #if defined(simple_lock)
  75. #undef simple_lock
  76. #endif
  77. #define simple_lock(l)         ((void) 1)
  78.  
  79. #if defined(simple_unlock)
  80. #undef simple_unlock
  81. #endif
  82. #define simple_unlock(l)        ((void) 1)
  83.  
  84. #if defined(simple_lock_try)
  85. #undef simple_lock_try
  86. #endif
  87. #define simple_lock_try(l)      1
  88.  
  89. #else /* KERNEL */
  90.  
  91. #ifndef    _MACHINE_SIMPLE_LOCK_DATA_
  92. #define    _MACHINE_SIMPLE_LOCK_DATA_
  93.  
  94. #include <mach/boolean.h>
  95.  
  96. #if defined(__ppc__)
  97. struct slock{
  98.     volatile unsigned int lock_data[10];
  99. };
  100. #else
  101. struct slock{
  102.     volatile unsigned int lock_data[9];
  103. };
  104. #endif
  105. typedef struct slock    simple_lock_data_t;
  106. typedef struct slock    *simple_lock_t;
  107. #define    decl_simple_lock_data(class,name) \
  108. class    simple_lock_data_t    name;
  109.  
  110. #endif    /* _MACHINE_SIMPLE_LOCK_DATA_ */
  111.  
  112. #endif /* KERNEL */
  113. /*
  114.  * The general lock structure.  Provides for multiple shared locks,
  115.  * upgrading from shared to exclusive, and sleeping until the lock
  116.  * can be gained. The simple locks are defined in <machine/param.h>.
  117.  */
  118. struct lock__bsd__ {
  119.     simple_lock_data_t
  120.         lk_interlock;        /* lock on remaining fields */
  121.     u_int    lk_flags;        /* see below */
  122.     int    lk_sharecount;        /* # of accepted shared locks */
  123.     int    lk_waitcount;        /* # of processes sleeping for lock */
  124.     short    lk_exclusivecount;    /* # of recursive exclusive locks */
  125.     short    lk_prio;        /* priority at which to sleep */
  126.     char    *lk_wmesg;        /* resource sleeping (for tsleep) */
  127.     int    lk_timo;        /* maximum sleep time (for tsleep) */
  128.     pid_t    lk_lockholder;        /* pid of exclusive lock holder */
  129.     void    *lk_lockthread;        /* thread which acquired excl lock */
  130. };
  131. /*
  132.  * Lock request types:
  133.  *   LK_SHARED - get one of many possible shared locks. If a process
  134.  *    holding an exclusive lock requests a shared lock, the exclusive
  135.  *    lock(s) will be downgraded to shared locks.
  136.  *   LK_EXCLUSIVE - stop further shared locks, when they are cleared,
  137.  *    grant a pending upgrade if it exists, then grant an exclusive
  138.  *    lock. Only one exclusive lock may exist at a time, except that
  139.  *    a process holding an exclusive lock may get additional exclusive
  140.  *    locks if it explicitly sets the LK_CANRECURSE flag in the lock
  141.  *    request, or if the LK_CANRECUSE flag was set when the lock was
  142.  *    initialized.
  143.  *   LK_UPGRADE - the process must hold a shared lock that it wants to
  144.  *    have upgraded to an exclusive lock. Other processes may get
  145.  *    exclusive access to the resource between the time that the upgrade
  146.  *    is requested and the time that it is granted.
  147.  *   LK_EXCLUPGRADE - the process must hold a shared lock that it wants to
  148.  *    have upgraded to an exclusive lock. If the request succeeds, no
  149.  *    other processes will have gotten exclusive access to the resource
  150.  *    between the time that the upgrade is requested and the time that
  151.  *    it is granted. However, if another process has already requested
  152.  *    an upgrade, the request will fail (see error returns below).
  153.  *   LK_DOWNGRADE - the process must hold an exclusive lock that it wants
  154.  *    to have downgraded to a shared lock. If the process holds multiple
  155.  *    (recursive) exclusive locks, they will all be downgraded to shared
  156.  *    locks.
  157.  *   LK_RELEASE - release one instance of a lock.
  158.  *   LK_DRAIN - wait for all activity on the lock to end, then mark it
  159.  *    decommissioned. This feature is used before freeing a lock that
  160.  *    is part of a piece of memory that is about to be freed.
  161.  *
  162.  * These are flags that are passed to the lockmgr routine.
  163.  */
  164. #define LK_TYPE_MASK    0x0000000f    /* type of lock sought */
  165. #define LK_SHARED    0x00000001    /* shared lock */
  166. #define LK_EXCLUSIVE    0x00000002    /* exclusive lock */
  167. #define LK_UPGRADE    0x00000003    /* shared-to-exclusive upgrade */
  168. #define LK_EXCLUPGRADE    0x00000004    /* first shared-to-exclusive upgrade */
  169. #define LK_DOWNGRADE    0x00000005    /* exclusive-to-shared downgrade */
  170. #define LK_RELEASE    0x00000006    /* release any type of lock */
  171. #define LK_DRAIN    0x00000007    /* wait for all lock activity to end */
  172. /*
  173.  * External lock flags.
  174.  *
  175.  * The first three flags may be set in lock_init to set their mode permanently,
  176.  * or passed in as arguments to the lock manager. The LK_REENABLE flag may be
  177.  * set only at the release of a lock obtained by drain.
  178.  */
  179. #define LK_EXTFLG_MASK    0x00000070    /* mask of external flags */
  180. #define LK_NOWAIT    0x00000010    /* do not sleep to await lock */
  181. #define LK_SLEEPFAIL    0x00000020    /* sleep, then return failure */
  182. #define LK_CANRECURSE    0x00000040    /* allow recursive exclusive lock */
  183. #define LK_REENABLE    0x00000080    /* lock is be reenabled after drain */
  184. /*
  185.  * Internal lock flags.
  186.  *
  187.  * These flags are used internally to the lock manager.
  188.  */
  189. #define LK_WANT_UPGRADE    0x00000100    /* waiting for share-to-excl upgrade */
  190. #define LK_WANT_EXCL    0x00000200    /* exclusive lock sought */
  191. #define LK_HAVE_EXCL    0x00000400    /* exclusive lock obtained */
  192. #define LK_WAITDRAIN    0x00000800    /* process waiting for lock to drain */
  193. #define LK_DRAINING    0x00004000    /* lock is being drained */
  194. #define LK_DRAINED    0x00008000    /* lock has been decommissioned */
  195. /*
  196.  * Control flags
  197.  *
  198.  * Non-persistent external flags.
  199.  */
  200. #define LK_INTERLOCK    0x00010000    /* unlock passed simple lock after
  201.                        getting lk_interlock */
  202. #define LK_RETRY    0x00020000    /* vn_lock: retry until locked */
  203.  
  204. /*
  205.  * Lock return status.
  206.  *
  207.  * Successfully obtained locks return 0. Locks will always succeed
  208.  * unless one of the following is true:
  209.  *    LK_FORCEUPGRADE is requested and some other process has already
  210.  *        requested a lock upgrade (returns EBUSY).
  211.  *    LK_WAIT is set and a sleep would be required (returns EBUSY).
  212.  *    LK_SLEEPFAIL is set and a sleep was done (returns ENOLCK).
  213.  *    PCATCH is set in lock priority and a signal arrives (returns
  214.  *        either EINTR or ERESTART if system calls is to be restarted).
  215.  *    Non-null lock timeout and timeout expires (returns EWOULDBLOCK).
  216.  * A failed lock attempt always returns a non-zero error value. No lock
  217.  * is held after an error return (in particular, a failed LK_UPGRADE
  218.  * or LK_FORCEUPGRADE will have released its shared access lock).
  219.  */
  220.  
  221. /*
  222.  * Indicator that no process holds exclusive lock
  223.  */
  224. #define LK_KERNPROC ((pid_t) -2)
  225. #define LK_NOPROC ((pid_t) -1)
  226.  
  227. struct proc;
  228.  
  229. void    lockinit __P((struct lock__bsd__ *, int prio, char *wmesg, int timo,
  230.             int flags));
  231. int    lockmgr __P((struct lock__bsd__ *, u_int flags,
  232.             simple_lock_t, struct proc *p));
  233. int    lockstatus __P((struct lock__bsd__ *));
  234.  
  235. #endif    /* _SYS_LOCK_H_ */
  236.