Return to ddi_data.h CVS log

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

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

1.1       root        1: #ifndef        __KERNEL_DDI_DATA_H__
                      2: #define        __KERNEL_DDI_DATA_H__
                      3: 
                      4: /*
                      5:  * This internal header contains data definitions common to several of the
                      6:  * <sys/ddi...> family of header files. This commonality does not warrant a
                      7:  * separate header for each type, because these are normally incomplete types
                      8:  * anyway, and the <sys/ddi...> mechanisms are only for internal use.
                      9:  */
                     10: /*
                     11:  *-IMPORTS:
                     12:  *     <kernel/_defer.h>
                     13:  *             deffuncp_t
                     14:  *     <kernel/_lock.h>
                     15:  *             __lock_t
                     16:  *     <kernel/x86lock.h>
                     17:  *             atomic_uchar_t
                     18:  */
                     19: 
                     20: #include <kernel/_defer.h>
                     21: #include <kernel/_lock.h>
                     22: #include <kernel/x86lock.h>
                     23: 
                     24: 
                     25: /*
                     26:  * Defer tables operate at both the per-CPU and global levels. This is the
                     27:  * type of a defer table, and the type used to index the table for reading
                     28:  * and writing.
                     29:  *
                     30:  * The defer tables use short atomic indices because that is considerably
                     31:  * simpler and more portable than dealing with atomic pointer types (as they
                     32:  * are implemented in this system, anyway). The extra scaling operation to
                     33:  * index the table seems worth it, since it's cheap and for many common CPUs
                     34:  * is available as an address mode anyway.
                     35:  */
                     36: 
                     37: typedef        atomic_uchar_t  deftabidx_t;
                     38: 
                     39: /*
                     40:  * The per-CPU defer-function tables need locks for writing since they are
                     41:  * used to bind routines to specific processors. The global defer-function
                     42:  * tables need read and write locks. The read lock is typically a simple test-
                     43:  * and-set lock because the table is tested on the way out of interrupts and
                     44:  * we are concerned about the overhead this imposes.
                     45:  */
                     46: 
                     47: typedef        atomic_uchar_t  defrlock_t;
                     48: typedef        __lock_t      * defwlock_t;
                     49: 
                     50: 
                     51: /*
                     52:  * The deferred-operation tables come in separate per-CPU and global flavours
                     53:  * due to different locking requirements. In addition, deferred operations can
                     54:  * run at different priority levels, most easily managed by having separate
                     55:  * tables.
                     56:  *
                     57:  * One priority level has operations indended to be lower than any interrupt
                     58:  * but higher than regular kernel processing. Kernel timeouts are a good
                     59:  * example of this. The other priority level has operations that are lower
                     60:  * than any kernel-level operation but higher priority than any user-level
                     61:  * operation.
                     62:  *
                     63:  * Since the only difference between the per-CPU and global tables is the read
                     64:  * lock, we can use the same structure for all the deferred functions (the
                     65:  * read lock takes no extra space under COFF due to the structure alignment
                     66:  * rules).
                     67:  */
                     68: 
                     69: typedef struct {
                     70:        __deffuncp_t  * df_tab;                 /* deferred function table */
                     71:        deftabidx_t     df_read;                /* next entry to run */
                     72:        deftabidx_t     df_max;                 /* number of table entries */
                     73:        deftabidx_t     df_write;               /* next entry to write to */
                     74:        defrlock_t      df_rlock;               /* lock read from table */
                     75:        defwlock_t      df_wlock;               /* lock write to table */
                     76: } defer_t;
                     77: 
                     78: 
                     79: #endif /* ! defined (__KERNEL_DDI_DATA_H__) */

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