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

1.1       root        1: #ifndef        __KERNEL_SIGPROC_H__
                      2: #define        __KERNEL_SIGPROC_H__
                      3: 
                      4: #include <common/ccompat.h>
                      5: #include <common/_signal.h>
                      6: #include <common/_siginfo.h>
                      7: #include <kernel/_proc.h>
                      8: 
                      9: /*
                     10:  * iBCS2 specifies that signal () shares a system call number with sigset (),
                     11:  * sighold (), sigrelse (), sigignore (), and sigpause (). The latter are
                     12:  * distinguished according to the high 16 bits of the signal number, as below.
                     13:  */
                     14: 
                     15: #define        SIGSET          0x100
                     16: #define        SIGHOLD         0x200
                     17: #define        SIGRELSE        0x400
                     18: #define        SIGIGNORE       0x800
                     19: #define        SIGPAUSE        0x1000
                     20: 
                     21: 
                     22: /*
                     23:  * Common kernel equivalent for the various user-level flavours of "struct
                     24:  * sigaction".
                     25:  */
                     26: 
                     27: typedef        struct {
                     28:        __sigactfl_t    sa_flags;
                     29:        __sigfunc_t     sa_handler;
                     30:        __sigset_t      sa_mask;
                     31: } __sigaction_t;
                     32: 
                     33: 
                     34: /*
                     35:  * The functions declared below provide kernel modules access to data items
                     36:  * stored in various ways as part of the U area or process structure. All
                     37:  * access to these items should be done through these accessors to ensure
                     38:  * binary compatibility between object modules independent of the exact layout
                     39:  * of these structures. We return pointers because C lacks references...
                     40:  */
                     41: 
                     42: __EXTERN_C_BEGIN__
                     43: 
                     44: void   curr_signal_action      __PROTO ((int _signal,
                     45:                                          __CONST__ __sigaction_t * _act,
                     46:                                          __sigaction_t * _oact));
                     47: void   curr_signal_mask        __PROTO ((__CONST__ __sigset_t * _mask,
                     48:                                          __sigset_t * _omask));
                     49: void   curr_signal_addmask     __PROTO ((__CONST__ __sigset_t * _mask));
                     50: 
                     51: int    proc_signal_masked      __PROTO ((__proc_t * _process, int _signal));
                     52: 
                     53: void   proc_send_signal        __PROTO ((__proc_t * _process,
                     54:                                          __CONST__ __siginfo_t * _siginfo));
                     55: 
                     56: void   proc_unkill             __PROTO ((__proc_t * _process, int _signal));
                     57: 
                     58: int    curr_signal_pending     __PROTO ((void));
                     59: 
                     60: __sigmiscfl_t  curr_signal_misc        __PROTO ((__sigmiscfl_t _clear,
                     61:                                                  __sigmiscfl_t _set));
                     62: __sigmiscfl_t  proc_signal_misc        __PROTO ((__proc_t * _process));
                     63: 
                     64: __EXTERN_C_END__
                     65: 
                     66: #endif /* ! defined (__KERNEL_SIGPROC_H__) */
                     67: 
                     68: 

unix.superglobalmegacorp.com

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