Return to v_proc.h CVS log

Up to [MW Coherent from dump] / coherent / f / usr / include / kernel

Annotation of coherent/f/usr/include/kernel/v_proc.h, revision 1.1.1.1

1.1       root        1: #ifndef        __KERNEL_V_PROC_H__
                      2: #define        __KERNEL_V_PROC_H__
                      3: 
                      4: /*
                      5:  * This function describes a high-level abstract interface to the low-level
                      6:  * scheduling system that is suitable for multiprocessor use. The design of
                      7:  * this interface has been primarily motivated by the multiprocessor DDI/DKI
                      8:  * sleep lock and synchronization variable functions, which impose a rather
                      9:  * different model of sleep incompatible with the old-style sleep () and
                     10:  * wakeup () functions. See "ksynch.c" for a detailed discussion of this.
                     11:  *
                     12:  * This interface is private to this DDI/DKI implementation, and is not
                     13:  * part of the DDI/DKI itself. Portable code should not rely on the contents
                     14:  * of this header at all.
                     15:  */
                     16: 
                     17: /*
                     18:  *-IMPORTS:
                     19:  *     <common/ccompat.h>
                     20:  *             __EXTERN_C_BEGIN__
                     21:  *             __EXTERN_C_END__
                     22:  *             __PROTO ()
                     23:  *     <kernel/_sleep.h>
                     24:  *             __sleep_t
                     25:  *     <kernel/ddi_proc.h>
                     26:  *             pnode_t
                     27:  *             ddi_proc_data ()
                     28:  */
                     29: 
                     30: #include <common/ccompat.h>
                     31: #include <kernel/_sleep.h>
                     32: #include <kernel/ddi_proc.h>
                     33: 
                     34: 
                     35: /*
                     36:  * Flag values to pass to MAKE_SLEEPING ().
                     37:  */
                     38: 
                     39: enum {
                     40:        SLEEP_NO_SIGNALS,
                     41:        SLEEP_INTERRUPTIBLE
                     42: };
                     43: 
                     44: 
                     45: /*
                     46:  * The following structure type defines the information that a client of
                     47:  * MAKE_SLEEPING is required to keep.
                     48:  *
                     49:  * If the underlying implementation uses an adress-based hash-list like the
                     50:  * old-style sleep () and wakeup () functions, then this item need not contain
                     51:  * any data. However, making at least one byte in size gives the property that
                     52:  * the address of such an item is unique. While this would normally contain
                     53:  * pointers threading process-table entries together, an implementation based
                     54:  * on old-style broadcast wakeup is plausible (where this structure would
                     55:  * contain counters to implement the one-at-a-time wakeup).
                     56:  *
                     57:  * Since this stuff is used to implement sleep locking, it is justified in not
                     58:  * using basic locks but going instead to the really primitive operations.
                     59:  */
                     60: 
                     61: typedef struct proc_list plist_t;
                     62: 
                     63: struct proc_list {
                     64:        atomic_uchar_t  pl_locked;      /* control list manipulation */
                     65:        pnode_t       * pl_head;        /* first waiting process info */
                     66: };
                     67: 
                     68: 
                     69: #define        PLIST_INIT(l)           ((void) ATOMIC_CLEAR_UCHAR ((l)->pl_locked))
                     70: #define PLIST_DESTROY(l)       ((void) 0)
                     71: #define PLIST_LOCK(l,n)                (TEST_AND_SET_LOCK ((l)->pl_locked, plhi, \
                     72:                                                    (n)))
                     73: #define        PLIST_UNLOCK(l,p)       (ATOMIC_CLEAR_UCHAR ((l)->pl_locked), \
                     74:                                                     (void) splx (p))
                     75: #define        PLIST_ASSERT_LOCKED(l)  ASSERT (ATOMIC_FETCH_UCHAR ((l)->pl_locked) \
                     76:                                        != 0)
                     77: 
                     78: 
                     79: /*
                     80:  * External function definitions. The curious may like to note that the use
                     81:  * of the __PROTO () macro below has a useful side-effect with respect to
                     82:  * macro-expansion of MAKE_SLEEPING (). The ISO C preprocessor scanning rules
                     83:  * prevent MAKE_SLEEPING () below being expanded because the next right token
                     84:  * is not a left parenthesis. The rescanning rules mean that even through
                     85:  * __PROTO () actually expands to something beginning with a left parenthesis,
                     86:  * the MAKE_SLEEPING token will get copied to the output without expansion,
                     87:  * because it will not be considered again.
                     88:  *
                     89:  * This feature may be of some use if one has a non-ISO C compiler but can
                     90:  * get the source ISO-preprocessed. Many K&R compilers do not understand the
                     91:  * ISO macro-suppression idiom of enclosing a macro name within parentheses
                     92:  * (this suppresses macro-expansion because the next token will be a right
                     93:  * parenthesis) in function declarations due to weaknesses in the grammars
                     94:  * used. Use of an identity macro to enclose the parameter list ensures that
                     95:  * the preprocessor doesn't perform the expansion but leaves the function
                     96:  * name unadorned by unnecessary parentheses. Note that enclosing the function
                     97:  * name does not have the suppressing effect!
                     98:  */
                     99: 
                    100: __EXTERN_C_BEGIN__
                    101: 
                    102: __sleep_t      MAKE_SLEEPING   __PROTO ((plist_t * _plistp, int _priority,
                    103:                                          int _flag));
                    104: void           RUN_NEXT        __PROTO ((void));
                    105: __VOID__      *        WAKE_ONE        __PROTO ((plist_t * _plistp));
                    106: void           WAKE_ALL        __PROTO ((plist_t * _plistp));
                    107: 
                    108: __VOID__      *        PROC_HANDLE     __PROTO ((void));
                    109: 
                    110: __EXTERN_C_END__
                    111: 
                    112: 
                    113: #endif /* ! defined (__KERNEL_V_PROC_H__) */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.