/* IBM_PROLOG_BEGIN_TAG */ /* This is an automatically generated prolog. */ /* */ /* bos72X src/bos/kernel/sys/proc.h 1.57.32.2 */ /* */ /* Licensed Materials - Property of IBM */ /* */ /* COPYRIGHT International Business Machines Corp. 1985,2021 */ /* All Rights Reserved */ /* */ /* US Government Users Restricted Rights - Use, duplication or */ /* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ /* */ /* IBM_PROLOG_END_TAG */ /* @(#)86 1.57.32.2 src/bos/kernel/sys/proc.h, sysproc, bos72X, x2021_45A1 11/4/21 15:37:04 */ /* * COMPONENT_NAME: SYSPROC * * FUNCTIONS: EXTRACT_NICE * MAYBE_PID * PROCMASK * PROCPTR * SET_NICE * PID_VALIDATE * * ORIGINS: 3, 27, 83 * */ /* * LEVEL 1, 5 Years Bull Confidential Information */ #ifndef _H_PROC #define _H_PROC #ifdef __cplusplus extern "C" { #endif #include #include #include #include #include #include #include #include #include #include #include /* * Avoid including ras.h by defining eye catcher type as below: */ typedef unsigned long proc_eye_catch_t; /* * One structure allocated per uid. This structure contains the * pointers to the uidinfo list, uid of the process and current * number of processes refering to the structure. */ struct uidinfo { struct uidinfo *pu_next; /* next uidinfo structure */ struct uidinfo *pu_prev; /* previous uidinfo structure */ uid_t pu_uid; /* uid of process */ long pu_cnt; /* # of refering processes */ cid_t pu_kcid; /* Corral A's users are distinct * from corral B's users even * though they may share the same * user IDs. */ short pu_pad[7]; /* future use */ }; extern struct uidinfo *get_uidinfo (uid_t uid, cid_t kcid); extern void free_uidinfo (struct uidinfo *uidinfo); /* * One structure allocated per active process. Entries that are * in use are pinned to avoid page faults in kernel critical sections. * * This structure contains per-process information that is needed * when the process is swapped out. The per-process data * that is not needed when the process is swapped out is located * in the processes u-block, . * If threads are enabled, per-thread data is located in the thread and * uthread structures, and . * * When changes are made here, be sure to update the assembler version * in kernel/ml/proc.m4, too. */ #define max_pvproc ((struct pvproc *)v.ve_proc) struct kernext_svc { void (*kernext_svc_cleanup)(void *); }; /* * Incrementing (interval) fields for advanced accounting records. * These are fields that can be summed for aggregation, and cleared * at the start of each interval, such as cpu time. * This structure is used in struct proc below, and in the process * accounting structures. * * See aacct.h to find out what is represented in each array element, * how each is serialized, etc. */ #define TRP_NUM_COUNTS 10 struct proc_counts { unsigned long long trp_count[TRP_NUM_COUNTS]; }; /* * ASO process-specific information */ struct aso { /* Process flags */ unsigned int flags; /* ASO optimization timeout for process in timebase minutes */ unsigned int opt_timeout; /* #times ASO optimization timeout was set for process */ unsigned int opt_timeout_count; /* Fields for 16M MPSS optimization */ union { unsigned char field_8b[2]; unsigned short field_16b; } aso_shmat; /* SRAD to use when attaching/detaching adv rset */ sradid_t pref_srad; /* Bitmask of cpus defined by Advisory Rset */ mrq_mask_t advrset_mask; /* ASO process load */ unsigned long long process_load; unsigned long long process_load_terminated; /* ASO process load for fixed prio threads */ unsigned long long fp_process_load; unsigned long long fp_process_load_terminated; /* Dispatch latency for process */ unsigned long long dispatch_latency; unsigned long long dispatch_latency_terminated; /* Dispatch count for process */ unsigned long long dispatch_count; /* Job ID */ long long opt_jobid; }; #ifndef _32KERMODE struct proc { struct pvproc *p_pvprocp; /* my global process data */ pid_t p_pid; /* unique process identifier */ uint p_flag; /* process flags */ uint p_flag2; /* More flags */ uint p_int; /* process flags */ uint p_atomic; /* process flags */ /* thread fields */ #ifndef __64BIT_KERNEL ushort p_threadcount; /* number of threads */ ushort p_active; /* number of active threads */ ushort p_suspended; /* number of suspended threads */ ushort p_terminating; /* number of terminating threads*/ ushort p_local; /* number of "local" threads */ #else uint p_threadcount; /* number of threads */ uint p_active; /* number of active threads */ uint p_suspended; /* number of suspended threads */ uint p_terminating; /* number of terminating threads*/ uint p_local; /* number of "local" threads */ #endif /* fields used by process migration */ ulong p_rss; /* n of private data pages */ short p_sradassign; /* srad assignment */ ushort p_boundcount; /* number of bound threads. */ short p_process_srad; /* Process SRAD attachment */ void *p_rs_attinfo; /* rset attachment */ /* dispatcher fields */ ulong p_pevent; /* pending events */ vmhandle_t p_adspace; /* process address space */ #ifdef __64BIT_KERNEL #ifdef _POWER vmhandle_t p_adspace_ldr; /* loader perprocess le segment */ ulong p_adtable; /* process address space */ #endif /* _POWER */ #endif /* signal information */ #ifdef __64BIT_KERNEL sigset_t p_sig; /* pending signals */ sigset_t p_sigignore; /* signals being ignored */ sigset_t p_sigcatch; /* signals being caught */ sigset_t p_siginfo; /* keep siginfo_t for these */ #else sigset64_t p_sig; /* pending signals */ sigset64_t p_sigignore; /* signals being ignored */ sigset64_t p_sigcatch; /* signals being caught */ sigset64_t p_siginfo; /* keep siginfo_t for these */ #endif struct ksiginfo *p_infoq; /* queue of siginfo_t's */ /* process statistics */ unsigned long long p_size; /* size of image (pages) */ unsigned long long p_minflt; /* page fault count - no I/O */ unsigned long long p_majflt; /* page fault count - I/O needed*/ long long p_repage; /* repaging count */ uint p_pctcpu; /* cpu percentage */ int p_sched_count; /* watchdog suspension count */ short p_cpticks; /* ticks of cpu time in last sec*/ short p_msgcnt; /* uprintf message count */ uint p_majfltsec; /* maj flts in the last sec */ /* scheduler fields */ char p_nice; /* nice for cpu usage */ /* NOTE: PUSER is added into */ /* this field for processes that*/ /* do not have a fixed priority */ char p_sched_pri; /* most favored swapped thrd pri*/ char sysidmod; /* flag to modify sysid. 696307 */ char unused1; /* misc fields */ int p_chkblock; /* n of checkpnt handler blocks */ void *p_chkfile; /* Ptr to chkfile structure */ void *p_prtrcset; /* procfs trace set */ #ifndef __64BIT_KERNEL void *p_lgpage; /* for shmat SHM_LGPAGE option */ #endif struct posix_tmr *p_rt_timer[_POSIX_TIMER_MAX]; /* posix rt timers */ struct cputime_clock p_clock; /* posix process cpu-time clock */ ushort p_io_priority; /* per-process I/O priority */ /* * Relatively static fields for advanced accounting. * These are protected by the pv_lock_d. */ time_t p_memory_lbolt; /* lbolt at get_mem_stats */ unsigned long long p_interval_start; /* interval start, TBs */ struct proc_counts p_acct; /* accounting counters */ struct diskiostat { unsigned long long inbytes; /* #bytes input disk I/0 */ unsigned long long outbytes; /* #bytes output disk I/0 */ unsigned long long logbytes; /* #bytes I/O to/from log dev */ unsigned long long logops; /* log I/O operations count */ unsigned long long inops; /* disk in operations count */ unsigned long long outops; /* disk out operations count */ } p_diskiostat; int p_wlmthrds; /* #threads in proc's wlm class */ int p_wlmocthrds; /* #threads not in proc's wlm class */ int p_thrsetcnt; /* #threads with rset attachment*/ int p_thsradcnt; /* #threads with pref'd sradid attach */ void *p_ptbpt; /* ptrace brkpnt control block */ tid_t p_ptsynch; /* synch for trap handling */ /* Dynamic Tracing counters */ ushort p_entry_probes; /* Number of entry probes */ ushort p_exit_probes; /* Number of exit probes */ /* User Probe Data structures */ void *p_uprobe; /* Linked list of user space probes */ void *p_etrc_procd_ptr; /* Process save data for interval probe*/ /* Process creation time */ unsigned long long p_forktime; /* ASO process-specific information */ struct aso p_aso; /* * Cumulative major and minor page fault times for kernel, * text and data segments for terminated threads. */ u_longlong_t p_maj_pf_text_term; u_longlong_t p_maj_pf_data_term; u_longlong_t p_maj_pf_kernel_term; u_longlong_t p_min_pf_text_term; u_longlong_t p_min_pf_data_term; u_longlong_t p_min_pf_kernel_term; /* CAPI fields */ struct proc *p_caccel_next_proc; /* Next capi process */ struct proc *p_caccel_prev_proc; /* Previous capi process */ void *p_caccel_uctxlist; /* List of user contexts for this process */ Simple_lock p_caccel_lock; /* Lock to manage process state */ unsigned int p_caccel_flags; /* CAPI flags/state of this process */ unsigned int p_caccel_count; /* Count of user contexts */ void *p_nx_accel_data_p; /* Flexctl boost type and boost level */ char p_boost_type; char p_boost_level; char p_pad[6]; /* ASO job information */ void *p_job; /* * Eye-catcher: this field must be the last field * of the structure. Please insert new fields above it. */ proc_eye_catch_t p_eyec; /* proc eye-catcher */ }; /* shortcuts to the per-process disk I/O statistics */ #define p_dkinbytes p_diskiostat.inbytes #define p_dkoutbytes p_diskiostat.outbytes #define p_dklogbytes p_diskiostat.logbytes #define p_dklogops p_diskiostat.logops #define p_dkinops p_diskiostat.inops #define p_dkoutops p_diskiostat.outops /* shortcuts to the per-process aso information */ #define p_asoflags p_aso.flags #define p_advrset_mask p_aso.advrset_mask #define p_process_load p_aso.process_load #define p_process_load_terminated p_aso.process_load_terminated #define p_fp_process_load p_aso.fp_process_load #define p_fp_process_load_terminated p_aso.fp_process_load_terminated #define p_dispatch_latency p_aso.dispatch_latency #define p_dispatch_latency_terminated p_aso.dispatch_latency_terminated #define p_dispatch_count p_aso.dispatch_count #define p_opt_timeout p_aso.opt_timeout #define p_opt_timeout_count p_aso.opt_timeout_count #define p_shmat_ever p_aso.aso_shmat.field_8b[0] #define p_shmat_new p_aso.aso_shmat.field_8b[1] #define p_shmat_flags p_aso.aso_shmat.field_16b #define p_opt_jobid p_aso.opt_jobid #define p_pref_srad p_aso.pref_srad /* Values for p_asoflags */ #define ASOENABLEALWAYS 0x00000001 /* Preferentially optimize with ASO */ #define ASOENABLENEVER 0x00000002 /* Never optimize with ASO */ #define ASOCUSTOMOPTS 0x00000004 /* Custom set of ASO optimisations */ #define ASOCUST_CA 0x00000008 /* Custom ASO - enable cache affinity */ #define ASOCUST_MA 0x00000010 /* Custom ASO - enable memory affinity */ #define ASORSET_DEL_ATT 0x00000020 /* AdvRset overridden by user attachment */ #define ASORSET_DELEXEC 0x00000040 /* AdvRset deleted on exec */ #define ASOCUST_LGPG 0x00000080 /* Custom ASO - enable 16MB MPSS */ #define ASOCUST_DSCR 0x00000100 /* Custom ASO - enable DSCR */ #define ASODSCR_NONDEF 0x00000200 /* DSCR set to non-default value */ #define ASOCUST_ALL (ASOCUST_CA | ASOCUST_MA | ASOCUST_LGPG | ASOCUST_DSCR) /* Values for shmat fields */ #define ASO_SHMAT_EVER 1 #define ASO_SHMAT_NEW 1 struct pvproc { /* identifier fields */ pid_t pv_pid; /* unique process identifier */ pid_t pv_ppid; /* parent process identifier */ pid_t pv_sid; /* session identifier */ pid_t pv_pgrp; /* process group leader pid */ uid_t pv_uid; /* real user identifier */ uid_t pv_suid; /* set user identifier */ class_id_t pv_class; /* wlm class */ int pv_pad0; /* Alignment pad. */ /* * identifier fields for checkpoint/restart. Virtual ids are * only used for restarted processes. */ pid_t pv_vpid; /* virtual process id */ pid_t pv_vppid; /* virtual parent id */ pid_t pv_vsid; /* virtual session identifier */ pid_t pv_vpgrp; /* virtual pgrp leader pid */ crid_t pv_crid; /* crid of process */ uint pv_crid_token; /* token for primary process */ /* zombie process information (doubleword aligned) */ struct trusage64 pv_ru; /* Rusage structure for exit() */ ulong pv_spare[1]; /* read-only spare fields */ Simple_lock pv_lock; /* proc lock for enabled cs */ /* process execution state */ char pv_stat; /* process state */ char pv_sigs_queued; /* number of signals I've q'd */ ushort pv_xstat; /* exit status: * 8 bit return value * 8 bit termination signal * see also pv_flag2 SCOREFILE. */ uint pv_atomic; /* process flags */ uint pv_flag; /* process flags */ uint pv_flag2; /* More flags */ int pv_wlm; /* wlm flags */ uint pv_auditmask; /* Auditing stuff */ /* user scheduler fields */ Simple_lock pv_usched_lock; /* disabled user scheduler lock */ struct pvthread *pv_uschedp; /* user scheduler thread ptr */ /* ptrace link pointers */ struct ptipc *pv_ipc; /* ipc when being debugged */ struct pvproc *pv_dblist; /* processes being debugged */ struct pvproc *pv_dbnext; /* next in p_dblist */ /* procfs fields */ struct vnode * pv_procfsvn; /* procfs process vnode address */ /* swapout queue link pointers */ struct pvproc *pv_sched_next; /* next process in swap queues */ struct pvproc *pv_sched_back; /* previous process in swap q */ /* main process link pointers */ struct proc *pv_procp; /* my global process data */ struct pvproc *pv_child; /* head of list of children */ struct pvproc *pv_siblings; /* NULL terminated sibling list */ struct uidinfo *pv_uidinfo; /* uid information structure */ /* The process group list is a NULL */ /* terminated doubly linked list. */ /* It only exists if pv_pgrp != 0 */ struct pvproc *pv_ganchor; /* anchor for pv_pgrp */ struct pvproc *pv_pgrpl; /* forward link for pv_pgrp */ struct pvproc *pv_pgrpb; /* back link for pv_pgrp */ struct pvproc *pv_ttyl; /* circular list of process groups */ /* in the same session (p_sid). */ /* If the session has a controlling */ /* tty (u.u_ttyp), the processes */ /* (process groups) in the session */ /* have the same controlling tty. */ /* NOTE: p_ttyl links one process of */ /* each process group in the session */ struct pvproc *pv_cridnext; /* Next process in C/R group */ Simple_lock pv_session_lock; /* pgrp and session lock - disabled */ Simple_lock pv_parent_lock; /* parent-child-sibling - disabled */ Simple_lock pv_lock_d; /* process lock - disabled */ /* thread fields */ struct pvthread *pv_threadlist; /* head of list of threads */ tid_t pv_synch; /* event list for threads waiting */ /* for this process to be suspended */ /* dispatcher fields */ uint64_t pv_mempools[1]; /* memory pools */ void *pv_rset; /* real rset (s/w partition) */ /* process statistics */ unsigned long long pv_nframes; /* accounting page frames */ unsigned long long pv_npsblks; /* accounting paging space blocks */ unsigned long long pv_nvpages; /* accounting virtual mem pages */ /* misc fields */ struct kernext_svc *pv_asyncio; tid_t pv_chksynch; /* event list for checkpoint */ struct pvthread *pv_chktv; /* pointer to adv handler pvthread */ /* * Process CPU times. * * The process CPU counters are split into a process-level * counter, which is updated once per second, and a set * of group counters, which are updated in the tick handler. * The group counters are pointed to by pv_pnda and are * protected by pv_time_lock. See proc_private.h for how * to read and update them. * */ unsigned long long pv_totalcputime; /* cpu time for proc */ unsigned long long pv_totalscputime; /* sys time for proc */ DRW_lock pv_time_lock; /* counters lock */ void *pv_pnda; /* node/group counters */ unsigned long long pv_totaldiskio; /* 512 bytes blocks */ time_t pv_termtime; void *pv_gcipc; /* gencore IPC */ /* scheduler fields */ char pv_pri; /* process fixed priority */ char pv_policy; /* process policy */ /* Fields for advanced accounting */ short pv_acctflags; int pv_projid; /* project ID */ unsigned long long pv_subproj; /* load leveler subproject */ int pv_sprojid; /* Saved project ID */ int pv_arch; /* ACE WPAR architecture */ dev64_t pv_app_dev; /* application id: device no */ ino64_t pv_app_ino; /* inode number */ uint_t pv_app_gen; /* generation number */ int pv_pad1; /* Alignment pad. */ void *pv_ewlmproc; /* pointer to ewlm proc block */ struct prochr *pv_handlers; /* per-process handlers */ void *pv_cached_credp;/* Pointed to cached creds */ Simple_lock pv_handlers_lock;/* per-process handlers lock*/ unsigned long long pv_wlm_nvpages; /* wlm virtual pg accounting*/ ushort pv_bopflags; /* BOP flags */ ushort pv_bopmcnt; /* BOP violation counts */ ushort pv_flag3; /* disabled flag */ uchar pv_flag3e; /* enabled flag */ uchar pv_flag3p; /* procfs flag */ struct vm_xproc_data *pv_vmm_xproc_data; /* cross process data */ /* * Eye-catcher: this field must be the last field * of the structure. Please insert new fields above it. */ proc_eye_catch_t pv_eyec; /* pvproc eye-catcher */ cid_t pv_kcid; /* kernel corral identifier */ short pv_secflag; /* security flags */ ushort pv_cre_flags; /* cre flags */ cre_t pv_cre; /* cre level */ void *pv_mcrp; /* used for checkpoint */ void *pv_p11_ctx; /* used by PKCS#11 device driver */ ulong pv_nodegen; /* holds inode number and gen value * for privileged symlink scripts */ /* the first few vmpools worth of affinity accounting stats * are kept right in the pvproc... how many is determined by * maximum memory capacity */ #define MAXAFFSTAT_SM 8 #define MAXAFFSTAT_LG 4 union { int pv_aff_stat_int[MAXAFFSTAT_SM]; long pv_aff_stat_long[MAXAFFSTAT_LG]; } pv_af1; void *pv_aff_stat_ext; /* vmpool id >= MAXAFFSTAT */ uint64_t pv_ncpages; /* # of compressed pages */ uint_t pv_aso_state; /* Fields for setting environment state */ int pv_static_environment; struct pvproc *pv_sib_back; /* Back link for siblings */ tid_t pv_xproc_synch; /* event list for cross-process * access when process * is execing or restarting. */ struct pvthread *pv_zombies; /* zombie threads awaiting free */ int pv_si_status; /* full 32-bit exit status */ int pv_pad2; /* Alignment pad. */ unsigned long long pv_as_map; /* mmap and shmat AS usage*/ struct pvproc *pv_last_child; /* tail of list of children */ /* * When deciding on a pad amount for the pvproc structure, be sure * that the final size is not only a cache multiple, but a power of * 2 as well. This is a requirement of the NUMA sub-zone support. * This value is defined as PV_LOGSIZE for use by pmzone.h. */ #ifdef _POWER #ifdef __64BIT_KERNEL #define PV_PAD 52 #define PV_LOGSIZE 10 #endif /* __64BIT_KERNEL */ #endif /* _POWER */ #if PV_PAD int pv_pad[PV_PAD]; #endif }; #endif /* _32KERMODE */ #define pv_link pv_vpgrp /* any field not used when free */ #define pv_utime pv_ru.ru_utime.tv_sec #define pv_stime pv_ru.ru_stime.tv_sec #define p_rt_ticks p_clock.rt_ticks #define p_active_tmrs p_clock.active_tmrs /* * IMPORTANT NOTE : * * The following bit flags are ored together and reported via getprocs, * in core files, and by /proc, so their definitions must be disjoint. * p_flag * pv_flag * pv_flag3 (SNOSWAP, SFIXPRI) * p_atomic (SWTED, SFWTED, SEWTED, SLWTED) * pv_atomic (SORPHANPGRP, SPPNOCLDSTOP) * Other bits used in pi_flags are: * SGETUREGS: copied from SIGETUREGS in p_int * SPLOCK: based on U_lock * * Similarly the p_flag2 and pv_flag2 bits must also form disjoint sets. * * Some of the flags can be updated cross-process, so in general, pv_lock_d * must be held at INTMAX in order to update the flags. * * FLAG Cross-process? Lock? * ------------------------------------------------------------------- * p_flag No pv_lock_d if multi-threaded * pv_flag Yes pv_lock_d * p_flag2 Yes pv_lock_d * pv_flag2 Yes pv_lock_d * p_atomic Yes No. Atomic primitive needed. * pv_atomic Yes No. Atomic primitive needed. * p_int Yes pv_lock_d. Can be updated from interrupt level. * pv_flag3 Yes pv_lock_d * pv_flag3e Yes pv_lock * pv_flag3p No pv_lock to serialize with /proc, getprocs(),... * * In order to improve readability and the creation of new flags, there are * now "RESERVED" comments in the flags of each field where overlapping is * problematic. These sets are: 1) (p_flag, pv_flag, p_atomic, and pv_atomic) * and 2) (p_flag2 and pv_flag2). The comments only exist in the more commonly * modified structures (i.e., not p_atomic and pv_atomic), so if these * structures are modified, the other bits must be taken into account. As * new flags are added, they should be added into one set of flags (or both * if needed), and comments reserving them should be added to the other * structure(s). These comments take the form: * RESERVED() 0x * where is the name of the flag, is its hex value, and * is the field for which it is reserved. * * pvproc flags, pv_flag * * The SLOAD, SKPROC, and SEXIT flags are also set in p_flag. * The SPPNOCLDSTOP flag is also set in pv_atomic. */ #define SLOAD 0x00000001 /* user and uthread struct. pinned */ /* RESERVED(SNOSWAP) 0x00000002 pv_flag3 */ /* RESERVED(SFORKSTACK) 0x00000004 p_flag */ #define STRC 0x00000008 /* process being traced */ /* RESERVED(SWTED) 0x00000010 p_atomic */ /* RESERVED(SFWTED) 0x00000020 p_atomic */ /* RESERVED(SEWTED) 0x00000040 p_atomic */ /* RESERVED(SLWTED) 0x00000080 p_atomic */ /* RESERVED(SFIXPRI) 0x00000100 pv_flag3 */ #define SKPROC 0x00000200 /* Kernel processes */ #define SSIGNOCHLD 0x00000400 /* do send SIGCHLD on child's death*/ /* RESERVED(SSIGSET) 0x00000800 p_flag */ /* RESERVED(SXPG1170) 0x00001000 p_flag */ /* RESERVED(SGETUREGS) 0x00002000 pi_flags (copy of SIGETUREGS in p_int) */ #define STRACING 0x00004000 /* process is a debugger */ #define SMPTRACE 0x00008000 /* multi-process debugging */ #define SEXIT 0x00010000 /* process is exiting */ /* RESERVED(SLPDATA) 0x00020000 p_flag */ /* RES.(SORPHANPGRP) 0x00040000 pv_atomic */ #define STRCME 0x00080000 /* trace myself */ /* RES.(SPPNOCLDSTOP) 0x00100000 pv_atomic */ #define SEXECED 0x00200000 /* process has exec'd */ #define SHIGHRES 0x00400000 /* High resolution timer for thread*/ /* RESERVED (SRRMEMAFF) 0x00800000 p_flag */ /* RESERVED(SEXECING) 0x01000000 p_flag */ /* RES.(SPSEARLYALLOC) 0x04000000 p_flag */ /* RESERVED(SCONTINUED) 0x08000000 p_flag */ /* RESERFVED(SPLOCK) 0x10000000 pi_flags */ #define SFASTWATCH 0x20000000 /* fast watchpoint enabled */ #define SMOBILE 0x40000000 /* process is in mobile corral */ #define SLATENCY 0x80000000 /* process is latency sensitive */ #define PV_MOBILE(PV) ((PV)->pv_flag & SMOBILE) #define SET_PV_MOBILE(PV,TRUE) ((TRUE) ? ((PV)->pv_flag |= SMOBILE) : \ ((PV)->pv_flag &= ~SMOBILE)) /* * pvproc flags, pv_flag2 * * The S64BIT flag is also set in p_flag2. */ #define S64BIT 0x00000001 /* this is a 64-bit process */ #define SWAITPROC 0x00000002 /* This is waitproc (one per cpu) */ /* RESERVED(SFASTTRAP) 0x00000004 p_flag2 */ #define SSCHEDPROC 0x00000008 /* Slave scheduler (one per srad) */ #define SRESTART 0x00000010 /* restart in progress */ #define SPRIMARY 0x00000020 /* Primary checkpoint process */ #define SCHKPNTABLE 0x00000040 /* Checkpointable process (env var)*/ #define SRESTARTED 0x00000080 /* Restarted process */ #define SRESTARTING 0x00000100 /* Restarting process */ #define SCHKTRC 0x00000200 /* traced at checkpoint */ /* RESERVED(SRT_MPC) 0x00000400 p_flag2 */ /* RESERVED(SRT_GRQ) 0x00000800 p_flag2 */ /* RES.(SWP_SIGNALED) 0x00001000 p_flag2 */ #define SCRED 0x00002000 /* Per-thread credentials */ #define SCOREFILE 0x00004000 /* Core file created */ #define SCHKHANDLER 0x00008000 /* Has a checkpoint handler */ /* RESERVED(SDSA) 0x00010000 p_flag2 */ /* RESERVED(SCORENAME) 0x00020000 p_flag2 */ /* RESERVED(SPTHREADED) 0x00040000 p_flag2 */ /* RES.(SLPDATAMUST) 0x00080000 p_flag2 */ /* RESERVED(SMCMMEMAFF) 0x00100000 p_flag2 */ #define SPIDCRIT 0x00200000 /* Critical process - UE GARD */ #define SFORKCRIT 0x00400000 /* Critical process - UE GARD */ /* RES.(SFCONTINUED) 0x00800000 p_flag2 */ #define SNOCKPTSHM 0x01000000 /* NEVER checkpoint shared memory */ #define SINHERITED 0x02000000 /* init inherited on parent exit */ /* RES.(SCORE_MMAP) 0x04000000 p_flag2 */ /* RES.(SCORE_NOSHM) 0x08000000 p_flag2 */ #define SPV_HOLD 0x10000000 /* freeproc will free this slot */ #define SUKEYAWARE 0x20000000 /* process has user keys enabled */ #define SMPIJOB 0x40000000 /* MPI job (can use local RQ) */ #define STRAPSIG 0x80000000 /* ptrace trap handling */ /* * pvproc flags, pv_flag3 * * Miscellaneous flags updated under pv_lock_d. * (The SNOSWAP and SFIXPRI macros are also defined in procinfo.h and can't * be redefined.) */ #define SNOSWAP 0x00000002 /* process can't be swapped out */ #define SFIXPRI 0x00000100 /* fixed priority, ignoring p_cpu */ #define SKPROC2UPROC 0x0010 /* kproc becoming a user proc later */ #define SHACRITICAL 0x0020 /* Critical proc for HA/clustering */ #define SPS_CTL_BLOCKING 0x0040 /* Pollset_ctl() should be blocking */ #define SPS_CTL_NONBLOCKING 0x0080 /* Pollset_ctl() should be nonblocking */ #define SHOTSEGS 0x1000 /* vmm use */ #define SMARKSEGS 0x2000 /* vmm use */ #define SCHK_WAS_STOPPED 0x4000 /* Process was stopped at checkpoint * time. */ #define SKIO 0x8000 /* Kernel process doing I/O */ /* * pvproc flags, pv_flag3e * * Miscellaneous flags updated under pv_lock. * These flag can be updated cross-process. */ #define AHAFS_PROC_MON 0x01 #define AHAFS_PID_PROC_MON 0x02 #define ETRC_UFT_PROBE 0x04 /* Process is created by ProbeVue (-X option) */ /* * pvproc flags, pv_flag3p * * Flag for communicating with procfs. * Only set in context. pv_lock must be taken to serialize with procfs et al. */ #define SPOST_EXEC_P 0x01 #define SEXIT_P 0x02 #define SACTIVE_P 0x04 #define SACTIVEKPROC_P 0x08 #define SRESTARTING_P 0x10 #define SEXECING_P 0x20 /* * process flags, p_flag */ #define SLOAD 0x00000001 /* user and uthread struct. pinned */ /* RESERVED(SNOSWAP) 0x00000002 pv_flag */ #define SFORKSTACK 0x00000004 /* special fork stack is allocated */ /* RESERVED(STRC) 0x00000008 pv_flag */ /* RESERVED(SWTED) 0x00000010 p_atomic */ /* RESERVED(SFWTED) 0x00000020 p_atomic */ /* RESERVED(SEWTED) 0x00000040 p_atomic */ /* RESERVED(SLWTED) 0x00000080 p_atomic */ /* RESERVED(SFIXPRI) 0x00000100 pv_flag */ #define SKPROC 0x00000200 /* Kernel processes */ /* RESERVED(SSIGNOCHLD) 0x00000400 pv_flag */ #define SSIGSET 0x00000800 /* process uses the SVID sigset int*/ #define SXPG1170 0x00001000 /* XPG SPEC1170 behavior assumed */ /* RESERVED(SGETUREGS) 0x00002000 pi_flags (copy of SIGETUREGS in p_int) */ /* RESERVED(STRACING) 0x00004000 pv_flag */ /* RESERVED(SMPTRACE) 0x00008000 pv_flag */ #define SEXIT 0x00010000 /* process is exiting */ #define SLPDATA 0x00020000 /* large page data process */ /* RES.(SORPHANPGRP) 0x00040000 pv_atomic */ /* RESERVED STRCME 0x00080000 pv_flag */ /* RES.(SPPNOCLDSTOP) 0x00100000 pv_atomic */ /* RESERVED(SEXECED) 0x00200000 pv_flag */ /* RESERVED (SHIGHRES) 0x00400000 pv_flag */ #define SRRMEMAFF 0x00800000 /* Strict round robin mem alloc */ #define SEXECING 0x01000000 /* process is execing */ #define SETRACE 0x02000000 /* dynamic tracing process */ #define SPSEARLYALLOC 0x04000000 /* allocates paging space early */ #define SCONTINUED 0x08000000 /* process continued after stop */ /* RESERVED(SPLOCK) 0x10000000 pi_flags */ /* RESERVED(SFASTWATCH) 0x20000000 pv_flag */ /* RESERVED(SMOBILE) 0x40000000 pv_flag */ /* There are three slightly overlapping flags for indicating user heap * page size: SLPDATA, SLPDATA_MUST, U_datal2psize. * * U_datal2psize will always indicate the page size that should be * used for future heap allocations. This will be set to L2LGPSIZE * when SLPDATA is set as well as if new_uheap_psize() is used to set * future allocations to said size. * * SLPDATA indicates that the process was started as a "large page" * process, implying a distinct address space model. * * SLPDATA_MUST indicates that if there are no more large pages for an * allocation then fail (rather then silently using 4k pages). It is * turned on if new_uheap_psize() is used to set U_datal2psize to * L2LGPSIZE, as well as if flagged by the environment process * creation time. * * All of are inherited over fork() but not exec(). */ #define SLPDATA_SET(U) ((U)->U_procp->p_flag & SLPDATA) #define USE_LPDATA(U) (SLPDATA_SET(U) || ((U)->U_datal2psize == L2LGPSIZE)) /* * yet more process flags, p_flag2 */ #define S64BIT 0x00000001 /* this is a 64-bit process */ /* RESERVED(SWAITPROC) 0x00000002 pv_flag2 */ #define SFASTTRAP 0x00000004 /* fast trap capability enabled */ /* RESERVED(SSCHEDPROC) 0x00000008 pv_flag2 */ /* RESERVED(SRESTART) 0x00000010 pv_flag2 */ /* RESERVED(SPRIMARY) 0x00000020 pv_flag2 */ /* RES.(SCHKPNTABLE) 0x00000040 pv_flag2 */ /* RESERVED(SRESTARTED) 0x00000080 pv_flag2 */ /* RES.(SRESTARTING) 0x00000100 pv_flag2 */ /* RESERVED(SCHKTRC) 0x00000200 pv_flag2 */ #define SRT_MPC 0x00000400 /* RT kernel: send MPC to preempt */ #define SRT_GRQ 0x00000800 /* process stays on global run queue */ #define SWP_SIGNALED 0x00001000 /* sig posted for watchpoint hit */ /* RESERVED(SCRED) 0x00002000 pv_flag2 */ /* RESERVED(SCOREFILE) 0x00004000 pv_flag2 */ /* RES.(SCHKHANDLER) 0x00008000 pv_flag2 */ #define SDSA 0x00010000 /* 32-bit Dynamic Segment Allocation */ #define SCORENAME 0x00020000 /* Use new-style core name */ #define SPTHREADED 0x00040000 /* this is a pthreaded process */ #define SLPDATAMUST 0x00080000 /* mandatory large page data proc: * applies to POLY_HEAP_PSIZE & * standard large page data procs */ #define SMCMMEMAFF 0x00100000 /* mcm local memory allocation */ /* RESERVED(SPIDCRIT) 0x00200000 pv_flag2 */ /* RESERVED(SFORKCRIT) 0x00400000 pv_flag2 */ #define SFCONTINUED 0x00800000 /* was force continued */ /* RESERVED(SNOCKPTSHM) 0x01000000 pv_flag2 */ /* RESERVED(SINHERITED) 0x02000000 pv_flag2 */ #define SCORE_MMAP 0x04000000 /* dump non-anonymous mmap regions */ #define SCORE_NOSHM 0x08000000 /* do NOT dump SHM to corefile */ /* RESERVED(SPV_HOLD) 0x10000000 pv_flag2 */ /* RESERVED(SUKEYAWARE) 0x20000000 pv_flag2 */ /* RESERVED(SMPIJOB) 0x40000000 pv_flag2 */ /* RESERVED(STRAPSIG) 0x80000000 pv_flag2 */ #define SLPDATAMUST_SET(U) ((U)->U_procp->p_flag2 & SLPDATAMUST) /* * process flags, p_int */ #define SCORE 0x00000001 /* process is core dumping */ #define SCORE_DUMP 0x00000002 /* core dump is processing */ #define SRUNQ 0x00000004 /* runnable pthreads. */ #define SCHKPNT 0x00000008 /* checkpoint operation pending */ #define SJOBSTOP 0x00000010 /* used with SSUSP for job stop */ #define SPROCFS 0x00000020 /* used with SSUSP for procfs stop */ #define SPTRACE 0x00000040 /* used with SSUSP for ptrace stop */ #define SCHKPNTING 0x00000080 /* Process in checkpoint */ #define SPRFORK 0x00000100 /* procfs inherit-on-fork */ #define SPRKLC 0x00000200 /* procfs kill-on-last-close */ #define SPRRLC 0x00000400 /* procfs run-on-last-close */ #define SPRASYNC 0x00000800 /* procfs async thread stop */ #define SPROCTR 0x00001000 /* procfs syscall tracing active */ #define SPRJOBSIG 0x00002000 /* procfs jobcontrol trace active */ #define SPROBEVUE 0x00004000 /* probevue signal */ #define SVMMXPROC 0x00008000 /* vmm cross process request signal*/ #define SPROFIL 0x00010000 /* profile buffer filled up */ #define SJUSTBACKIN 0x00020000 /* process recently restarted */ #define SCHKPTSTOP 0x00040000 /* used with SSUSP for chkpt stop */ #define SLOWPSEXCP 0x00080000 /* psmgr chose me for an exception */ #define SWLM 0x00100000 /* wlm. send a message to the tty */ #define SWLMRMEM 0x00200000 /* wlm suspend process flag */ #define SWLMVMEM 0x00400000 /* wlm suspend process flag */ #define SWLMVMEMPROC 0x00800000 /* proc vmem wlm process flag */ #define SCORESTOP 0x01000000 /* coredump() called */ #define SPSMKILL 0x02000000 /* paging space mgr chose me to die*/ #define SNOFCONT 0x04000000 /* do not force continue process */ #define SIGETUREGS 0x08000000 /* save u regs on SVC */ #define STERM 0x10000000 /* process should be terminated */ #define SSUSP 0x20000000 /* suspend process in kmode/umode */ #define SSUSPUM 0x40000000 /* suspend process in umode */ #define SGETOUT 0x80000000 /* process should be swapped out */ /* * Collect all process-level stops that are reflected in p_int. */ #define SALLSTOPS (SJOBSTOP|SPROCFS|SPTRACE|SCORESTOP|SCHKPTSTOP) /* * This flag triggers a call to sig_slih. When changing these flags, * one must also change proc.m4. Moreover, the bits have to be consecutive * to work with rlinm. */ #define SSIGSLIH (STERM|SSUSP|SSUSPUM|SGETOUT) /* * process flags, pv_atomic */ #define SORPHANPGRP 0x00040000 /* orphaned process group */ #define SPPNOCLDSTOP 0x00100000 /* Do not send parent process */ /* SIGCHLD when a child stops */ /* * process flags, p_atomic */ #define SWTED 0x00000010 /* stopped while traced */ #define SFWTED 0x00000020 /* stopped after fork while traced */ #define SEWTED 0x00000040 /* stopped after exec while traced */ #define SLWTED 0x00000080 /* stopped after load/unload while */ #define UV_SYSCFG 0x00000400 /* syscfg mapping loaded */ #define UV_PZERO 0x00000800 /* page zero mapped */ #define SWLMTERMSENT 0x00001000 /* wlm: sigterm sent to the process */ /* * AACCT flags, pv_acctflags */ #define SPROJFIXED 0x0001 /* fixed project assignment */ #define SPROJAPP 0x0002 /* app specific project assignment */ #define SPROJINVOKE 0x0004 /* This process invoked the app */ #define SPROJABS 0x0008 /* This process has an absolute project */ /* * Fields for environment state, environment state */ #define SADJHIGRES 0x00000001 /* Environment to make processes to get */ /* high resolution timer for select/poll */ /* * process states, pv_stat */ #define SNONE 0 /* slot is available */ #define SIDL 4 /* process is created */ #define SZOMB 5 /* process is dying */ #define SSTOP 6 /* process is stopped */ #define SACTIVE 7 /* process is active */ #define SSWAP 8 /* process is swapped */ /* * For multiplication of fractions that are stored as integers, including * p_pctcpu. Not allowed to do floating point arithmetic in the kernel. */ #define SBITS 16 /* * security flags, pv_secflag */ #define SROOT 0x0001 /* root is enabled */ #define STRAUTH 0x0002 /* authorization tracing is enabled */ /* Flags for pi_flags in getprocs */ #define SGETUREGS 0x00002000 /* copy of SIGETUREGS in p_int */ #define SPLOCK 0x10000000 /* Based in U_lock */ /* * The following is used by proc_check. These must be updated if * flags are added/removed */ #define PROC_CHECKER_PFLAG SLOAD | SFORKSTACK | SKPROC | \ SSIGSET | SXPG1170 | \ SEXIT | SLPDATA | SRRMEMAFF | \ SEXECING | SPSEARLYALLOC | SCONTINUED | \ SETRACE #define PROC_CHECKER_PFLAG2 S64BIT | SFASTTRAP | SRT_MPC | \ SRT_GRQ | SWP_SIGNALED | SDSA | \ SCORENAME | SPTHREADED | SLPDATAMUST | \ SMCMMEMAFF | SFCONTINUED | SCORE_MMAP | \ SCORE_NOSHM #define PROC_CHECKER_PINT SCORE | SCORE_DUMP | SRUNQ | SCHKPNT | \ SJOBSTOP | SPROCFS | SPTRACE | SCHKPNTING | \ SPRFORK | SPRKLC | SPRRLC | SPRASYNC | \ SPROCTR | SPRJOBSIG | SPROFIL | SJUSTBACKIN | \ SCHKPTSTOP | SLOWPSEXCP | SWLM | SWLMRMEM | \ SWLMVMEM | SWLMVMEMPROC | SCORESTOP | \ SPSMKILL | SNOFCONT |STERM | SSUSP | \ SSUSPUM | SGETOUT | SPROBEVUE | SVMMXPROC | SIGETUREGS #define PROC_CHECKER_PATOMIC SWTED | SFWTED | SEWTED | SLWTED | UV_SYSCFG | \ UV_PZERO | SWLMTERMSENT #define PROC_CHECKER_PVATOMIC SORPHANPGRP|SPPNOCLDSTOP #define PROC_CHECKER_PVFLAG SLOAD | STRC | STRCME | SKPROC | SMOBILE | \ SSIGNOCHLD |STRACING | SMPTRACE | SEXIT | \ SEXECED | SPPNOCLDSTOP | SFASTWATCH | SHIGHRES | \ SLATENCY #define PROC_CHECKER_PVFLAG2 S64BIT | SWAITPROC | SSCHEDPROC | SRESTART | \ SPRIMARY | SCHKPNTABLE | SRESTARTED | \ SRESTARTING | SCHKTRC | SCRED | SCOREFILE | \ SCHKHANDLER |SPIDCRIT | SFORKCRIT | \ SNOCKPTSHM | SINHERITED | SPV_HOLD | \ SUKEYAWARE | SMPIJOB | STRAPSIG #define PROC_CHECKER_PVFLAG3 SFIXPRI | SNOSWAP | SMARKSEGS | \ SHACRITICAL | SHOTSEGS | SKPROC2UPROC | \ SPS_CTL_BLOCKING | SPS_CTL_NONBLOCKING | \ SCHK_WAS_STOPPED | SKIO #define PROC_CHECKER_PVFLAG3e AHAFS_PROC_MON | AHAFS_PID_PROC_MON | \ ETRC_UFT_PROBE #define PROC_CHECKER_PVFLAG3p SPOST_EXEC_P | SEXIT_P | SACTIVE_P | \ SRESTARTING_P | SEXECING_P | SACTIVEKPROC_P #define PROC_CHECKER_PVWLM SWLMRSET | SWLMRSETFAIL | SWLMTAGINHERITFORK | \ SWLMTAGINHERITEXEC | SWLMMANUALSUPERROOT | \ SWLMMANUALSUPERAUTH | SWLMMANUALSUBROOT | \ SWLMMANUALSUBADMIN | SWLMMANUALSUBAUTH | \ SWLMNOINHERIT | SWLMSESSIONACCOUNTED | \ SWLMPROCTAGGED | SWLMPROCACCOUNTED | \ SWLMTHRDTAGGEDINPRC #define PROC_CHECKER_PVACCTFLAG SPROJFIXED | SPROJAPP | SPROJINVOKE | SPROJABS /* * Flags in p_asoflags used by Active System Optimizer. */ #define ASO_FLAGS_MASK (ASOENABLEALWAYS | ASOENABLENEVER | \ ASOCUSTOMOPTS | ASOCUST_ALL | \ ASORSET_DEL_ATT | ASORSET_DELEXEC) /* * Flags/state in p_caccel_flags used by Coherent Accelerator (CAPI) procs */ #define PCACCEL 0x00000001 #define PCACCEL_TERM 0x00000002 /* * Defines and macros for use with process table entries */ #define PIDRESERVED 6 /* number of bits reserved in pid */ #define PROCSHIFT 18 /* number of bits in proc index */ #define PGENSHIFT 8 /* proc index offset */ #define PGENMASK ((1<> (PGENSHIFT+PZONESHIFT)) | \ ((pid) & 1)) /* mask for pid from process table idx */ #define PIDGEN(idx) \ (((((idx) & (PIDXMASK)) << (PZONESHIFT)) | \ (((idx) & (PZONEMASK<> PIDXSHIFT)) << PGENSHIFT) #ifdef _KERNEL extern struct pvproc pvproc[NPROC]; /* the process table, itself */ /* convert pid to proc pointer */ #define PVPROCPTR(pid) (&pvproc[PROCMASK(pid)]) /* validate whether a process id is valid or not */ #ifndef _KERNSYS #define PID_VALIDATE(pid) \ ((((ulong)pid >= PIDMAX+1) || \ (PVPROCPTR((pid&PIDMAX)) >= (struct pvproc *)pvproc_cb.primary \ [PROCMASK((pid&PIDMAX))>>PIDXSHIFT]->highwater_addr) || \ (PVPROCPTR((pid&PIDMAX))->pv_pid != (pid))) ? \ NULL : PVPROCPTR((pid&PIDMAX))) #endif /* determine if a process is multi-threaded given a procp or threadp */ #define MTHREAD(p) ( (p)->p_active > 1 ) #define MTHREADT(t) ( (t)->t_procp->p_active > 1 ) /* pv_lock hierarchy based on address */ #define PV_LOCK_2(pv1,pv2) \ { \ if ((ulong) pv1 < (ulong) pv2) { \ simple_lock(&pv1->pv_lock); \ simple_lock(&pv2->pv_lock); \ } else if ((ulong) pv2 < (ulong) pv1) { \ simple_lock(&pv2->pv_lock); \ simple_lock(&pv1->pv_lock); \ } else { \ simple_lock(&pv1->pv_lock); \ } \ } #define PV_UNLOCK_2(pv1,pv2) \ { \ if ((ulong) pv1 != (ulong) pv2) { \ simple_unlock(&pv1->pv_lock); \ simple_unlock(&pv2->pv_lock); \ } else { \ simple_unlock(&pv1->pv_lock); \ } \ } #endif /* _KERNEL */ #ifdef _KERNSYS #define CHECKPOINTABLE(_pv) ((_pv)->pv_flag2 & SCHKPNTABLE) #endif #define P_NICE_DEFAULT (NZERO+PUSER) /* default value for p_nice */ #define P_NICE_MAX 40 /* maximum nice value */ #define P_NICE_MIN 0 /* minimum nice value */ #define EXTRACT_NICE(p) \ (((p)->p_pvprocp->pv_flag3 & SFIXPRI) ? \ (P_NICE_MAX + 1) : ((p)->p_nice - PUSER)) #define SET_NICE(p,n) \ { \ if (!((p)->p_pvprocp->pv_flag3 & SFIXPRI)) { \ (p)->p_nice = (MIN(P_NICE_MAX,MAX(0,(n)))) + PUSER; \ } \ } /* global locks - listed in precedence */ extern Simple_lock crid_lock; extern Simple_lock ptrace_lock; extern Complex_lock core_lock; extern Simple_lock time_lock; /* pv_lock */ extern Simple_lock uidinfo_lock; /* tod_lock */ extern Simple_lock uex_lock; /* event_list_lock's and slist_list_lock's are peers */ /* p_lock_d's */ extern Simple_lock suspending_q_lock; /* run_queue_lock's, suspending_q_lock, and vmm wait_list_lock's are peers */ /* * Structures for resource intialization/termination handlers */ struct proch { struct proch *next; /* next pointer */ void (*handler)(); /* function to be called */ }; /* Defines to pass the resource handlers */ #define PROCH_INITIALIZE 1 #define PROCH_TERMINATE 2 #define PROCH_SWAPOUT 3 /* process is being swapped out. It's */ /* u block is still pinned. Interrupts */ /* are enabled */ #define PROCH_SWAPIN 4 /* process is being made runnable. It's */ /* u block has been pinned , but it has*/ /* not been put on a 'ready to run' */ /* queue. Interrupts are enabled. */ #define PROCH_EXEC 5 #define PROCH_LOAD 6 /* load module notification */ #define PROCH_UNLOAD 7 /* unload module notification */ #define THREAD_INITIALIZE 11 #define THREAD_TERMINATE 12 #define PROCH_SETUID 13 /* setuid notification, only supported */ /* on proch_reg() resource handlers */ #define PROCH_SETGID 14 /* setgid notification, only supported */ /* on proch_reg() resource handlers */ #define PROCH_EXECEXIT 15 /* exec exit notification. Called */ /* near the end of exec processing when */ /* preparing to exit the kernel and */ /* give control to the exec'ed program. */ /* Called when the exec has been */ /* successful and the new program has */ /* loaded. Only supported on */ /* proch_reg() resource handlers. */ #define PROCH_RESTART 16 /* Called at the end of restart before */ /* the process's checkpointed state is */ /* resumed. The primary process goes */ /* through this first, then all the */ /* secondary processes. Only supported */ /* on proch_reg() resource handlers */ /* All above are also supported with proch_reg_process resource handlers */ #define THREAD_LOCAL_INIT 17 /* Called when a pthread first gets */ /* created and dispatched to run on a */ /* kernel thread. Only supported on */ /* proch_reg_process() resource */ /* handlers */ #define THREAD_LOCAL_TERM 18 /* Called when an M:N pthread exits */ /* Only supported on proch_reg_process */ /* resource handlers */ #define THREAD_LOCAL_DISPATCH 19 /* Called when an M:N pthread has */ /* dispatched to run on a kernel thread */ /* Only supported on proch_reg_process */ /* resource handlers */ #define THREAD_LOCAL_MCHANGE 20 /* Called when a pthread scope changes */ /* Only supported on proch_reg_process */ /* resource handlers */ /* UE-Gard */ #define NONCRITFORK 1 /* * You can also register resource handlers with proch_reg(struct prochr*, mask). * In this case, you also register for the situations during which your * handler is called with a combination of the bits defined here. * These bits must be placed in prochr_mask before calling proch_reg(). * (The defined relationship of the prochr bit being the proch numbered bit * in a mask must be preserved here. The kernel code is based on this.) * * Do not change the contents of the prochr structure after registering it. * It may appear that you can dynamically change the mask, but this is not * supported. Once a prochr structure has been registered, the only valid * operation that may be performed upon it is to proch_unreg() it. */ struct prochr { struct prochr *prochr_next; /* next pointer */ void (*prochr_handler)(); /* function to be called */ uint prochr_mask; /* conditions under which to call */ int pad; /* padding for structure */ }; /* * Structure passed by reference to PROCHR_EXECEXIT handler */ typedef struct prochr_execexit { int len; /* length of prochr_execexit struct */ dev_t dev; /* device id of exec'ed file */ ino_t ino; /* inode number of exec'ed file */ uint_t gen; /* generation number of exec'ed file */ } prochr_execexit_t; #define PROCHR_INITIALIZE (1UL<pv_cre == CRE_AIX_52S) /* Macro to determine whether application uses AIX 5.3 runtime environment */ #define PV_CRE_53(pv) (VWPAR_VR_LVL((pv)->pv_cre) == CRE_AIX_53) #endif /* * Function prototypes for kernel extension. * The 64bit kernel always defines with full prototypes. */ #ifdef _KERNEL extern int proch_reg(struct prochr *); extern int proch_unreg(struct prochr *); extern int proch_reg_process(pid_t, struct prochr *); extern int proch_unreg_process(pid_t, struct prochr *); #if defined(__64BIT_KERNEL) || defined(__FULL_PROTO) extern void prochadd(struct proch *); extern void prochdel(struct proch *); extern int initp(pid_t, int (*)(), char *, int32long64_t, char[]); extern pid_t creatp(void); extern void freep(pid_t pid); extern int setpinit(void); extern int setpswap(void); extern pid_t getpid(void); extern pid_t getppidx(pid_t pid); extern int getuerror(void); extern int setuerror(int errno); extern void ut_set_cancelable(void); extern int setjmpx(label_t *); extern void clrjmpx(label_t *); extern int longjmpx(int); extern void setsid2(void); extern int ue_proc_check(pid_t pid); #endif /* (__64BIT_KERNEL || __FULL_PROTO) */ #endif /* _KERNEL */ /* * proc_getattr and proc_setattr are APIs that allow a privileged * user to set/unset attributes of any process (including self) */ #define PA_IGNORE 0 #define PA_ENABLE 1 #define PA_DISABLE 2 typedef struct { uchar core_naming; /* Unique core file name */ uchar core_mmap; /* Dump mmap'ed regions in core file */ uchar core_shm; /* Dump shared memory regions in core file */ uchar aixthread_hrt;/* Enable high res timers */ uchar ha_critical; /* Process is critical to HA */ } procattr_t; extern int proc_getattr(pid_t pid, procattr_t *attr, uint32_t attrsize); extern int proc_setattr(pid_t pid, procattr_t *attr, uint32_t attrsize); /* * p_pctcpu is a floating point number represented as a ulong. It has * a range of [(2 ** 16 ) - 1, (2 ** -16) + 1]. To translate into a * floating point divide by (double)FLT_MODULO. */ #define FLT_MODULO (1<<16) /* * vpmctl defines */ /* vpmctl commands */ #define VPM_FOLD 1 /* Fold one/all cores */ #define VPM_UNFOLD 2 /* Unfold one/all cores */ #define VPM_GET_STATUS 3 /* Get fold status of one/all cores */ #define VPM_CMD_MAX VPM_GET_STATUS /* vpmctl flags */ #define VPM_LOGICAL_CPUID 0x0001 /* CPU id is logical cpu# */ #define VPM_BIND_CPUID 0x0002 /* CPU is of type bindid */ /* Return from VPM_GET_STATUS */ #define VPM_FOLDED 1 #define VPM_UNFOLDED 2 /* vpmctl errors (returned negative) */ #define VPM_ERR_DISABLED 1 /* vpmctl has been disabled */ #define VPM_ERR_FOLD_ENABLED 2 /* Automatic folding enabled. Disable using schedo -o vpm_fold_policy = 0 */ #define VPM_ERR_INVALID_CPUID 3 /* CPU id specified is invalid */ #define VPM_ERR_INVALID_BINDID 4 /* CPU id specified is invalid */ #define VPM_ERR_CPU_OFFLINE 5 /* CPU is offline */ #define VPM_ERR_INVALID_CMD 6 /* Invalid command specified */ #define VPM_ERR_SWITCH_CPU 7 /* Error while switching cpu */ #define VPM_ERR_FOLD_MASTER 8 /* Cannot fold master CPU */ #define VPM_ERR_NOPRIV 9 /* Insufficient RBAC privileges */ extern int vpmctl(uint, cpu_t, void *, uint); #ifdef __cplusplus } #endif #endif /* _H_PROC */