Return to defer.h CVS log

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

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

1.1       root        1: #ifndef        __KERNEL_DEFER_H__
                      2: #define        __KERNEL_DEFER_H__
                      3: 
                      4: /*
                      5:  *-IMPORTS:
                      6:  *     <common/ccompat.h>
                      7:  *             __EXTERN_C_BEGIN__
                      8:  *             __EXTERN_C_END__
                      9:  *             __PROTO ()
                     10:  *     <common/_cpuid.h>
                     11:  *             processorid_t
                     12:  */
                     13: 
                     14: #include <common/ccompat.h>
                     15: #include <kernel/_cpuid.h>
                     16: #include <kernel/_defer.h>
                     17: 
                     18: /*
                     19:  * An interesting facility is used in the Coherent kernel; called defer (), it
                     20:  * requests that a function (with a single argument) be called before return
                     21:  * to user level. It's a useful facility, but need some work to be useful for
                     22:  * a multiprocessor system. At the same time, it seems like a good idea to
                     23:  * alter it a litte; unfortunately, the facility suffers severe abuse from (a)
                     24:  * being used to solve problems of poor design such as not having interrupts
                     25:  * prioritized, and (b) being used as a global "solution" for synchronization
                     26:  * issues by moving parts of interrupt code out into base level, where no
                     27:  * thought need be given to synchronization. In this system, (a) has been
                     28:  * dealt with properly, and (b) synchronization issues *must* be dealt with in
                     29:  * a multiprocessor system properly.
                     30:  *
                     31:  * The version presented here has two aims; as a general mechanism for
                     32:  * deferring activity for "return to user level" time to reduce interrupt
                     33:  * latency, and as a mechanism for binding activities to specific processors.
                     34:  * A benefit of using this approach is simplifying the complex set of "before
                     35:  * we return to user level" features.
                     36:  *
                     37:  * Note that this version does not permit callback functions to take any
                     38:  * parameters, thus avoiding type problems (see bufcall () for some of these
                     39:  * that AT&T have foisted on us) and also discourages using it in fashion (b)
                     40:  * above. This could be changed if we find a genuine reason.
                     41:  */
                     42: 
                     43: 
                     44: __EXTERN_C_BEGIN__
                     45: 
                     46: int            defer_int_cpu   __PROTO ((__deffuncp_t _funcp,
                     47:                                          processorid_t _cpuid));
                     48: int            defer_int_any   __PROTO ((__deffuncp_t _funcp));
                     49: int            defer_int_here  __PROTO ((__deffuncp_t _funcp));
                     50: 
                     51: int            defer_proc_cpu  __PROTO ((__deffuncp_t _funcp,
                     52:                                          processorid_t _cpuid));
                     53: int            defer_proc_any  __PROTO ((__deffuncp_t _funcp));
                     54: int            defer_proc_here __PROTO ((__deffuncp_t _funcp));
                     55: 
                     56: __EXTERN_C_END__
                     57: 
                     58: 
                     59: #endif /* ! defined (__KERNEL_DEFER_H__) */

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