pollution: quot intmax_t quot; pollution: rem intmax_t rem; pollution: strtoimax static intmax_t strtoimax (const char * restrict __nptr, char ** restrict __endptr, int __base) { return __strtollmax (__nptr, __endptr, __base); } pollution: imaxabs extern intmax_t imaxabs (intmax_t); pollution: imaxdiv extern imaxdiv_t imaxdiv (intmax_t, intmax_t); pollution: strtoumax extern uintmax_t strtoumax (const char * restrict, char ** restrict, int); pollution: wcstoimax extern intmax_t wcstoimax (const wchar_t * restrict, wchar_t ** restrict, int ); pollution: wcstoumax extern uintmax_t wcstoumax (const wchar_t * restrict, wchar_t ** restrict, int); pollution: int8 typedef signed char int8; pollution: int16 typedef signed short int16; pollution: int32 typedef signed int int32; pollution: int64 typedef signed long long int64; pollution: u_int8 typedef unsigned char u_int8; pollution: u_int16 typedef unsigned short u_int16; pollution: u_int32 typedef unsigned int u_int32; pollution: u_int64 typedef unsigned long long u_int64; pollution: losigs unsigned int losigs; pollution: hisigs unsigned int hisigs; pollution: losigs pollution: hisigs unsigned int losigs, hisigs; pollution: ss_set uint64_t ss_set[4]; pollution: val unsigned int val[2]; pollution: val uint64_t val[2]; pollution: val int val[2]; pollution: quad typedef struct _quad { int val[2]; } quad; pollution: srval vmhandle_t srval; pollution: offset caddr_t offset; pollution: alloc ulong32int64_t alloc; pollution: srval vmhandle_t srval[16]; pollution: alloc uint_t alloc; pollution: srval uint_t srval[16]; pollution: BadAttr pollution: VirtAddr pollution: MR_ATTR_TYPE typedef enum _MR_ATTR_TYPE { BadAttr = 0, VirtAddr = 1 } MR_ATTR_TYPE; pollution: BadMem pollution: FreeMem pollution: IPLCB pollution: RMALLOC pollution: PM_HEAP pollution: RTAS_HEAP pollution: TCE_TABLE pollution: IO_SPACE pollution: HUGE_PAGE pollution: MR_LABEL_TYPE typedef enum _MR_LABEL_TYPE { BadMem = 0, FreeMem = 1, IPLCB = 2, RMALLOC = 3, PM_HEAP = 4, RTAS_HEAP = 5, TCE_TABLE = 6, IO_SPACE = 7, HUGE_PAGE = 8 } MR_LABEL_TYPE; pollution: mr_addr unsigned long long mr_addr; pollution: mr_size unsigned long long mr_size; pollution: mr_att unsigned char mr_att; pollution: mr_label unsigned char mr_label; pollution: mr_nodeid unsigned short mr_nodeid; pollution: mr_flags unsigned short mr_flags; pollution: reserved char reserved[2]; pollution: va_list typedef char * va_list; pollution: UniChar typedef ushort_t UniChar; pollution: UTF32Char typedef uint_t UTF32Char; pollution: uchar typedef uchar_t uchar; pollution: ushort typedef ushort_t ushort; pollution: uint typedef uint_t uint; pollution: ulong typedef ulong_t ulong; pollution: r int r[1]; pollution: physadr typedef physadr_t physadr; pollution: u_char typedef unsigned char u_char; pollution: u_short typedef unsigned short u_short; pollution: u_int typedef unsigned int u_int; pollution: u_long typedef unsigned long u_long; pollution: losigs unsigned int losigs; pollution: hisigs unsigned int hisigs; pollution: sigset struct sigset { unsigned int losigs; unsigned int hisigs; }; pollution: val unsigned int val[2]; pollution: fsid struct fsid { unsigned int val[2]; }; pollution: fid_len uint_t fid_len; pollution: fid_ino ino32_t fid_ino; pollution: fid_gen uint_t fid_gen; pollution: fid_x char fid_x[20 - (sizeof(ino32_t) + 2) - sizeof(uint_t)]; pollution: fileid struct fileid { uint_t fid_len; ino32_t fid_ino; uint_t fid_gen; char fid_x[20 - (sizeof(ino32_t) + 2) - sizeof(uint_t)]; }; pollution: fid_len uint_t fid_len; pollution: fid_data char fid_data[20]; pollution: fid struct fid { uint_t fid_len; char fid_data[20]; }; pollution: fid typedef struct fid fid_t; pollution: x char x[32]; pollution: fhandle struct fhandle { char x[32]; }; pollution: fhandle typedef struct fhandle fhandle_t; pollution: fh_fsid fsid_t fh_fsid; pollution: fileid pollution: fh_fid struct fileid fh_fid; pollution: filehandle struct filehandle { fsid_t fh_fsid; struct fileid fh_fid; }; pollution: word1 __ulong32_t word1; pollution: word2 __ulong32_t word2; pollution: word3 __ulong32_t word3; pollution: word4 __ulong32_t word4; pollution: unique_id struct unique_id { __ulong32_t word1; __ulong32_t word2; __ulong32_t word3; __ulong32_t word4; }; pollution: unique_id typedef struct unique_id unique_id_t; pollution: iov_base void *iov_base; pollution: iov_len size_t iov_len; pollution: iovec struct iovec { void *iov_base; size_t iov_len; }; pollution: iovec pollution: readv extern ssize_t readv(int, const struct iovec *, int); pollution: iovec pollution: writev extern ssize_t writev(int, const struct iovec *, int); pollution: iovec pollution: readvx extern ssize_t readvx(int, const struct iovec *, int, long); pollution: iovec pollution: writevx extern ssize_t writevx(int, const struct iovec *, int, long); pollution: iovec pollution: preadv extern ssize_t preadv(int, const struct iovec *, int, offset_t); pollution: iovec pollution: pwritev extern ssize_t pwritev(int, const struct iovec *, int, offset_t); pollution: total int total; pollution: used int used; pollution: s_vpn unsigned int s_vpn; pollution: rpn rpn_t *rpn; pollution: xmem_phys struct xmem_phys { int total; int used; unsigned int s_vpn; rpn_t *rpn; }; pollution: version short version; pollution: flag short flag; pollution: s struct { short version; short flag; } s; pollution: u1 union { vmhandle_t _subspace_id; uint _prexflags; } u1; pollution: xmem struct xmem *_orig_xmem; pollution: u2 union { vmhandle_t _subspace_id2; struct xmem *_orig_xmem; } u2; pollution: uaddr char *uaddr; pollution: xmem struct xmem { union { struct { short version; short flag; } s; int _aspace_id; } _u; union { vmhandle_t _subspace_id; uint _prexflags; } u1; union { vmhandle_t _subspace_id2; struct xmem *_orig_xmem; } u2; char *uaddr; }; pollution: xmem pollution: xmem_global extern struct xmem *xmem_global; pollution: location pollution: original pollution: newval pollution: xmem pollution: dp pollution: xmem_compare_and_swap_32 int xmem_compare_and_swap_32(int *location,int *original,int newval, struct xmem *dp); pollution: location pollution: original pollution: newval pollution: xmem pollution: dp pollution: xmem_compare_and_swap_64 int xmem_compare_and_swap_64(long long *location,long long *original, long long newval,struct xmem *dp); pollution: xmattach int xmattach(); pollution: vaddr pollution: count pollution: xmem pollution: dp pollution: segflag pollution: xmattach64 int xmattach64(unsigned long long vaddr, int count, struct xmem *dp, int segflag); pollution: xmbsterile int xmbsterile(); pollution: xm_ue_query long xm_ue_query(); pollution: xmattach_remio long xmattach_remio(); pollution: xmemin int xmemin(); pollution: xmemout int xmemout(); pollution: xmdetach int xmdetach(); pollution: xmemdma int xmemdma(); pollution: xmemacc int xmemacc(); pollution: xmemdma64 unsigned long long xmemdma64(); pollution: iovec pollution: uio_iov struct iovec *uio_iov; pollution: xmem pollution: uio_xmem struct xmem *uio_xmem; pollution: uio_iovcnt int32long64_t uio_iovcnt; pollution: uio_iovdcnt int32long64_t uio_iovdcnt; pollution: uio_offset offset_t uio_offset; pollution: uio_resid int32long64_t uio_resid; pollution: uio_segflg short uio_segflg; pollution: uio_fmode long uio_fmode; pollution: uio struct uio { struct iovec *uio_iov; struct xmem *uio_xmem; int32long64_t uio_iovcnt; int32long64_t uio_iovdcnt; offset_t uio_offset; int32long64_t uio_resid; short uio_segflg; long uio_fmode; }; pollution: uio typedef struct uio uio_t; pollution: UIO_READ pollution: UIO_WRITE pollution: UIO_READ_NO_MOVE pollution: UIO_WRITE_NO_MOVE pollution: UIO_PWRITE pollution: uio_rw enum uio_rw { UIO_READ, UIO_WRITE, UIO_READ_NO_MOVE, UIO_WRITE_NO_MOVE, UIO_PWRITE }; pollution: pid pid_t pid; pollution: tid tid_t tid; pollution: euid uid_t euid; pollution: egid gid_t egid; pollution: peercred_struct struct peercred_struct { pid_t pid; tid_t tid; uid_t euid; gid_t egid; }; pollution: pid pid32_t pid; pollution: tid tid_t tid; pollution: euid uid_t euid; pollution: egid gid_t egid; pollution: peercred_struct_32_64 struct peercred_struct_32_64 { pid32_t pid; tid_t tid; uid_t euid; gid_t egid; }; pollution: pid pid32_t pid; pollution: tid tid32_t tid; pollution: euid uid_t euid; pollution: egid gid_t egid; pollution: peercred_struct32 struct peercred_struct32 { pid32_t pid; tid32_t tid; uid_t euid; gid_t egid; }; pollution: pid pid32_t pid; pollution: tid tid64_t tid; pollution: euid uid_t euid; pollution: egid gid_t egid; pollution: peercred_struct64 struct peercred_struct64 { pid32_t pid; tid64_t tid; uid_t euid; gid_t egid; }; pollution: l_onoff int l_onoff; pollution: l_linger int l_linger; pollution: linger struct linger { int l_onoff; int l_linger; }; pollution: sa_len uchar_t sa_len; pollution: sa_family sa_family_t sa_family; pollution: sa_data char sa_data[14]; pollution: sockaddr struct sockaddr { uchar_t sa_len; sa_family_t sa_family; char sa_data[14]; }; pollution: msg_name void *msg_name; pollution: msg_namelen socklen_t msg_namelen; pollution: iovec pollution: msg_iov struct iovec *msg_iov; pollution: msg_iovlen int msg_iovlen; pollution: msg_control void *msg_control; pollution: msg_controllen socklen_t msg_controllen; pollution: msg_flags int msg_flags; pollution: msghdr struct msghdr { void *msg_name; socklen_t msg_namelen; struct iovec *msg_iov; int msg_iovlen; void *msg_control; socklen_t msg_controllen; int msg_flags; }; pollution: msghdr pollution: msg_hdr struct msghdr msg_hdr; pollution: msg_len unsigned int msg_len; pollution: mmsghdr struct mmsghdr { struct msghdr msg_hdr; unsigned int msg_len; }; pollution: cmsg_len socklen_t cmsg_len; pollution: cmsg_level int cmsg_level; pollution: cmsg_type int cmsg_type; pollution: cmsghdr struct cmsghdr { socklen_t cmsg_len; int cmsg_level; int cmsg_type; }; pollution: sockaddr pollution: naccept int naccept(int, struct sockaddr *restrict, socklen_t *restrict); pollution: sockaddr pollution: ngetpeername int ngetpeername(int, struct sockaddr *restrict, socklen_t *restrict); pollution: sockaddr pollution: ngetsockname int ngetsockname(int, struct sockaddr *restrict, socklen_t *restrict); pollution: sockaddr pollution: nrecvfrom ssize_t nrecvfrom(int, void *restrict, size_t, int, struct sockaddr *restrict, socklen_t *restrict); pollution: msghdr pollution: nrecvmsg ssize_t nrecvmsg(int, struct msghdr *, int); pollution: msghdr pollution: nsendmsg ssize_t nsendmsg(int, const struct msghdr *, int); pollution: sockaddr pollution: bind int bind(int, const struct sockaddr *, socklen_t); pollution: sockaddr pollution: connect int connect(int, const struct sockaddr *, socklen_t); pollution: getsockopt int getsockopt(int, int, int, void *restrict, socklen_t *restrict); pollution: listen int listen(int, int); pollution: recv ssize_t recv(int, void *, size_t, int); pollution: send ssize_t send(int, const void *, size_t, int); pollution: sockaddr pollution: sendto ssize_t sendto(int, const void *, size_t, int, const struct sockaddr *, socklen_t); pollution: setsockopt int setsockopt(int, int, int, const void *, socklen_t); pollution: shutdown int shutdown(int, int); pollution: socket int socket(int, int, int); pollution: socketpair int socketpair(int, int, int, int[2]); pollution: sockatmark int sockatmark(int); pollution: ss_family sa_family_t ss_family; pollution: sockaddr_storage struct sockaddr_storage { uchar_t __ss_len; sa_family_t ss_family; char __ss_pad1[((sizeof (int64_t)) - (sizeof(uchar_t) + sizeof(sa_family_t)))]; int64_t __ss_align; char __ss_pad2[(1280 - (sizeof(sa_family_t) + ((sizeof (int64_t)) - (sizeof(uchar_t) + sizeof(sa_family_t))) + (sizeof (int64_t))))]; }; pollution: sa_family u_short sa_family; pollution: sa_data char sa_data[14]; pollution: osockaddr struct osockaddr { u_short sa_family; char sa_data[14]; }; pollution: sp_family u_short sp_family; pollution: sp_protocol u_short sp_protocol; pollution: sockproto struct sockproto { u_short sp_family; u_short sp_protocol; }; pollution: msg_name caddr_t msg_name; pollution: msg_namelen int msg_namelen; pollution: iovec pollution: msg_iov struct iovec *msg_iov; pollution: msg_iovlen int msg_iovlen; pollution: msg_accrights caddr_t msg_accrights; pollution: msg_accrightslen int msg_accrightslen; pollution: omsghdr struct omsghdr { caddr_t msg_name; int msg_namelen; struct iovec *msg_iov; int msg_iovlen; caddr_t msg_accrights; int msg_accrightslen; }; pollution: header_data void *header_data; pollution: header_length uint_t header_length; pollution: file_descriptor int file_descriptor; pollution: file_size uint64_t file_size; pollution: file_offset uint64_t file_offset; pollution: file_bytes int64_t file_bytes; pollution: trailer_data void *trailer_data; pollution: trailer_length uint_t trailer_length; pollution: bytes_sent uint64_t bytes_sent; pollution: sf_parms struct sf_parms { void *header_data; uint_t header_length; int file_descriptor; uint64_t file_size; uint64_t file_offset; int64_t file_bytes; void *trailer_data; uint_t trailer_length; uint64_t bytes_sent; }; pollution: sf_parms pollution: send_file ssize_t send_file(int *, struct sf_parms *, uint_t); pollution: tv_sec time_t tv_sec; pollution: tv_usec suseconds_t tv_usec; pollution: timeval struct timeval { time_t tv_sec; suseconds_t tv_usec; }; pollution: tv_sec int32_t tv_sec; pollution: tv_usec int32_t tv_usec; pollution: timeval32 struct timeval32 { int32_t tv_sec; int32_t tv_usec; }; pollution: tv_sec int64_t tv_sec; pollution: tv_usec int32_t tv_usec; pollution: timeval64 struct timeval64 { int64_t tv_sec; int32_t tv_usec; }; pollution: tz_minuteswest int tz_minuteswest; pollution: tz_dsttime int tz_dsttime; pollution: timezone struct timezone { int tz_minuteswest; int tz_dsttime; }; pollution: timeval pollution: it_interval struct timeval it_interval; pollution: timeval pollution: it_value struct timeval it_value; pollution: itimerval struct itimerval { struct timeval it_interval; struct timeval it_value; }; pollution: itimerval pollution: getitimer extern int getitimer(int, struct itimerval *); pollution: itimerval pollution: itimerval pollution: setitimer extern int setitimer(int, const struct itimerval *restrict, struct itimerval *restrict); pollution: timeval pollution: gettimeofday extern int gettimeofday(struct timeval *restrict, void *restrict); pollution: timeval pollution: timezone pollution: settimeofday extern int settimeofday(struct timeval *, struct timezone *); pollution: timeval64 pollution: utimes64 extern int utimes64(const char *, const struct timeval64 *); pollution: timeval pollution: utimes extern int utimes(const char *, const struct timeval *); pollution: fds_bits long fds_bits[(65534/(sizeof(long) * 8)+1)]; pollution: fd_set pollution: fd_set typedef struct fd_set { long fds_bits[(65534/(sizeof(long) * 8)+1)]; } fd_set; pollution: tv_sec time_t tv_sec; pollution: tv_nsec long tv_nsec; pollution: timespec struct timespec { time_t tv_sec; long tv_nsec; }; pollution: timespec pollution: pselect extern int pselect(int, void *restrict, void *restrict, void *restrict, const struct timespec *restrict, const sigset_t *restrict); pollution: timeval extern int __fd_select(int, fd_set *restrict, fd_set *restrict, fd_set *restrict, struct timeval *restrict); pollution: timeval pollution: select static int select(int __fds, fd_set *restrict __readlist, fd_set *restrict __writelist, fd_set *restrict __exceptlist, struct timeval *restrict __timeout) { return __fd_select(__fds, __readlist, __writelist, __exceptlist, __timeout); } pollution: tv_sec time_t tv_sec; pollution: tv_nsec suseconds_t tv_nsec; pollution: tv_sec int32_t tv_sec; pollution: tv_nsec int32_t tv_nsec; pollution: tv_sec int64_t tv_sec; pollution: tv_nsec int32_t tv_nsec; pollution: it_interval struct timestruc_t it_interval; pollution: it_value struct timestruc_t it_value; pollution: it_interval struct timestruc32_t it_interval; pollution: it_value struct timestruc32_t it_value; pollution: it_interval struct timestruc64_t it_interval; pollution: it_value struct timestruc64_t it_value; pollution: flag int flag; pollution: tb_high unsigned int tb_high; pollution: tb_low unsigned int tb_low; pollution: timebasestruct typedef struct timebasestruct { int flag; unsigned int tb_high; unsigned int tb_low; } timebasestruct_t; pollution: read_real_time int read_real_time(timebasestruct_t *, size_t); pollution: mread_real_time int mread_real_time(timebasestruct_t *, size_t); pollution: read_wall_time int read_wall_time(timebasestruct_t *, size_t); pollution: time_base_to_time int time_base_to_time(timebasestruct_t *, size_t); pollution: s_addr in_addr_t s_addr; pollution: in_addr struct in_addr { in_addr_t s_addr; }; pollution: sin_len uchar_t sin_len; pollution: sin_family sa_family_t sin_family; pollution: sin_port in_port_t sin_port; pollution: in_addr pollution: sin_addr struct in_addr sin_addr; pollution: sin_zero uchar_t sin_zero[8]; pollution: sockaddr_in struct sockaddr_in { uchar_t sin_len; sa_family_t sin_family; in_port_t sin_port; struct in_addr sin_addr; uchar_t sin_zero[8]; }; pollution: ntohs uint16_t ntohs(uint16_t); pollution: htons uint16_t htons(uint16_t); pollution: ntohl uint32_t ntohl(uint32_t); pollution: htonl uint32_t htonl(uint32_t); pollution: version unsigned int version; pollution: number_of_streams unsigned int number_of_streams; pollution: platform_default_pd long long platform_default_pd; pollution: os_default_pd long long os_default_pd; pollution: dscr_version int dscr_version; pollution: dscr_control unsigned int dscr_control; pollution: dscr_smt long long dscr_smt[5]; pollution: dscr_mask long long dscr_mask; pollution: dscr_properties struct dscr_properties { unsigned int version; unsigned int number_of_streams; long long platform_default_pd; long long os_default_pd; int dscr_version; unsigned int dscr_control; long long dscr_smt[5]; long long dscr_mask; }; pollution: op pollution: buf_p pollution: size pollution: dscr_ctl int dscr_ctl(int op, void *buf_p, int size); pollution: ue_load uint64_t ue_load(void *); pollution: ue_query void *ue_query(void *, unsigned long); pollution: ntohll uint64_t ntohll(uint64_t); pollution: htonll uint64_t htonll(uint64_t); pollution: u6_addr32 u_int32_t u6_addr32[4]; pollution: u6_addr16 u_int16_t u6_addr16[8]; pollution: u6_addr8 u_int8_t u6_addr8[16]; pollution: u6_addr union { u_int32_t u6_addr32[4]; u_int16_t u6_addr16[8]; u_int8_t u6_addr8[16]; } u6_addr; pollution: in6_addr struct in6_addr { union { u_int32_t u6_addr32[4]; u_int16_t u6_addr16[8]; u_int8_t u6_addr8[16]; } u6_addr; }; pollution: sin6_len u_char sin6_len; pollution: sin6_family u_char sin6_family; pollution: sin6_port u_int16_t sin6_port; pollution: sin6_flowinfo u_int32_t sin6_flowinfo; pollution: in6_addr pollution: sin6_addr struct in6_addr sin6_addr; pollution: sin6_scope_id uint32_t sin6_scope_id; pollution: sockaddr_in6 struct sockaddr_in6 { u_char sin6_len; u_char sin6_family; u_int16_t sin6_port; u_int32_t sin6_flowinfo; struct in6_addr sin6_addr; uint32_t sin6_scope_id; }; pollution: sin_len u_char sin_len; pollution: sin_family u_char sin_family; pollution: sin_num u_short sin_num; pollution: sin_data char sin_data[12]; pollution: sockaddr_inds struct sockaddr_inds { u_char sin_len; u_char sin_family; u_short sin_num; char sin_data[12]; }; pollution: in_addr pollution: ip_dst struct in_addr ip_dst; pollution: ip_opts char ip_opts[40]; pollution: ip_opts struct ip_opts { struct in_addr ip_dst; char ip_opts[40]; }; pollution: in_addr pollution: imr_multiaddr struct in_addr imr_multiaddr; pollution: in_addr pollution: imr_interface struct in_addr imr_interface; pollution: ip_mreq struct ip_mreq { struct in_addr imr_multiaddr; struct in_addr imr_interface; }; pollution: in6_addr pollution: ipv6mr_multiaddr struct in6_addr ipv6mr_multiaddr; pollution: ipv6mr_interface unsigned int ipv6mr_interface; pollution: ipv6_mreq struct ipv6_mreq { struct in6_addr ipv6mr_multiaddr; unsigned int ipv6mr_interface; }; pollution: in_addr pollution: imr_multiaddr struct in_addr imr_multiaddr; pollution: in_addr pollution: imr_sourceaddr struct in_addr imr_sourceaddr; pollution: in_addr pollution: imr_interface struct in_addr imr_interface; pollution: ip_mreq_source struct ip_mreq_source { struct in_addr imr_multiaddr; struct in_addr imr_sourceaddr; struct in_addr imr_interface; }; pollution: in6_addr pollution: ipv6mr_multiaddr struct in6_addr ipv6mr_multiaddr; pollution: in6_addr pollution: ipv6mr_interface struct in6_addr ipv6mr_interface; pollution: oipv6_mreq struct oipv6_mreq { struct in6_addr ipv6mr_multiaddr; struct in6_addr ipv6mr_interface; }; pollution: gr_interface uint32_t gr_interface; pollution: sockaddr_storage pollution: gr_group struct sockaddr_storage gr_group; pollution: group_req struct group_req { uint32_t gr_interface; struct sockaddr_storage gr_group; }; pollution: gsr_interface uint32_t gsr_interface; pollution: sockaddr_storage pollution: gsr_group struct sockaddr_storage gsr_group; pollution: sockaddr_storage pollution: gsr_source struct sockaddr_storage gsr_source; pollution: group_source_req struct group_source_req { uint32_t gsr_interface; struct sockaddr_storage gsr_group; struct sockaddr_storage gsr_source; }; pollution: isfr_if_type uint32_t isfr_if_type; pollution: isfr_if_index uint32_t isfr_if_index; pollution: in_addr pollution: isfr_if_iaddr struct in_addr isfr_if_iaddr; pollution: isfr_interface union { uint32_t isfr_if_index; struct in_addr isfr_if_iaddr; } isfr_interface; pollution: in_addr pollution: isfr_group struct in_addr isfr_group; pollution: isfr_fmode uint32_t isfr_fmode; pollution: isfr_numsrc uint32_t isfr_numsrc; pollution: in_addr pollution: isfr_slist struct in_addr isfr_slist[1]; pollution: ip_source_filter_req struct ip_source_filter_req { uint32_t isfr_if_type; union { uint32_t isfr_if_index; struct in_addr isfr_if_iaddr; } isfr_interface; struct in_addr isfr_group; uint32_t isfr_fmode; uint32_t isfr_numsrc; struct in_addr isfr_slist[1]; }; pollution: gsfr_if_index uint32_t gsfr_if_index; pollution: sockaddr_storage pollution: gsfr_group struct sockaddr_storage gsfr_group; pollution: gsfr_fmode uint32_t gsfr_fmode; pollution: gsfr_numsrc uint32_t gsfr_numsrc; pollution: sockaddr_storage pollution: gsfr_slist struct sockaddr_storage gsfr_slist[1]; pollution: group_source_filter_req struct group_source_filter_req { uint32_t gsfr_if_index; struct sockaddr_storage gsfr_group; uint32_t gsfr_fmode; uint32_t gsfr_numsrc; struct sockaddr_storage gsfr_slist[1]; }; pollution: ifi_name char ifi_name[16]; pollution: in_addr pollution: ifi_addr struct in_addr ifi_addr; pollution: ifi_type int ifi_type; pollution: buf_len int buf_len; pollution: mtus_list int *mtus_list; pollution: get_mtus struct get_mtus { int buf_len; int *mtus_list; }; pollution: mtu_value int mtu_value; pollution: next struct _mtu_node *next; pollution: mtu_node typedef struct _mtu_node { int mtu_value; struct _mtu_node *next; } mtu_node; pollution: in6_addr pollution: in6addr_any pollution: in6addr_loopback extern const struct in6_addr in6addr_any, in6addr_loopback; pollution: in6_addr pollution: ipi6_addr struct in6_addr ipi6_addr; pollution: ipi6_ifindex int ipi6_ifindex; pollution: in6_pktinfo struct in6_pktinfo { struct in6_addr ipi6_addr; int ipi6_ifindex; }; pollution: sockaddr_in6 pollution: ip6m_addr struct sockaddr_in6 ip6m_addr; pollution: ip6m_mtu uint32_t ip6m_mtu; pollution: ip6_mtuinfo struct ip6_mtuinfo { struct sockaddr_in6 ip6m_addr; uint32_t ip6m_mtu; }; pollution: inet6_rth_space socklen_t inet6_rth_space(int, int); pollution: inet6_rth_init void *inet6_rth_init(void *, socklen_t, int, int); pollution: in6_addr pollution: inet6_rth_add int inet6_rth_add(void *, const struct in6_addr *); pollution: inet6_rth_reverse int inet6_rth_reverse(const void *, void *); pollution: inet6_rth_segments int inet6_rth_segments(const void *); pollution: in6_addr pollution: inet6_rth_getaddr struct in6_addr *inet6_rth_getaddr(const void *, int); pollution: inet6_opt_init int inet6_opt_init(void *, socklen_t); pollution: inet6_opt_append int inet6_opt_append(void *, socklen_t, int, uint8_t, socklen_t, uint_t, void **); pollution: inet6_opt_finish int inet6_opt_finish(void *,socklen_t, int); pollution: inet6_opt_set_val int inet6_opt_set_val(void *, int, void *, socklen_t); pollution: inet6_opt_next int inet6_opt_next(void *, socklen_t, int, uint8_t *, socklen_t *, void **); pollution: inet6_opt_find int inet6_opt_find(void *, socklen_t, int, uint8_t, socklen_t *, void **); pollution: inet6_opt_get_val int inet6_opt_get_val(void *, int, void *, socklen_t); pollution: in_addr pollution: in_addr pollution: in_addr pollution: setipv4sourcefilter int setipv4sourcefilter(int, struct in_addr, struct in_addr, uint32_t, uint32_t, struct in_addr *); pollution: in_addr pollution: in_addr pollution: in_addr pollution: getipv4sourcefilter int getipv4sourcefilter(int, struct in_addr, struct in_addr, uint32_t *, uint32_t *, struct in_addr *); pollution: sockaddr pollution: sockaddr_storage pollution: setsourcefilter int setsourcefilter(int, uint32_t, struct sockaddr *, socklen_t, uint32_t, uint_t, struct sockaddr_storage *); pollution: sockaddr pollution: sockaddr_storage pollution: getsourcefilter int getsourcefilter(int, uint32_t, struct sockaddr *, socklen_t, uint32_t *, uint_t *, struct sockaddr_storage *); pollution: sockaddr pollution: bind2addrsel int bind2addrsel(int, const struct sockaddr *, socklen_t); pollution: sockaddr_in6 pollution: inet6_is_srcaddr short inet6_is_srcaddr(struct sockaddr_in6 *, uint32_t); pollution: ifnet struct ifnet; pollution: corral struct corral; pollution: socket struct socket; pollution: in_addr struct in_addr; pollution: ifnet struct ifnet; pollution: wlm_bounds struct wlm_bounds; pollution: sockaddr_in struct sockaddr_in; pollution: rtentry pollution: ro_rt struct rtentry *ro_rt; pollution: sockaddr pollution: ro_dst struct sockaddr ro_dst; pollution: route struct route { struct rtentry *ro_rt; struct sockaddr ro_dst; }; pollution: ip6_rtexpire_isr pollution: next struct ip6_rtexpire_isr *next; pollution: count int count; pollution: ip6_rtexpire_isr struct ip6_rtexpire_isr { struct ip6_rtexpire_isr *next; int count; }; pollution: pmtu_isr pollution: next struct pmtu_isr * next; pollution: val int val; pollution: rtentry pollution: rtp struct rtentry * rtp; pollution: operation int operation; pollution: pmtu_isr struct pmtu_isr { struct pmtu_isr * next; int val; struct rtentry * rtp; int operation; }; pollution: in6_addr pollution: pref struct in6_addr pref; pollution: in6_addr pollution: pmask struct in6_addr pmask; pollution: ip6_destcache_info struct ip6_destcache_info { struct in6_addr pref; struct in6_addr pmask; }; pollution: rmx_locks __ulong32_t rmx_locks; pollution: rmx_mtu __ulong32_t rmx_mtu; pollution: rmx_hopcount __ulong32_t rmx_hopcount; pollution: rmx_expire __ulong32_t rmx_expire; pollution: rmx_recvpipe __ulong32_t rmx_recvpipe; pollution: rmx_sendpipe __ulong32_t rmx_sendpipe; pollution: rmx_ssthresh __ulong32_t rmx_ssthresh; pollution: rmx_rtt __ulong32_t rmx_rtt; pollution: rmx_rttvar __ulong32_t rmx_rttvar; pollution: rmx_pksent __ulong32_t rmx_pksent; pollution: rt_metrics_new struct rt_metrics_new { __ulong32_t rmx_locks; __ulong32_t rmx_mtu; __ulong32_t rmx_hopcount; __ulong32_t rmx_expire; __ulong32_t rmx_recvpipe; __ulong32_t rmx_sendpipe; __ulong32_t rmx_ssthresh; __ulong32_t rmx_rtt; __ulong32_t rmx_rttvar; __ulong32_t rmx_pksent; }; pollution: rmx_locks __ulong32_t rmx_locks; pollution: rmx_mtu __ulong32_t rmx_mtu; pollution: rmx_hopcount __ulong32_t rmx_hopcount; pollution: rmx_expire __ulong32_t rmx_expire; pollution: rmx_recvpipe __ulong32_t rmx_recvpipe; pollution: rmx_sendpipe __ulong32_t rmx_sendpipe; pollution: rmx_ssthresh __ulong32_t rmx_ssthresh; pollution: rmx_rtt __ulong32_t rmx_rtt; pollution: rmx_rttvar __ulong32_t rmx_rttvar; pollution: rt_metrics struct rt_metrics { __ulong32_t rmx_locks; __ulong32_t rmx_mtu; __ulong32_t rmx_hopcount; __ulong32_t rmx_expire; __ulong32_t rmx_recvpipe; __ulong32_t rmx_sendpipe; __ulong32_t rmx_ssthresh; __ulong32_t rmx_rtt; __ulong32_t rmx_rttvar; }; pollution: permission short permission; pollution: gid gid_t gid; pollution: gidnode struct gidnode { short permission; gid_t gid; }; pollution: SINFINITY extern unsigned int SINFINITY; pollution: SQNAN extern unsigned int SQNAN; pollution: DQNAN extern unsigned int DQNAN[2]; pollution: SSNAN extern unsigned int SSNAN; pollution: DSNAN extern unsigned int DSNAN[2]; pollution: fp_read_rnd fprnd_t fp_read_rnd(void); pollution: rnd pollution: fp_swap_rnd fprnd_t fp_swap_rnd(fprnd_t rnd); pollution: inuse int inuse; pollution: gidnode pollution: gids struct gidnode gids[2048]; pollution: gidstruct struct gidstruct { int inuse; struct gidnode gids[2048]; }; pollution: inuse int inuse; pollution: gidnode pollution: gids struct gidnode gids[32]; pollution: gidstruct_compat struct gidstruct_compat { int inuse; struct gidnode gids[32]; }; pollution: pinfo_cnt int32_t pinfo_cnt; pollution: pinfo_policy int32_t pinfo_policy; pollution: pinfo_lu_index int32_t pinfo_lu_index; pollution: lu_index_usecnt int32_t lu_index_usecnt; pollution: prfn_lcnt int32_t prfn_lcnt; pollution: prfn_mcnt int32_t prfn_mcnt; pollution: prfn_hcnt int32_t prfn_hcnt; pollution: rtentry pollution: pinfo_rtptr struct rtentry *pinfo_rtptr[256]; pollution: policystruct struct policystruct { int32_t pinfo_cnt; int32_t pinfo_policy; int32_t pinfo_lu_index; int32_t lu_index_usecnt; int32_t prfn_lcnt; int32_t prfn_mcnt; int32_t prfn_hcnt; struct rtentry *pinfo_rtptr[256]; }; pollution: ifnet pollution: ifp struct ifnet *ifp; pollution: sockaddr_in6 pollution: target struct sockaddr_in6 target; pollution: ip6_ndsol_info struct ip6_ndsol_info { struct ifnet *ifp; struct sockaddr_in6 target; }; pollution: radix_mask struct radix_mask; pollution: radix_mask pollution: rn_mklist struct radix_mask *rn_mklist; pollution: radix_node pollution: rn_p struct radix_node *rn_p; pollution: rn_b short rn_b; pollution: rn_bmask char rn_bmask; pollution: rn_flags u_char rn_flags; pollution: rn_Key caddr_t rn_Key; pollution: rn_Mask caddr_t rn_Mask; pollution: radix_node pollution: rn_Dupedkey struct radix_node *rn_Dupedkey; pollution: rn_leaf struct { caddr_t rn_Key; caddr_t rn_Mask; struct radix_node *rn_Dupedkey; } rn_leaf; pollution: rn_Off int rn_Off; pollution: radix_node pollution: rn_L struct radix_node *rn_L; pollution: radix_node pollution: rn_R struct radix_node *rn_R; pollution: rn_node struct { int rn_Off; struct radix_node *rn_L; struct radix_node *rn_R; }rn_node; pollution: rn_u union { struct { caddr_t rn_Key; caddr_t rn_Mask; struct radix_node *rn_Dupedkey; } rn_leaf; struct { int rn_Off; struct radix_node *rn_L; struct radix_node *rn_R; }rn_node; } rn_u; pollution: radix_node struct radix_node { struct radix_mask *rn_mklist; struct radix_node *rn_p; short rn_b; char rn_bmask; u_char rn_flags; union { struct { caddr_t rn_Key; caddr_t rn_Mask; struct radix_node *rn_Dupedkey; } rn_leaf; struct { int rn_Off; struct radix_node *rn_L; struct radix_node *rn_R; }rn_node; } rn_u; }; pollution: rm_b short rm_b; pollution: rm_unused char rm_unused; pollution: rm_flags u_char rm_flags; pollution: radix_mask pollution: rm_mklist struct radix_mask *rm_mklist; pollution: rmu_mask caddr_t rmu_mask; pollution: radix_node pollution: rmu_leaf struct radix_node *rmu_leaf; pollution: rm_rmu union { caddr_t rmu_mask; struct radix_node *rmu_leaf; } rm_rmu; pollution: rm_refs int rm_refs; pollution: radix_mask pollution: rn_mkfreelist extern struct radix_mask { short rm_b; char rm_unused; u_char rm_flags; struct radix_mask *rm_mklist; union { caddr_t rmu_mask; struct radix_node *rmu_leaf; } rm_rmu; int rm_refs; } *rn_mkfreelist; pollution: flags ulong flags; pollution: gidstruct pollution: gidlist struct gidstruct *gidlist; pollution: ifnet pollution: ifp struct ifnet *ifp; pollution: cost __ulong32_t *cost; pollution: policy int policy; pollution: weight int weight; pollution: kcid cid_t kcid; pollution: preference int preference; pollution: pktsent __ulong32_t pktsent; pollution: rtreq_parm struct rtreq_parm { ulong flags; struct gidstruct *gidlist; struct ifnet *ifp; __ulong32_t *cost; int policy; int weight; cid_t kcid; int preference; __ulong32_t pktsent; }; pollution: radix_node pollution: rnh_treetop struct radix_node *rnh_treetop; pollution: rnh_addrsize int rnh_addrsize; pollution: rnh_pktsize int rnh_pktsize; pollution: radix_node pollution: v pollution: mask pollution: radix_node_head pollution: head pollution: radix_node pollution: nodes pollution: g pollution: rtreq_parm pollution: rnh_addaddr struct radix_node *(*rnh_addaddr) (void *v, void *mask, struct radix_node_head *head, struct radix_node nodes[], void *g, struct rtreq_parm *); pollution: radix_node pollution: v pollution: mask pollution: radix_node_head pollution: head pollution: radix_node pollution: nodes pollution: rnh_addpkt struct radix_node *(*rnh_addpkt) (void *v, void *mask, struct radix_node_head *head, struct radix_node nodes[]); pollution: radix_node pollution: v pollution: mask pollution: radix_node_head pollution: head pollution: gidstruct pollution: gidlist pollution: g pollution: ifnet pollution: ifp pollution: cost pollution: rnh_deladdr struct radix_node *(*rnh_deladdr) (void *v, void *mask, struct radix_node_head *head, struct gidstruct *gidlist, void *g, struct ifnet *ifp, __ulong32_t *cost, cid_t); pollution: radix_node pollution: v pollution: mask pollution: radix_node_head pollution: head pollution: rnh_delpkt struct radix_node *(*rnh_delpkt) (void *v, void *mask, struct radix_node_head *head); pollution: radix_node pollution: v pollution: radix_node_head pollution: head pollution: gidstruct pollution: gidlist pollution: rnh_matchaddr struct radix_node *(*rnh_matchaddr) (void *v, struct radix_node_head *head, struct gidstruct *gidlist, cid_t); pollution: radix_node pollution: v pollution: mask pollution: radix_node_head pollution: head pollution: gidstruct pollution: gidlist pollution: rnh_lookup struct radix_node *(*rnh_lookup) (void *v, void *mask, struct radix_node_head *head, struct gidstruct *gidlist, cid_t); pollution: radix_node pollution: v pollution: radix_node_head pollution: head pollution: rnh_matchpkt struct radix_node *(*rnh_matchpkt) (void *v, struct radix_node_head *head); pollution: radix_node_head pollution: head pollution: f pollution: w pollution: rnh_walktree int (*rnh_walktree) (struct radix_node_head *head, int (*f)(), void *w); pollution: radix_node pollution: rnh_nodes struct radix_node rnh_nodes[3]; pollution: radix_node_head struct radix_node_head { struct radix_node *rnh_treetop; int rnh_addrsize; int rnh_pktsize; struct radix_node *(*rnh_addaddr) (void *v, void *mask, struct radix_node_head *head, struct radix_node nodes[], void *g, struct rtreq_parm *); struct radix_node *(*rnh_addpkt) (void *v, void *mask, struct radix_node_head *head, struct radix_node nodes[]); struct radix_node *(*rnh_deladdr) (void *v, void *mask, struct radix_node_head *head, struct gidstruct *gidlist, void *g, struct ifnet *ifp, __ulong32_t *cost, cid_t); struct radix_node *(*rnh_delpkt) (void *v, void *mask, struct radix_node_head *head); struct radix_node *(*rnh_matchaddr) (void *v, struct radix_node_head *head, struct gidstruct *gidlist, cid_t); struct radix_node *(*rnh_lookup) (void *v, void *mask, struct radix_node_head *head, struct gidstruct *gidlist, cid_t); struct radix_node *(*rnh_matchpkt) (void *v, struct radix_node_head *head); int (*rnh_walktree) (struct radix_node_head *head, int (*f)(), void *w); struct radix_node rnh_nodes[3]; }; pollution: radix_node pollution: rt_nodes struct radix_node rt_nodes[2]; pollution: sockaddr pollution: rt_gateway struct sockaddr *rt_gateway; pollution: rt_redisctime short rt_redisctime; pollution: rt_refcnt ushort rt_refcnt; pollution: rt_flags u_long rt_flags; pollution: ifnet pollution: rt_ifp struct ifnet *rt_ifp; pollution: ifaddr pollution: rt_ifa struct ifaddr *rt_ifa; pollution: sockaddr pollution: rt_genmask struct sockaddr *rt_genmask; pollution: rt_llinfo caddr_t rt_llinfo; pollution: rt_metrics_new pollution: rt_rmx struct rt_metrics_new rt_rmx; pollution: rtentry pollution: rt_gwroute struct rtentry *rt_gwroute; pollution: rt_idle short rt_idle; pollution: ipRouteAge int ipRouteAge; pollution: rt_proto caddr_t rt_proto; pollution: gidstruct pollution: rt_gidlist struct gidstruct *rt_gidlist; pollution: rt_lock long rt_lock; pollution: rt_intr int rt_intr; pollution: rtentry pollution: rt_duplist struct rtentry *rt_duplist; pollution: policystruct pollution: policyinfo struct policystruct *policyinfo; pollution: rt_timer int rt_timer; pollution: rt_cost_config int rt_cost_config; pollution: pmtu_isr pollution: rt_pmtuisr struct pmtu_isr rt_pmtuisr; pollution: ip6_rtexpire_isr pollution: rt_ip6expireisr struct ip6_rtexpire_isr rt_ip6expireisr; pollution: rt_ip6sleepword tid_t rt_ip6sleepword; pollution: rt_weight int rt_weight; pollution: rt_kcid cid_t rt_kcid; pollution: rt_preference int rt_preference; pollution: rt_cache_origin caddr_t rt_cache_origin; pollution: rtentry struct rtentry { struct radix_node rt_nodes[2]; struct sockaddr *rt_gateway; short rt_redisctime; ushort rt_refcnt; u_long rt_flags; struct ifnet *rt_ifp; struct ifaddr *rt_ifa; struct sockaddr *rt_genmask; caddr_t rt_llinfo; struct rt_metrics_new rt_rmx; struct rtentry *rt_gwroute; short rt_idle; int ipRouteAge; caddr_t rt_proto; struct gidstruct *rt_gidlist; long rt_lock; int rt_intr; struct rtentry *rt_duplist; struct policystruct *policyinfo; int rt_timer; int rt_cost_config; struct pmtu_isr rt_pmtuisr; struct ip6_rtexpire_isr rt_ip6expireisr; tid_t rt_ip6sleepword; int rt_weight; cid_t rt_kcid; int rt_preference; caddr_t rt_cache_origin; }; pollution: rtp_eyecat eye_catch8b_t rtp_eyecat; pollution: rtentry pollution: rtp_rt struct rtentry rtp_rt; pollution: rtentry_plus pollution: rtp_next struct rtentry_plus *rtp_next; pollution: rtp_pindex int rtp_pindex; pollution: rtentry_plus struct rtentry_plus { eye_catch8b_t rtp_eyecat; struct rtentry rtp_rt; struct rtentry_plus *rtp_next; int rtp_pindex; }; pollution: rmx_pksent __ulong32_t rmx_pksent; pollution: rt_metrics_dummy struct rt_metrics_dummy { __ulong32_t rmx_pksent; }; pollution: rt_hash __ulong32_t rt_hash; pollution: sockaddr pollution: rt_dst struct sockaddr rt_dst; pollution: sockaddr pollution: rt_gateway struct sockaddr rt_gateway; pollution: rt_flags short rt_flags; pollution: rt_refcnt short rt_refcnt; pollution: rt_metrics_dummy pollution: rt_rmx struct rt_metrics_dummy rt_rmx; pollution: ifnet pollution: rt_ifp struct ifnet *rt_ifp; pollution: ortentry struct ortentry { __ulong32_t rt_hash; struct sockaddr rt_dst; struct sockaddr rt_gateway; short rt_flags; short rt_refcnt; struct rt_metrics_dummy rt_rmx; struct ifnet *rt_ifp; }; pollution: rts_badredirect short rts_badredirect; pollution: rts_dynamic short rts_dynamic; pollution: rts_newgateway short rts_newgateway; pollution: rts_unreach short rts_unreach; pollution: rts_wildcard short rts_wildcard; pollution: rtstat struct rtstat { short rts_badredirect; short rts_dynamic; short rts_newgateway; short rts_unreach; short rts_wildcard; }; pollution: rtm_msglen u_short rtm_msglen; pollution: rtm_version u_char rtm_version; pollution: rtm_type u_char rtm_type; pollution: rtm_index u_short rtm_index; pollution: rtm_pid int rtm_pid; pollution: rtm_addrs int rtm_addrs; pollution: rtm_seq int rtm_seq; pollution: rtm_errno int rtm_errno; pollution: rtm_flags int rtm_flags; pollution: rtm_use int rtm_use; pollution: rtm_inits __ulong32_t rtm_inits; pollution: rt_metrics pollution: rtm_rmx struct rt_metrics rtm_rmx; pollution: rt_msghdr struct rt_msghdr { u_short rtm_msglen; u_char rtm_version; u_char rtm_type; u_short rtm_index; int rtm_pid; int rtm_addrs; int rtm_seq; int rtm_errno; int rtm_flags; int rtm_use; __ulong32_t rtm_inits; struct rt_metrics rtm_rmx; }; pollution: rtm_msglen u_short rtm_msglen; pollution: rtm_version u_char rtm_version; pollution: rtm_type u_char rtm_type; pollution: rtm_index u_short rtm_index; pollution: rtm_pid int rtm_pid; pollution: rtm_addrs int rtm_addrs; pollution: rtm_seq int rtm_seq; pollution: rtm_errno int rtm_errno; pollution: rtm_flags int rtm_flags; pollution: rtm_use int rtm_use; pollution: rtm_inits __ulong32_t rtm_inits; pollution: rt_metrics pollution: rtm_rmx struct rt_metrics rtm_rmx; pollution: gidstruct_compat pollution: rtm_gidlist struct gidstruct_compat rtm_gidlist; pollution: newrt_msghdr_compat struct newrt_msghdr_compat { u_short rtm_msglen; u_char rtm_version; u_char rtm_type; u_short rtm_index; int rtm_pid; int rtm_addrs; int rtm_seq; int rtm_errno; int rtm_flags; int rtm_use; __ulong32_t rtm_inits; struct rt_metrics rtm_rmx; struct gidstruct_compat rtm_gidlist; }; pollution: rtm_msglen u_short rtm_msglen; pollution: rtm_version u_char rtm_version; pollution: rtm_type u_char rtm_type; pollution: rtm_index u_short rtm_index; pollution: rtm_pid int rtm_pid; pollution: rtm_addrs int rtm_addrs; pollution: rtm_seq int rtm_seq; pollution: rtm_errno int rtm_errno; pollution: rtm_flags int rtm_flags; pollution: rtm_use int rtm_use; pollution: rtm_inits __ulong32_t rtm_inits; pollution: rt_metrics pollution: rtm_rmx struct rt_metrics rtm_rmx; pollution: gidstruct pollution: rtm_gidlist struct gidstruct rtm_gidlist; pollution: newrt_msghdr struct newrt_msghdr { u_short rtm_msglen; u_char rtm_version; u_char rtm_type; u_short rtm_index; int rtm_pid; int rtm_addrs; int rtm_seq; int rtm_errno; int rtm_flags; int rtm_use; __ulong32_t rtm_inits; struct rt_metrics rtm_rmx; struct gidstruct rtm_gidlist; }; pollution: rtm_msglen u_short rtm_msglen; pollution: rtm_version u_char rtm_version; pollution: rtm_type u_char rtm_type; pollution: rtm_index u_short rtm_index; pollution: rtm_pid int rtm_pid; pollution: rtm_addrs int rtm_addrs; pollution: rtm_seq int rtm_seq; pollution: rtm_errno int rtm_errno; pollution: rtm_flags int rtm_flags; pollution: rtm_use int rtm_use; pollution: rtm_inits __ulong32_t rtm_inits; pollution: rt_metrics pollution: rtm_rmx struct rt_metrics rtm_rmx; pollution: gidstruct pollution: rtm_gidlist struct gidstruct rtm_gidlist; pollution: rtm_policy int rtm_policy; pollution: rtm_weight int rtm_weight; pollution: rt_msghdr_policy struct rt_msghdr_policy { u_short rtm_msglen; u_char rtm_version; u_char rtm_type; u_short rtm_index; int rtm_pid; int rtm_addrs; int rtm_seq; int rtm_errno; int rtm_flags; int rtm_use; __ulong32_t rtm_inits; struct rt_metrics rtm_rmx; struct gidstruct rtm_gidlist; int rtm_policy; int rtm_weight; }; pollution: rtm_msglen u_short rtm_msglen; pollution: rtm_version u_char rtm_version; pollution: rtm_type u_char rtm_type; pollution: rtm_index u_short rtm_index; pollution: rtm_pid int rtm_pid; pollution: rtm_addrs int rtm_addrs; pollution: rtm_seq int rtm_seq; pollution: rtm_errno int rtm_errno; pollution: rtm_flags int rtm_flags; pollution: rtm_use int rtm_use; pollution: rtm_inits __ulong32_t rtm_inits; pollution: rt_metrics pollution: rtm_rmx struct rt_metrics rtm_rmx; pollution: gidstruct pollution: rtm_gidlist struct gidstruct rtm_gidlist; pollution: rtm_policy int rtm_policy; pollution: rtm_weight int rtm_weight; pollution: rtm_kcid cid_t rtm_kcid; pollution: rt_msghdr_policy_ext struct rt_msghdr_policy_ext { u_short rtm_msglen; u_char rtm_version; u_char rtm_type; u_short rtm_index; int rtm_pid; int rtm_addrs; int rtm_seq; int rtm_errno; int rtm_flags; int rtm_use; __ulong32_t rtm_inits; struct rt_metrics rtm_rmx; struct gidstruct rtm_gidlist; int rtm_policy; int rtm_weight; cid_t rtm_kcid; }; pollution: rtm_msglen u_short rtm_msglen; pollution: rtm_version u_char rtm_version; pollution: rtm_type u_char rtm_type; pollution: rtm_index u_short rtm_index; pollution: rtm_pid int rtm_pid; pollution: rtm_addrs int rtm_addrs; pollution: rtm_seq int rtm_seq; pollution: rtm_errno int rtm_errno; pollution: rtm_flags int rtm_flags; pollution: rtm_use int rtm_use; pollution: rtm_inits __ulong32_t rtm_inits; pollution: rt_metrics pollution: rtm_rmx struct rt_metrics rtm_rmx; pollution: gidstruct pollution: rtm_gidlist struct gidstruct rtm_gidlist; pollution: rtm_policy int rtm_policy; pollution: rtm_weight int rtm_weight; pollution: rtm_kcid cid_t rtm_kcid; pollution: rtm_preference int rtm_preference; pollution: rt_msghdr_policy_prfn struct rt_msghdr_policy_prfn { u_short rtm_msglen; u_char rtm_version; u_char rtm_type; u_short rtm_index; int rtm_pid; int rtm_addrs; int rtm_seq; int rtm_errno; int rtm_flags; int rtm_use; __ulong32_t rtm_inits; struct rt_metrics rtm_rmx; struct gidstruct rtm_gidlist; int rtm_policy; int rtm_weight; cid_t rtm_kcid; int rtm_preference; }; pollution: sockaddr pollution: dst struct sockaddr *dst; pollution: active int active; pollution: dgd_arg struct dgd_arg { struct sockaddr *dst; int active; }; pollution: rti_addrs int rti_addrs; pollution: sockaddr pollution: rti_info struct sockaddr *rti_info[8]; pollution: rt_addrinfo struct rt_addrinfo { int rti_addrs; struct sockaddr *rti_info[8]; }; pollution: ip_count int ip_count; pollution: ns_count int ns_count; pollution: iso_count int iso_count; pollution: any_count int any_count; pollution: route_cb struct route_cb { int ip_count; int ns_count; int iso_count; int any_count; }; pollution: simple_lock_data typedef int32long64_t simple_lock_data; pollution: complex_lock_status typedef int32long64_t complex_lock_status; pollution: status complex_lock_status status; pollution: flags short flags; pollution: recursion_depth short recursion_depth; pollution: reserved uint_t reserved; pollution: complex_lock_data struct complex_lock_data { complex_lock_status status; short flags; short recursion_depth; uint_t reserved; }; pollution: status complex_lock_status status; pollution: drw_lock_data struct drw_lock_data { complex_lock_status status; }; pollution: s_lock simple_lock_data s_lock; pollution: complex_lock_data pollution: c_lock struct complex_lock_data c_lock; pollution: drw_lock_data pollution: drw_lock struct drw_lock_data drw_lock; pollution: lock_data_instrumented pollution: lock_next struct lock_data_instrumented *lock_next; pollution: lock_control_word union { simple_lock_data s_lock; struct complex_lock_data c_lock; struct drw_lock_data drw_lock; struct lock_data_instrumented *lock_next; } lock_control_word; pollution: li_flags unsigned int li_flags; pollution: reserved int reserved[1]; pollution: name long name; pollution: occurrence unsigned int occurrence; pollution: lock_data_instrumented struct lock_data_instrumented { union { simple_lock_data s_lock; struct complex_lock_data c_lock; struct drw_lock_data drw_lock; struct lock_data_instrumented *lock_next; } lock_control_word; unsigned int li_flags; int reserved[1]; union { long name; struct { unsigned int _id; unsigned int occurrence; } _lock_id; } _lockname; }; pollution: lock_data_instrumented struct lock_data_instrumented *_slockp; pollution: complex_lock_data struct complex_lock_data _clock; pollution: lock_data_instrumented struct lock_data_instrumented *_clockp; pollution: lock_data_instrumented struct lock_data_instrumented *_drwlockp; pollution: Simple_lock typedef union _simple_lock Simple_lock; pollution: Complex_lock typedef union _complex_lock Complex_lock; pollution: DRW_lock typedef union _drw_lock DRW_lock; pollution: read_status complex_lock_status read_status; pollution: fill char fill[120]; pollution: complex_upgraded_reader_data typedef struct complex_upgraded_reader_data { complex_lock_status read_status; char fill[120]; } complex_upgraded_reader_data_t; pollution: rdata complex_upgraded_reader_data_t rdata[4]; pollution: complex_upgraded_reader struct complex_upgraded_reader { complex_upgraded_reader_data_t rdata[4]; }; pollution: complex_upgraded_reader pollution: Reader_lock typedef struct complex_upgraded_reader Reader_lock; pollution: simple_lock void simple_lock(simple_lock_t); pollution: simple_lock_hot void simple_lock_hot(simple_lock_t); pollution: simple_unlock void simple_unlock(simple_lock_t); pollution: simple_unlock_mem void simple_unlock_mem(simple_lock_t); pollution: simple_unlock_hot void simple_unlock_hot(simple_lock_t); pollution: simple_lock_try boolean_t simple_lock_try(simple_lock_t); pollution: simple_dlock_timeout boolean_t simple_dlock_timeout(simple_lock_t,long); pollution: disable_lock int disable_lock(int,simple_lock_t); pollution: unlock_enable void unlock_enable(int,simple_lock_t); pollution: unlock_enable_mem void unlock_enable_mem(int,simple_lock_t); pollution: lock_init void lock_init(complex_lock_t , boolean_t); pollution: lock_write void lock_write(complex_lock_t); pollution: lock_read void lock_read(complex_lock_t); pollution: lock_done void lock_done(complex_lock_t); pollution: lock_done_mem void lock_done_mem(complex_lock_t); pollution: lock_read_to_write boolean_t lock_read_to_write(complex_lock_t); pollution: lock_write_to_read void lock_write_to_read(complex_lock_t); pollution: lock_try_read_to_write boolean_t lock_try_read_to_write(complex_lock_t); pollution: lock_try_write boolean_t lock_try_write(complex_lock_t); pollution: lock_try_read boolean_t lock_try_read(complex_lock_t); pollution: lock_set_recursive void lock_set_recursive(complex_lock_t); pollution: lock_clear_recursive void lock_clear_recursive(complex_lock_t); pollution: lock_islocked int lock_islocked(complex_lock_t); pollution: drw_lock_init void drw_lock_init(drw_lock_t); pollution: drw_lock_free void drw_lock_free(drw_lock_t); pollution: drw_lock_read void drw_lock_read(drw_lock_t); pollution: drw_lock_write void drw_lock_write(drw_lock_t); pollution: drw_lock_done void drw_lock_done(drw_lock_t); pollution: drw_lock_write_to_read void drw_lock_write_to_read(drw_lock_t); pollution: drw_lock_read_to_write boolean_t drw_lock_read_to_write(drw_lock_t); pollution: drw_lock_try_read_to_write boolean_t drw_lock_try_read_to_write(drw_lock_t); pollution: drw_lock_try_write boolean_t drw_lock_try_write(drw_lock_t); pollution: drw_lock_islocked boolean_t drw_lock_islocked(drw_lock_t); pollution: lockl int lockl(lock_t *,int); pollution: unlockl void unlockl(lock_t *); pollution: lockl_mine boolean_t lockl_mine(lock_t *); pollution: simple_lock_init void simple_lock_init(simple_lock_t); pollution: lock_mine boolean_t lock_mine(void *); pollution: What pollution: Who pollution: Where pollution: bindprocessor extern int bindprocessor(int What, int Who, cpu_t Where); pollution: mycpu extern cpu_t mycpu(void); pollution: enable_jitter_dispatch_windows kerrno_t enable_jitter_dispatch_windows(int, int); pollution: set_jitter_dispatch_window kerrno_t set_jitter_dispatch_window(jitter_dispatch_window_t); pollution: disable_jitter_dispatch_windows kerrno_t disable_jitter_dispatch_windows(void); pollution: set_elongated_decr kerrno_t set_elongated_decr(int, int); pollution: reset_elongated_decr kerrno_t reset_elongated_decr(void); pollution: read_smt_priority kerrno_t read_smt_priority(smt_thread_priority_t *); pollution: cpu_speculation_barrier extern void cpu_speculation_barrier(void); pollution: cpu_context_barrier extern void cpu_context_barrier(int); pollution: pre_idx u_int pre_idx; pollution: nxt_idx u_int nxt_idx; pollution: addr void *addr; pollution: size size_t size; pollution: memtype int memtype; pollution: cpu char cpu; pollution: pading char pading[3]; pollution: callers void *callers[16]; pollution: ostd_mem_rec struct ostd_mem_rec { u_int pre_idx; u_int nxt_idx; void *addr; size_t size; int memtype; char cpu; char pading[3]; void *callers[16]; }; pollution: ostd_array_size extern u_int ostd_array_size; pollution: ostd_mem_rec pollution: d_list struct ostd_mem_rec *d_list; pollution: d_idx_que u_int *d_idx_que; pollution: d_cnt u_int d_cnt; pollution: d_size u_int d_size; pollution: d_last_idx u_int d_last_idx; pollution: d_first_idx u_int d_first_idx; pollution: d_lock long d_lock; pollution: d_savpri int d_savpri; pollution: d_expand u_int d_expand; pollution: ostd_mem struct ostd_mem { struct ostd_mem_rec *d_list; u_int *d_idx_que; u_int d_cnt; u_int d_size; u_int d_last_idx; u_int d_first_idx; long d_lock; int d_savpri; u_int d_expand; }; pollution: ostd_mem pollution: ostd extern struct ostd_mem *ostd; pollution: ks_inuse long ks_inuse; pollution: ks_calls long ks_calls; pollution: ks_memuse long ks_memuse; pollution: ks_limblocks long ks_limblocks; pollution: ks_mapblocks long ks_mapblocks; pollution: ks_maxused long ks_maxused; pollution: ks_limit long ks_limit; pollution: ks_failed long ks_failed; pollution: ks_delayed long ks_delayed; pollution: ks_lock long ks_lock; pollution: kmemstats struct kmemstats { long ks_inuse; long ks_calls; long ks_memuse; long ks_limblocks; long ks_mapblocks; long ks_maxused; long ks_limit; long ks_failed; long ks_delayed; long ks_lock; }; pollution: ku_indx short ku_indx; pollution: freecnt u_short freecnt; pollution: pagecnt u_short pagecnt; pollution: ku_un union { u_short freecnt; u_short pagecnt; } ku_un; pollution: ku_cpu int ku_cpu; pollution: ku_lock long ku_lock; pollution: ku_flags int ku_flags; pollution: ku_size int ku_size; pollution: ku_police_debug long ku_police_debug; pollution: ku_free_debug long ku_free_debug; pollution: kmemusage struct kmemusage { short ku_indx; union { u_short freecnt; u_short pagecnt; } ku_un; int ku_cpu; long ku_lock; int ku_flags; int ku_size; long ku_police_debug; long ku_free_debug; }; pollution: next void *next; pollution: prev void *prev; pollution: kmemusage pollution: kup struct kmemusage *kup; pollution: kmem_dblink struct kmem_dblink { void *next; void *prev; struct kmemusage *kup; }; pollution: kb_next void *kb_next; pollution: kb_calls long kb_calls; pollution: kb_total long kb_total; pollution: kb_totalfree long kb_totalfree; pollution: kb_elmpercl long kb_elmpercl; pollution: kb_highwat long kb_highwat; pollution: kb_couldfree long kb_couldfree; pollution: kb_failed long kb_failed; pollution: kb_delayed long kb_delayed; pollution: kb_lock long kb_lock; pollution: kb_tail long *kb_tail; pollution: delta int delta; pollution: kmembuckets struct kmembuckets { void *kb_next; long kb_calls; long kb_total; long kb_totalfree; long kb_elmpercl; long kb_highwat; long kb_couldfree; long kb_failed; long kb_delayed; long kb_lock; long *kb_tail; int delta; }; pollution: cpu cpu_t cpu; pollution: type char type; pollution: lrcnt short lrcnt; pollution: memtype int memtype; pollution: size size_t size; pollution: addr void *addr; pollution: callers void *callers[16]; pollution: police_event struct police_event { cpu_t cpu; char type; short lrcnt; int memtype; size_t size; void *addr; void *callers[16]; }; pollution: ipif_total u_long ipif_total; pollution: ipif_tooshort u_long ipif_tooshort; pollution: ipif_toosmall u_long ipif_toosmall; pollution: ipif_fragments u_long ipif_fragments; pollution: ipif_fragdropped u_long ipif_fragdropped; pollution: ipif_fragtimeout u_long ipif_fragtimeout; pollution: ipif_forward u_long ipif_forward; pollution: ipif_cantforward u_long ipif_cantforward; pollution: ipif_noproto u_long ipif_noproto; pollution: ipif_delivered u_long ipif_delivered; pollution: ipif_localout u_long ipif_localout; pollution: ipif_odropped u_long ipif_odropped; pollution: ipif_reassembled u_long ipif_reassembled; pollution: ipif_fragmented u_long ipif_fragmented; pollution: ipif_ofragments u_long ipif_ofragments; pollution: ipif_cantfrag u_long ipif_cantfrag; pollution: ipif_noroute u_long ipif_noroute; pollution: ipif_InHdrErrors u_long ipif_InHdrErrors; pollution: ipif_InAddrErrors u_long ipif_InAddrErrors; pollution: ipif_InDiscards u_long ipif_InDiscards; pollution: ipif_InMAddrErrors u_long ipif_InMAddrErrors; pollution: ipif_inoctets u_long ipif_inoctets; pollution: ipif_outoctets u_long ipif_outoctets; pollution: ipif_inmcastpacks u_long ipif_inmcastpacks; pollution: ipif_inmcastoctets u_long ipif_inmcastoctets; pollution: ipif_outmcastpacks u_long ipif_outmcastpacks; pollution: ipif_outmcastoctets u_long ipif_outmcastoctets; pollution: ipif_inbcastpacks u_long ipif_inbcastpacks; pollution: ipif_outbcastpacks u_long ipif_outbcastpacks; pollution: timeval pollution: ipif_disconttime struct timeval ipif_disconttime; pollution: ipifstat struct ipifstat { u_long ipif_total; u_long ipif_tooshort; u_long ipif_toosmall; u_long ipif_fragments; u_long ipif_fragdropped; u_long ipif_fragtimeout; u_long ipif_forward; u_long ipif_cantforward; u_long ipif_noproto; u_long ipif_delivered; u_long ipif_localout; u_long ipif_odropped; u_long ipif_reassembled; u_long ipif_fragmented; u_long ipif_ofragments; u_long ipif_cantfrag; u_long ipif_noroute; u_long ipif_InHdrErrors; u_long ipif_InAddrErrors; u_long ipif_InDiscards; u_long ipif_InMAddrErrors; u_long ipif_inoctets; u_long ipif_outoctets; u_long ipif_inmcastpacks; u_long ipif_inmcastoctets; u_long ipif_outmcastpacks; u_long ipif_outmcastoctets; u_long ipif_inbcastpacks; u_long ipif_outbcastpacks; struct timeval ipif_disconttime; }; pollution: ipifstat struct ipifstat if_stat; pollution: dummy char dummy[128 - (sizeof(struct ipifstat) % 128)]; pollution: reserved union { char dummy[128 - (sizeof(struct ipifstat) % 128)]; } reserved; pollution: dist_ipifstat struct dist_ipifstat { struct ipifstat if_stat; union { char dummy[128 - (sizeof(struct ipifstat) % 128)]; } reserved; }; pollution: ifnet64_stats struct ifnet64_stats { uint64_t if_ipackets; uint64_t if_opackets; uint64_t if_ibytes; uint64_t if_obytes; uint64_t if_ierrors; uint64_t if_oerrors; uint64_t if_imcasts; uint64_t if_omcasts; uint64_t if_collisions; uint64_t if_iqdrops; uint64_t if_noproto; uint64_t if_arpdrops; }; pollution: cwif short cwif; pollution: cwdf short cwdf; pollution: flags int flags; pollution: flags u_long flags; pollution: tcp_sendspace u_long tcp_sendspace; pollution: tcp_recvspace u_long tcp_recvspace; pollution: tcp_mssdflt int tcp_mssdflt; pollution: tcp_nodelay int tcp_nodelay; pollution: rfc1323 int rfc1323; pollution: tcp_low_rto u_long tcp_low_rto; pollution: cwnd struct if_cwnd cwnd; pollution: spare u_long spare[10]; pollution: timeval pollution: if4_lastchange struct timeval if4_lastchange; pollution: timeval pollution: if6_lastchange struct timeval if6_lastchange; pollution: dist_ipifstat struct dist_ipifstat *if_ipstat_ptr; pollution: dist_ipifstat struct dist_ipifstat *if_ip6stat_ptr; pollution: if6z_array caddr_t if6z_array; pollution: if6z_lookup int (*if6z_lookup)(); pollution: ndd pollution: p_ndd struct ndd * p_ndd; pollution: trb pollution: selfarp_trb struct trb * selfarp_trb; pollution: arp_count int arp_count; pollution: ns_status_sid int ns_status_sid; pollution: reserved u_long reserved[8]; pollution: stats64_allocated cpu_t stats64_allocated; pollution: ifnet64_stats pollution: stats64pp struct ifnet64_stats **stats64pp; pollution: ifnet_ext struct ifnet_ext { struct timeval if4_lastchange; struct timeval if6_lastchange; struct dist_ipifstat *if_ipstat_ptr; struct dist_ipifstat *if_ip6stat_ptr; caddr_t if6z_array; int (*if6z_lookup)(); struct ndd * p_ndd; struct trb * selfarp_trb; int arp_count; int ns_status_sid; u_long reserved[8]; uint64_t if_xbaudrate; cpu_t stats64_allocated; struct ifnet64_stats **stats64pp; }; pollution: timeval pollution: if4_lastchange struct timeval if4_lastchange; pollution: timeval pollution: if6_lastchange struct timeval if6_lastchange; pollution: dist_ipifstat struct dist_ipifstat *if_ipstat_ptr; pollution: dist_ipifstat struct dist_ipifstat *if_ip6stat_ptr; pollution: if6z_array caddr_t if6z_array; pollution: if6z_lookup int (*if6z_lookup)(); pollution: ndd pollution: p_ndd struct ndd *p_ndd; pollution: trb pollution: selfarp_trb struct trb *selfarp_trb; pollution: arp_count int arp_count; pollution: ns_status_sid int ns_status_sid; pollution: reserved u_long reserved[10]; pollution: ifnet64_stats pollution: stats64 struct ifnet64_stats stats64[(1024)]; pollution: ifnet_ext_v1 struct ifnet_ext_v1 { struct timeval if4_lastchange; struct timeval if6_lastchange; struct dist_ipifstat *if_ipstat_ptr; struct dist_ipifstat *if_ip6stat_ptr; caddr_t if6z_array; int (*if6z_lookup)(); struct ndd *p_ndd; struct trb *selfarp_trb; int arp_count; int ns_status_sid; u_long reserved[10]; struct ifnet64_stats stats64[(1024)]; }; pollution: ifaddr struct ifaddr *if_addrlist; pollution: ifnet struct ifnet *if_next; pollution: timeval struct timeval if_lastchange; pollution: ipv6_sug_hlim u_char ipv6_sug_hlim; pollution: ifnet_ext struct ifnet_ext *if_ext; pollution: devno dev_t devno; pollution: chan chan_t chan; pollution: ifml int ifml; pollution: in_multi struct in_multi *if_multiaddrs; pollution: mbuf pollution: ifq_head struct mbuf *ifq_head; pollution: mbuf pollution: ifq_tail struct mbuf *ifq_tail; pollution: ifq_len long ifq_len; pollution: ifq_maxlen long ifq_maxlen; pollution: ifq_drops int ifq_drops; pollution: ifq_slock long ifq_slock; pollution: ifqueue struct ifqueue { struct mbuf *ifq_head; struct mbuf *ifq_tail; long ifq_len; long ifq_maxlen; int ifq_drops; long ifq_slock; } if_snd; pollution: if6_multi_lock long if6_multi_lock; pollution: gidstruct struct gidstruct *if_gidlist; pollution: in6_multi pollution: lh_first struct in6_multi *lh_first; pollution: ifnet struct ifnet *if_vipaxface; pollution: tran_netif long long tran_netif[4]; pollution: offload_flags u_long offload_flags; pollution: offload_ptr caddr_t offload_ptr; pollution: ifnet struct ifnet { char *if_name; short if_unit; u_long if_mtu; u_long if_flags; short if_timer; int if_metric; struct ifaddr *if_addrlist; int (*if_init)(); int (*if_output)(); int (*if_start)(); int (*if_done)(); int (*if_ioctl)(); int (*if_reset)(); int (*if_watchdog)(); int if_ipackets; int if_ierrors; int if_opackets; int if_oerrors; int if_collisions; struct ifnet *if_next; u_char if_type; u_char if_addrlen; u_char if_hdrlen; u_char if_index; struct timeval if_lastchange; int if_ibytes; int if_obytes; int if_imcasts; int if_omcasts; int if_iqdrops; int if_noproto; int if_baudrate; u_long if_arpdrops; u_int if_ifbufminsize; u_short if_site6; u_char if_reserveds; u_char ipv6_sug_hlim; struct ifnet_ext *if_ext; int if_statsml; int if_auto_cksum; struct if_netopts *if_isno; int if_options; dev_t devno; chan_t chan; int ifml; struct in_multi *if_multiaddrs; int (*if_tap)(void *, void *); caddr_t if_tapctl; int (*if_arpres)(); int (*if_arprev)(); int (*if_arpinput)(); struct ifqueue { struct mbuf *ifq_head; struct mbuf *ifq_tail; long ifq_len; long ifq_maxlen; int ifq_drops; long ifq_slock; } if_snd; DRW_lock if_slock; long if_multi_lock; long if6_multi_lock; long if_addrlist_lock; struct gidstruct *if_gidlist; int (*if_ip6tomcast)(); int (*if_ndp_bcopy)(); int (*if_ndp_bcmp)(); u_int if_ndtype; struct if_multiaddrs6 { struct in6_multi *lh_first; } if_multiaddrs6; u_long if_desired_mtu; struct ifnet *if_vipaxface; long long tran_netif[4]; ulong if_htoken; union { u_long offload_flags; caddr_t offload_ptr; } if_offload_info; caddr_t if_rule; }; pollution: sockaddr pollution: ifa_addr struct sockaddr *ifa_addr; pollution: sockaddr pollution: ifa_dstaddr struct sockaddr *ifa_dstaddr; pollution: sockaddr pollution: ifa_netmask struct sockaddr *ifa_netmask; pollution: ifnet pollution: ifa_ifp struct ifnet *ifa_ifp; pollution: ifaddr pollution: ifa_next struct ifaddr *ifa_next; pollution: ifa_rtrequest void (*ifa_rtrequest)(); pollution: rtentry pollution: ifa_rt struct rtentry *ifa_rt; pollution: ifa_flags u_short ifa_flags; pollution: ifa_refcnt short ifa_refcnt; pollution: ifa_origin short ifa_origin; pollution: timeval pollution: ifa_created struct timeval ifa_created; pollution: timeval pollution: ifa_lastupdate struct timeval ifa_lastupdate; pollution: ifaddr struct ifaddr { struct sockaddr *ifa_addr; struct sockaddr *ifa_dstaddr; struct sockaddr *ifa_netmask; struct ifnet *ifa_ifp; struct ifaddr *ifa_next; void (*ifa_rtrequest)(); struct rtentry *ifa_rt; u_short ifa_flags; short ifa_refcnt; short ifa_origin; struct timeval ifa_created; struct timeval ifa_lastupdate; }; pollution: ifm_msglen u_short ifm_msglen; pollution: ifm_version u_char ifm_version; pollution: ifm_type u_char ifm_type; pollution: ifm_addrs int ifm_addrs; pollution: ifm_flags int ifm_flags; pollution: ifm_index u_short ifm_index; pollution: ifm_addrlen u_char ifm_addrlen; pollution: ifam_msglen u_short ifam_msglen; pollution: ifam_version u_char ifam_version; pollution: ifam_type u_char ifam_type; pollution: ifam_addrs int ifam_addrs; pollution: ifam_flags int ifam_flags; pollution: ifam_index u_short ifam_index; pollution: ifa_msghdr struct ifa_msghdr { u_short ifam_msglen; u_char ifam_version; u_char ifam_type; int ifam_addrs; int ifam_flags; u_short ifam_index; }; pollution: ifr_name char ifr_name[16]; pollution: sockaddr pollution: ifru_addr struct sockaddr ifru_addr; pollution: sockaddr pollution: ifru_dstaddr struct sockaddr ifru_dstaddr; pollution: sockaddr pollution: ifru_broadaddr struct sockaddr ifru_broadaddr; pollution: ifru_flags __ulong32_t ifru_flags; pollution: ifru_metric int ifru_metric; pollution: ifru_data caddr_t ifru_data; pollution: ifru_site6 u_short ifru_site6; pollution: ifru_mtu __ulong32_t ifru_mtu; pollution: ifru_obaudrate int ifru_obaudrate; pollution: ifru_baudrate uint64_t ifru_baudrate; pollution: ifru_checksum_offload int ifru_checksum_offload[2]; pollution: ifr_ifru union { struct sockaddr ifru_addr; struct sockaddr ifru_dstaddr; struct sockaddr ifru_broadaddr; __ulong32_t ifru_flags; int ifru_metric; caddr_t ifru_data; u_short ifru_site6; __ulong32_t ifru_mtu; int ifru_obaudrate; uint64_t ifru_baudrate; int ifru_checksum_offload[2]; } ifr_ifru; pollution: ifreq struct ifreq { char ifr_name[16]; union { struct sockaddr ifru_addr; struct sockaddr ifru_dstaddr; struct sockaddr ifru_broadaddr; __ulong32_t ifru_flags; int ifru_metric; caddr_t ifru_data; u_short ifru_site6; __ulong32_t ifru_mtu; int ifru_obaudrate; uint64_t ifru_baudrate; int ifru_checksum_offload[2]; } ifr_ifru; }; pollution: ifr_name char ifr_name[16]; pollution: ifr_hwaddr char ifr_hwaddr[64]; pollution: addr_len int addr_len; pollution: ifhwaddr_req struct ifhwaddr_req { char ifr_name[16]; char ifr_hwaddr[64]; int addr_len; }; pollution: ifr_name char ifr_name[16]; pollution: ifr_hwaddr char ifr_hwaddr[64]; pollution: addr_len int addr_len; pollution: ndd_name char ndd_name[16]; pollution: ndd_flags int ndd_flags; pollution: ndd_flags2 int ndd_flags2; pollution: ifhwaddr2_req struct ifhwaddr2_req { char ifr_name[16]; char ifr_hwaddr[64]; int addr_len; char ndd_name[16]; int if_options; int ndd_flags; int ndd_flags2; }; pollution: ifrg_name char ifrg_name[16]; pollution: gidstruct pollution: ifrg_gidlist struct gidstruct ifrg_gidlist; pollution: ifgidreq struct ifgidreq { char ifrg_name[16]; struct gidstruct ifrg_gidlist; }; pollution: ifra_name char ifra_name[16]; pollution: sockaddr pollution: ifra_addr struct sockaddr ifra_addr; pollution: sockaddr pollution: ifra_broadaddr struct sockaddr ifra_broadaddr; pollution: sockaddr pollution: ifra_mask struct sockaddr ifra_mask; pollution: ifaliasreq struct ifaliasreq { char ifra_name[16]; struct sockaddr ifra_addr; struct sockaddr ifra_broadaddr; struct sockaddr ifra_mask; }; pollution: ifr_name char ifr_name[16]; pollution: sockaddr pollution: ifru_addr struct sockaddr ifru_addr; pollution: sockaddr pollution: ifru_dstaddr struct sockaddr ifru_dstaddr; pollution: sockaddr pollution: ifru_broadaddr struct sockaddr ifru_broadaddr; pollution: ifru_flags __long32_t ifru_flags; pollution: ifru_metric int ifru_metric; pollution: ifru_data caddr_t ifru_data; pollution: ifru_mtu __ulong32_t ifru_mtu; pollution: ifr_ifru union { struct sockaddr ifru_addr; struct sockaddr ifru_dstaddr; struct sockaddr ifru_broadaddr; __long32_t ifru_flags; int ifru_metric; caddr_t ifru_data; __ulong32_t ifru_mtu; } ifr_ifru; pollution: reserved u_char reserved[8]; pollution: oifreq struct oifreq { char ifr_name[16]; union { struct sockaddr ifru_addr; struct sockaddr ifru_dstaddr; struct sockaddr ifru_broadaddr; __long32_t ifru_flags; int ifru_metric; caddr_t ifru_data; __ulong32_t ifru_mtu; } ifr_ifru; u_char reserved[8]; }; pollution: ifrv_name char ifrv_name[16]; pollution: ifrv_numif u_int ifrv_numif; pollution: ifrv_ifname char (*ifrv_ifname)[16]; pollution: ifvireq struct ifvireq { char ifrv_name[16]; u_int ifrv_numif; char (*ifrv_ifname)[16]; }; pollution: ifr_name char ifr_name[16]; pollution: qkey uint qkey; pollution: pmtu uint pmtu; pollution: res uchar res[96]; pollution: ifibreq struct ifibreq { char ifr_name[16]; uint qkey; uint pmtu; uchar res[96]; }; pollution: ifc_len int ifc_len; pollution: ifcu_buf caddr_t ifcu_buf; pollution: ifreq pollution: ifcu_req struct ifreq *ifcu_req; pollution: ifc_ifcu union { caddr_t ifcu_buf; struct ifreq *ifcu_req; } ifc_ifcu; pollution: ifconf struct ifconf { int ifc_len; union { caddr_t ifcu_buf; struct ifreq *ifcu_req; } ifc_ifcu; }; pollution: ifr_name char ifr_name[16]; pollution: ifaddrs int ifaddrs; pollution: naddrs int naddrs; pollution: sockaddr_in pollution: addr_in struct sockaddr_in addr_in; pollution: sockaddr_in6 pollution: addr_in6 struct sockaddr_in6 addr_in6; pollution: ifrasu union { struct sockaddr_in addr_in; struct sockaddr_in6 addr_in6; } ifrasu[1]; pollution: ifreqaddrs struct ifreqaddrs { char ifr_name[16]; int ifaddrs; int naddrs; union { struct sockaddr_in addr_in; struct sockaddr_in6 addr_in6; } ifrasu[1]; }; pollution: ifro_name char ifro_name[16]; pollution: sockaddr_in pollution: ifro_addr struct sockaddr_in ifro_addr; pollution: ifro_origin int ifro_origin; pollution: ifaddrorigin struct ifaddrorigin { char ifro_name[16]; struct sockaddr_in ifro_addr; int ifro_origin; }; pollution: ar_hrd u_short ar_hrd; pollution: ar_pro u_short ar_pro; pollution: ar_hln u_char ar_hln; pollution: ar_pln u_char ar_pln; pollution: ar_op u_short ar_op; pollution: arphdr struct arphdr { u_short ar_hrd; u_short ar_pro; u_char ar_hln; u_char ar_pln; u_short ar_op; }; pollution: u_rcf u_short u_rcf; pollution: u_seg u_short u_seg[8]; pollution: token pollution: token struct token { u_short u_rcf; u_short u_seg[8]; } token; pollution: u_session_id u_short u_session_id; pollution: u_unit u_short u_unit; pollution: x25 pollution: x25 struct x25 { u_short u_session_id; u_short u_unit; } x25; pollution: u_rcf u_short u_rcf; pollution: u_seg u_short u_seg[16]; pollution: fddi pollution: fddi struct fddi { u_short u_rcf; u_short u_seg[16]; } fddi; pollution: in_addr pollution: isaddr struct in_addr *isaddr; pollution: in_addr pollution: itaddr struct in_addr *itaddr; pollution: in_addr pollution: myaddr struct in_addr *myaddr; pollution: mbuf pollution: tmpmbuf struct mbuf **tmpmbuf; pollution: hwaddr u_char *hwaddr; pollution: szhwaddr int szhwaddr; pollution: flags u_char *flags; pollution: arptab pollution: at_addr struct arptab *at_addr; pollution: hp pollution: action int (*if_ifdependent) (caddr_t hp, union if_dependent *if_dependent, int action); pollution: arpupdate_parm struct arpupdate_parm { struct in_addr *isaddr; struct in_addr *itaddr; struct in_addr *myaddr; struct mbuf **tmpmbuf; union if_dependent *if_dependent; u_char *hwaddr; int szhwaddr; u_char *flags; struct arptab *at_addr; int (*if_ifdependent) (caddr_t hp, union if_dependent *if_dependent, int action); }; pollution: in_addr pollution: at_iaddr struct in_addr at_iaddr; pollution: hwaddr u_char hwaddr[20]; pollution: at_timer u_char at_timer; pollution: at_flags u_char at_flags; pollution: at_count u_short at_count; pollution: mbuf pollution: at_hold struct mbuf *at_hold; pollution: mbuf pollution: at_last struct mbuf *at_last; pollution: ifnet pollution: at_ifp struct ifnet *at_ifp; pollution: at_time struct timestruc_t at_time; pollution: at_requests u_int at_requests; pollution: arptab struct arptab { struct in_addr at_iaddr; u_char hwaddr[20]; u_char at_timer; u_char at_flags; u_short at_count; struct mbuf *at_hold; struct mbuf *at_last; struct ifnet *at_ifp; struct timestruc_t at_time; u_int at_requests; union if_dependent if_dependent; }; pollution: sockaddr pollution: arp_pa struct sockaddr arp_pa; pollution: sockaddr pollution: arp_ha struct sockaddr arp_ha; pollution: arp_flags int arp_flags; pollution: at_length u_short at_length; pollution: ifd union if_dependent ifd; pollution: ifType __ulong32_t ifType; pollution: arpreq struct arpreq { struct sockaddr arp_pa; struct sockaddr arp_ha; int arp_flags; u_short at_length; union if_dependent ifd; __ulong32_t ifType; }; pollution: ifnet pollution: ac_if struct ifnet ac_if; pollution: ac_hwaddr u_char ac_hwaddr[20]; pollution: in_addr pollution: ac_ipaddr struct in_addr ac_ipaddr; pollution: driver_multi pollution: ac_multiaddrs struct driver_multi *ac_multiaddrs; pollution: ac_multi_lock long ac_multi_lock; pollution: in6_addr pollution: ac_llip6 struct in6_addr ac_llip6; pollution: arpcom struct arpcom { struct ifnet ac_if; u_char ac_hwaddr[20]; struct in_addr ac_ipaddr; struct driver_multi *ac_multiaddrs; long ac_multi_lock; struct in6_addr ac_llip6; }; pollution: nlocks_per_arptabbuckets extern long nlocks_per_arptabbuckets; pollution: enm_addrlo u_char enm_addrlo[6]; pollution: enm_addrhi u_char enm_addrhi[6]; pollution: arpcom pollution: enm_ac struct arpcom *enm_ac; pollution: enm_refcount u_int enm_refcount; pollution: driver_multi pollution: enm_next struct driver_multi *enm_next; pollution: driver_multi struct driver_multi { u_char enm_addrlo[6]; u_char enm_addrhi[6]; struct arpcom *enm_ac; u_int enm_refcount; struct driver_multi *enm_next; }; pollution: arpcom pollution: en_ac struct arpcom en_ac; pollution: ndd pollution: nddp struct ndd *nddp; pollution: en_softc struct en_softc { struct arpcom en_ac; struct ndd *nddp; }; pollution: arpcom pollution: fc_ac struct arpcom fc_ac; pollution: ndd pollution: nddp struct ndd *nddp; pollution: ndd pollution: mbuf pollution: efcnet_arp_fct int(*efcnet_arp_fct) (struct ndd *, struct mbuf *); pollution: fc_softc struct fc_softc { struct arpcom fc_ac; struct ndd *nddp; int(*efcnet_arp_fct) (struct ndd *, struct mbuf *); }; pollution: kinfo_ifnet struct kinfo_ifnet { char if_name[16]; u_char if_type; u_char if_index; short if_unit; u_int32_t if_mtu; u_int32_t if_flag; }; pollution: ACE_MAX_LVL #define ACE_MAX_LVL ACE_POWER9 pollution: ACE_NONE #define ACE_NONE 0 pollution: ACE_POWER4 #define ACE_POWER4 1 pollution: ACE_POWER5 #define ACE_POWER5 3 pollution: ACE_POWER6 #define ACE_POWER6 4 pollution: ACE_POWER7 #define ACE_POWER7 5 pollution: ACE_POWER8 #define ACE_POWER8 6 pollution: ACE_POWER9 #define ACE_POWER9 7 pollution: ACE_PPC970 #define ACE_PPC970 2 pollution: ACMULTI_LOCK #define ACMULTI_LOCK(acp) _acml = disable_lock(PL_IMP, &((acp)->ac_multi_lock)) pollution: ACMULTI_LOCKINIT #define ACMULTI_LOCKINIT(acp) { lock_alloc(&((acp)->ac_multi_lock), LOCK_ALLOC_PIN, ACMULTI_LOCK_FAMILY, (short32uint64_t)acp); simple_lock_init(&((acp)->ac_multi_lock)); } pollution: ACMULTI_LOCK_DECL #define ACMULTI_LOCK_DECL() int _acml; pollution: ACMULTI_UNLOCK #define ACMULTI_UNLOCK(acp) unlock_enable(_acml, &((acp)->ac_multi_lock)) pollution: ADDR6_NUMSCOPES #define ADDR6_NUMSCOPES (ADDR6_SCP_MAX+1) pollution: ADDR6_SCP_0 #define ADDR6_SCP_0 0x0 pollution: ADDR6_SCP_3 #define ADDR6_SCP_3 0x3 pollution: ADDR6_SCP_6 #define ADDR6_SCP_6 0x6 pollution: ADDR6_SCP_7 #define ADDR6_SCP_7 0x7 pollution: ADDR6_SCP_9 #define ADDR6_SCP_9 0x9 pollution: ADDR6_SCP_A #define ADDR6_SCP_A 0xA pollution: ADDR6_SCP_ADMIN #define ADDR6_SCP_ADMIN 0x4 pollution: ADDR6_SCP_B #define ADDR6_SCP_B 0xB pollution: ADDR6_SCP_C #define ADDR6_SCP_C 0xC pollution: ADDR6_SCP_D #define ADDR6_SCP_D 0xD pollution: ADDR6_SCP_F #define ADDR6_SCP_F 0xF pollution: ADDR6_SCP_GLOBAL #define ADDR6_SCP_GLOBAL 0xE pollution: ADDR6_SCP_INTF #define ADDR6_SCP_INTF 0x1 pollution: ADDR6_SCP_LINK #define ADDR6_SCP_LINK 0x2 pollution: ADDR6_SCP_MAX #define ADDR6_SCP_MAX ADDR6_SCP_F pollution: ADDR6_SCP_MIN #define ADDR6_SCP_MIN ADDR6_SCP_0 pollution: ADDR6_SCP_NODE #define ADDR6_SCP_NODE 0x1 pollution: ADDR6_SCP_ORG #define ADDR6_SCP_ORG 0x8 pollution: ADDR6_SCP_SITE #define ADDR6_SCP_SITE 0x5 pollution: ADDRESS_ORIGIN_DHCP #define ADDRESS_ORIGIN_DHCP 4 pollution: ADDRESS_ORIGIN_LINKLAYER #define ADDRESS_ORIGIN_LINKLAYER 5 pollution: ADDRESS_ORIGIN_MANUAL #define ADDRESS_ORIGIN_MANUAL 2 pollution: ADDRESS_ORIGIN_OTHER #define ADDRESS_ORIGIN_OTHER 1 pollution: ADDRESS_ORIGIN_RANDOM #define ADDRESS_ORIGIN_RANDOM 6 pollution: ADD_NS_TO_TIMEVAL #define ADD_NS_TO_TIMEVAL(tvp,delta) { (tvp).tv_usec += delta; if((tvp).tv_usec >= NS_PER_SEC) { (tvp).tv_sec++; (tvp).tv_usec -= NS_PER_SEC; } } pollution: ADD_TO_NS #define ADD_TO_NS(tvp,delta) { (tvp).tv_nsec += delta; if((tvp).tv_nsec >= NS_PER_SEC) { (tvp).tv_sec++; (tvp).tv_nsec -= NS_PER_SEC; } } pollution: ADSP_MASK #define ADSP_MASK(_x) ((1U << 31) >> (_x)) pollution: AF_APPLETALK #define AF_APPLETALK 16 pollution: AF_BYPASS #define AF_BYPASS 25 pollution: AF_CCITT #define AF_CCITT 10 pollution: AF_CHAOS #define AF_CHAOS 5 pollution: AF_DATAKIT #define AF_DATAKIT 9 pollution: AF_DECnet #define AF_DECnet 12 pollution: AF_DLI #define AF_DLI 13 pollution: AF_ECMA #define AF_ECMA 8 pollution: AF_HYLINK #define AF_HYLINK 15 pollution: AF_IMPLINK #define AF_IMPLINK 3 pollution: AF_INET #define AF_INET 2 pollution: AF_INET6 #define AF_INET6 24 pollution: AF_INTF #define AF_INTF 20 pollution: AF_ISO #define AF_ISO 7 pollution: AF_LAT #define AF_LAT 14 pollution: AF_LINK #define AF_LINK 18 pollution: AF_LOCAL #define AF_LOCAL AF_UNIX pollution: AF_MAX #define AF_MAX 30 pollution: AF_NDD #define AF_NDD 23 pollution: AF_NETWARE #define AF_NETWARE 22 pollution: AF_NS #define AF_NS 6 pollution: AF_OSI #define AF_OSI AF_ISO pollution: AF_PUP #define AF_PUP 4 pollution: AF_RIF #define AF_RIF 21 pollution: AF_ROUTE #define AF_ROUTE 17 pollution: AF_SNA #define AF_SNA 11 pollution: AF_UNIX #define AF_UNIX 1 pollution: AF_UNSPEC #define AF_UNSPEC 0 pollution: AIO_LISTIO_MAX #define AIO_LISTIO_MAX 4096 pollution: AIO_LISTIO_MAX_SIZE #define AIO_LISTIO_MAX_SIZE AIO_LISTIO_MAX pollution: AIO_MAX #define AIO_MAX 4096 pollution: AIO_PRIO_DELTA_MAX #define AIO_PRIO_DELTA_MAX 20 pollution: AIO_PRIO_DFL #define AIO_PRIO_DFL 1 pollution: AIO_PRIO_MAX #define AIO_PRIO_MAX 1 pollution: AIO_PRIO_MIN #define AIO_PRIO_MIN 1 pollution: ALIGN #define ALIGN(p) (ulong)((caddr_t)(p) + MACHINE_ALIGNMENT - 1 - ALIGNMENT((caddr_t)(p) + MACHINE_ALIGNMENT - 1)) pollution: ALIGNMENT #define ALIGNMENT(p) ((ulong)(p) % MACHINE_ALIGNMENT) pollution: ARG_MAX #define ARG_MAX 1048576 pollution: ARPHRD_802_3 #define ARPHRD_802_3 6 pollution: ARPHRD_802_5 #define ARPHRD_802_5 6 pollution: ARPHRD_ETHER #define ARPHRD_ETHER 1 pollution: ARPHRD_FDDI #define ARPHRD_FDDI 1 pollution: ARPOP_REPLY #define ARPOP_REPLY 2 pollution: ARPOP_REQUEST #define ARPOP_REQUEST 1 pollution: ARPTAB_BSIZ #define ARPTAB_BSIZ 7 pollution: ARPTAB_NB #define ARPTAB_NB 149 pollution: ARPT_AGE #define ARPT_AGE (60 * 1) pollution: ARPT_KILLC #define ARPT_KILLC 20 pollution: ARPT_KILLI #define ARPT_KILLI 3 pollution: ARP_FAIL #define ARP_FAIL 1 pollution: ARP_FLG_NOARP #define ARP_FLG_NOARP 2 pollution: ARP_HWADDR #define ARP_HWADDR 1 pollution: ARP_MBUF #define ARP_MBUF 0 pollution: ARP_NEWF #define ARP_NEWF -1 pollution: ARP_OK #define ARP_OK 0 pollution: ATEXIT_MAX #define ATEXIT_MAX 2048 pollution: ATF_ASK #define ATF_ASK 0x20 pollution: ATF_COM #define ATF_COM 0x02 pollution: ATF_INUSE #define ATF_INUSE 0x01 pollution: ATF_PERM #define ATF_PERM 0x04 pollution: ATF_PUBL #define ATF_PUBL 0x08 pollution: ATF_USETRAILERS #define ATF_USETRAILERS 0x10 pollution: BASICISDN #define BASICISDN IFT_ISDNBASIC pollution: BC_BASE_MAX #define BC_BASE_MAX _POSIX2_BC_BASE_MAX pollution: BC_DIM_MAX #define BC_DIM_MAX _POSIX2_BC_DIM_MAX pollution: BC_SCALE_MAX #define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX pollution: BC_STRING_MAX #define BC_STRING_MAX 2048 pollution: BIG_ENDIAN #define BIG_ENDIAN 4321 pollution: BINDPROCESS #define BINDPROCESS 1 pollution: BINDTHREAD #define BINDTHREAD 2 pollution: BUCKETSPERCPU #define BUCKETSPERCPU (MAXBUCKET+1) pollution: BYTE_ORDER #define BYTE_ORDER BIG_ENDIAN pollution: B_ALLOW_RESTART #define B_ALLOW_RESTART 0x80 pollution: B_CORRAL_INIT #define B_CORRAL_INIT 0x1 pollution: B_IGNORE_WPS #define B_IGNORE_WPS 0x40 pollution: B_NO_CHECKPOINT #define B_NO_CHECKPOINT 0x8 pollution: B_NO_CHROOT #define B_NO_CHROOT 0x4 pollution: B_REPARENT_INIT #define B_REPARENT_INIT 0x2 pollution: B_RESTART_EXIT #define B_RESTART_EXIT 0x10 pollution: Bcmp #define Bcmp(a,b,n) bcmp(((char *)(a)), ((char *)(b)), (n)) pollution: Bzero #define Bzero(p,n) bzero((char *)(p), (int)(n)); pollution: CCB_ALL #define CCB_ALL 0 pollution: CCB_ENTRY #define CCB_ENTRY 1 pollution: CCB_EXIT #define CCB_EXIT -1 pollution: CEPT #define CEPT IFT_CEPT pollution: CFLAG_RESTART #define CFLAG_RESTART 0x01 pollution: CFLAG_START #define CFLAG_START 0x00 pollution: CHARCLASS_NAME_MAX #define CHARCLASS_NAME_MAX 14 pollution: CHAR_BIT #define CHAR_BIT (8) pollution: CHAR_MAX #define CHAR_MAX UCHAR_MAX pollution: CHAR_MIN #define CHAR_MIN (0) pollution: CHILD_MAX #define CHILD_MAX 128 pollution: CIRCLEQ_ENTRY #define CIRCLEQ_ENTRY(type) struct { struct type *cqe_next; struct type *cqe_prev; } pollution: CIRCLEQ_HEAD #define CIRCLEQ_HEAD(name,type) struct name { struct type *cqh_first; struct type *cqh_last; } pollution: CIRCLEQ_INIT #define CIRCLEQ_INIT(head) { (head)->cqh_first = (void *)(head); (head)->cqh_last = (void *)(head); } pollution: CIRCLEQ_INSERT_AFTER #define CIRCLEQ_INSERT_AFTER(head,listelm,elm,field) { (elm)->field.cqe_next = (listelm)->field.cqe_next; (elm)->field.cqe_prev = (listelm); if ((listelm)->field.cqe_next == (void *)(head)) (head)->cqh_last = (elm); else (listelm)->field.cqe_next->field.cqe_prev = (elm); (listelm)->field.cqe_next = (elm); } pollution: CIRCLEQ_INSERT_BEFORE #define CIRCLEQ_INSERT_BEFORE(head,listelm,elm,field) { (elm)->field.cqe_next = (listelm); (elm)->field.cqe_prev = (listelm)->field.cqe_prev; if ((listelm)->field.cqe_prev == (void *)(head)) (head)->cqh_first = (elm); else (listelm)->field.cqe_prev->field.cqe_next = (elm); (listelm)->field.cqe_prev = (elm); } pollution: CIRCLEQ_INSERT_HEAD #define CIRCLEQ_INSERT_HEAD(head,elm,field) { (elm)->field.cqe_next = (head)->cqh_first; (elm)->field.cqe_prev = (void *)(head); if ((head)->cqh_last == (void *)(head)) (head)->cqh_last = (elm); else (head)->cqh_first->field.cqe_prev = (elm); (head)->cqh_first = (elm); } pollution: CIRCLEQ_INSERT_TAIL #define CIRCLEQ_INSERT_TAIL(head,elm,field) { (elm)->field.cqe_next = (void *)(head); (elm)->field.cqe_prev = (head)->cqh_last; if ((head)->cqh_first == (void *)(head)) (head)->cqh_first = (elm); else (head)->cqh_last->field.cqe_next = (elm); (head)->cqh_last = (elm); } pollution: CIRCLEQ_REMOVE #define CIRCLEQ_REMOVE(head,elm,field) { if ((elm)->field.cqe_next == (void *)(head)) (head)->cqh_last = (elm)->field.cqe_prev; else (elm)->field.cqe_next->field.cqe_prev = (elm)->field.cqe_prev; if ((elm)->field.cqe_prev == (void *)(head)) (head)->cqh_first = (elm)->field.cqe_next; else (elm)->field.cqe_prev->field.cqe_next = (elm)->field.cqe_next; } pollution: CKEY_INIT #define CKEY_INIT 0x0 pollution: CLR_ADDR6 #define CLR_ADDR6(a) { (a).s6_addr32[0] = 0; (a).s6_addr32[1] = 0; (a).s6_addr32[2] = 0; (a).s6_addr32[3] = 0; } pollution: CL_BUCKETS #define CL_BUCKETS 4 pollution: CL_NOTRANSITION #define CL_NOTRANSITION 9999 pollution: CMSG_ALIGN #define CMSG_ALIGN _CMSG_ALIGN pollution: CMSG_DATA #define CMSG_DATA(cmsg) (((uchar_t *)(cmsg)) + _CMSG_ALIGN(sizeof(struct cmsghdr))) pollution: CMSG_FIRSTHDR #define CMSG_FIRSTHDR(mhdr) ((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? (struct cmsghdr *)(mhdr)->msg_control : (struct cmsghdr *)0 ) pollution: CMSG_LEN #define CMSG_LEN(len) (_CMSG_ALIGN(sizeof(struct cmsghdr)) + (len)) pollution: CMSG_NXTHDR #define CMSG_NXTHDR(mhdr,cmsg) (((cmsg) == 0) ? CMSG_FIRSTHDR(mhdr) : (((caddr_t)(cmsg) + (cmsg)->cmsg_len + sizeof(struct cmsghdr) > (caddr_t)((mhdr)->msg_control) + (mhdr)->msg_controllen) ? (struct cmsghdr *)0 : (struct cmsghdr *)((caddr_t)(cmsg) + _CMSG_ALIGN((cmsg)->cmsg_len)))) pollution: CMSG_SPACE #define CMSG_SPACE(len) (_CMSG_ALIGN(sizeof(struct cmsghdr)) + _CMSG_ALIGN(len)) pollution: COLL_WEIGHTS_MAX #define COLL_WEIGHTS_MAX 4 pollution: COMPLEX_LOCKING #define COMPLEX_LOCKING #define COMPLEX_LOCK_AVAIL SIMPLE_LOCK_AVAIL pollution: COPT_APP_WPAR #define COPT_APP_WPAR 0x0010 pollution: COPT_DEFAULT #define COPT_DEFAULT 0x0000 pollution: COPT_MIG_CROSS_LEVEL #define COPT_MIG_CROSS_LEVEL 0x0100 pollution: COPT_MOBILE #define COPT_MOBILE 0x0020 pollution: COPT_NOVIPWPAR #define COPT_NOVIPWPAR 0x0080 pollution: COPT_NO_CHROOT #define COPT_NO_CHROOT 0x0008 pollution: COPT_ROUTING #define COPT_ROUTING 0x0040 pollution: COPT_WLM_MANAGED #define COPT_WLM_MANAGED 0x0004 pollution: COPT_XWPARIPC #define COPT_XWPARIPC 0x0200 pollution: COPY_ADDR6 #define COPY_ADDR6(from,to) (to) = (from) pollution: CORDATAOP_ALL #define CORDATAOP_ALL 0x1FFF pollution: CORDATAOP_ARCH #define CORDATAOP_ARCH 0x0002 pollution: CORDATAOP_MIG_VERSIONS #define CORDATAOP_MIG_VERSIONS 0x0003 pollution: CORDATAOP_UUID #define CORDATAOP_UUID 0x0001 pollution: CORRAL_GLOBAL #define CORRAL_GLOBAL 0 pollution: CORRAL_MAX #define CORRAL_MAX 0xFFFE pollution: CP_ITIMERSTRUCT #define CP_ITIMERSTRUCT(__tsrc,__tdest) (__tdest).it_interval.tv_sec = (__tsrc).it_interval.tv_sec; (__tdest).it_interval.tv_nsec = (__tsrc).it_interval.tv_nsec; (__tdest).it_value.tv_sec = (__tsrc).it_value.tv_sec; (__tdest).it_value.tv_nsec = (__tsrc).it_value.tv_nsec pollution: CP_TIMESTRUCT #define CP_TIMESTRUCT(__tsrc,__tdest) (__tdest).tv_sec = (__tsrc).tv_sec; (__tdest).tv_nsec = (__tsrc).tv_nsec pollution: CP_TIMEVAL #define CP_TIMEVAL(__tsrc,__tdest) (__tdest).tv_sec = (__tsrc).tv_sec; (__tdest).tv_usec = (__tsrc).tv_usec pollution: CRE_AIX_52S #define CRE_AIX_52S 1 pollution: CRE_AIX_53 #define CRE_AIX_53 ((3 - VWPAR_MIN_REL) << VWPAR_REL_SHIFT) pollution: CRE_AIX_71 #define CRE_AIX_71 (((7 - VWPAR_MIN_VER) << VWPAR_VER_SHIFT) + ((1 - VWPAR_MIN_REL) << VWPAR_REL_SHIFT)) pollution: CRE_AIX_71_BTL #define CRE_AIX_71_BTL (2 << VWPAR_TL_SHIFT) pollution: CRE_ALL_LEVELS #define CRE_ALL_LEVELS CRE_INVALID_LEVEL pollution: CRE_INVALID_LEVEL #define CRE_INVALID_LEVEL 65535 pollution: CRE_MAX_LVL #define CRE_MAX_LVL CRE_AIX_52S pollution: CRE_MAX_SC #define CRE_MAX_SC (ACE_MAX_LVL + CRE_MAX_LVL + 1) pollution: CRE_NONE #define CRE_NONE 0 pollution: CR_EQ #define CR_EQ 0x20000000 pollution: CR_FEX #define CR_FEX 0x04000000 pollution: CR_FIELD #define CR_FIELD(n,cr) ((cr << (n << 2)) & 0xF0000000) pollution: CR_FX #define CR_FX 0x08000000 pollution: CR_GT #define CR_GT 0x40000000 pollution: CR_LT #define CR_LT 0x80000000 pollution: CR_OX #define CR_OX 0x01000000 pollution: CR_SO #define CR_SO 0x10000000 pollution: CR_VX #define CR_VX 0x02000000 pollution: DBL_DECIMAL_DIG #define DBL_DECIMAL_DIG __DBL_DECIMAL_DIG__ pollution: DBL_DIG #define DBL_DIG __DBL_DIG__ pollution: DBL_EPSILON #define DBL_EPSILON __DBL_EPSILON__ pollution: DBL_HAS_SUBNORM #define DBL_HAS_SUBNORM __DBL_HAS_DENORM__ pollution: DBL_INFINITY #define DBL_INFINITY (*((double *) (_DBLINF))) pollution: DBL_MANT_DIG #define DBL_MANT_DIG __DBL_MANT_DIG__ pollution: DBL_MAX #define DBL_MAX __DBL_MAX__ pollution: DBL_MAX_10_EXP #define DBL_MAX_10_EXP __DBL_MAX_10_EXP__ pollution: DBL_MAX_EXP #define DBL_MAX_EXP __DBL_MAX_EXP__ pollution: DBL_MIN #define DBL_MIN __DBL_MIN__ pollution: DBL_MIN_10_EXP #define DBL_MIN_10_EXP __DBL_MIN_10_EXP__ pollution: DBL_MIN_EXP #define DBL_MIN_EXP __DBL_MIN_EXP__ pollution: DBL_QNAN #define DBL_QNAN (*((double *) (DQNAN))) pollution: DBL_SNAN #define DBL_SNAN (*((double *) (DSNAN))) pollution: DBL_TRUE_MIN #define DBL_TRUE_MIN __DBL_DENORM_MIN__ pollution: DDN_X25 #define DDN_X25 IFT_X25DDN pollution: DECIMAL_DIG #define DECIMAL_DIG __DECIMAL_DIG__ pollution: DECR_STAT_IFV6 #define DECR_STAT_IFV6(ifp,cpu,field) do { NETSTAT_LOCK_IF_DECL(); if ((ifp) != NULL) { NETSTAT_LOCK_IF((ifp)); if (((ifp)->if_ext != NULL) && ((ifp)->if_ext->if_ip6stat_ptr != NULL)){ (ifp)->if_ext->if_ip6stat_ptr[(cpu)].field--; } NETSTAT_UNLOCK_IF(ifp); } } while (0) pollution: DEFAULT_GPR #define DEFAULT_GPR 0xDEADBEEF pollution: DEFAULT_MSR #define DEFAULT_MSR (MSR_EE|MSR_ME|MSR_IR|MSR_DR|MSR_RI) pollution: DEFAULT_USER_MSR #define DEFAULT_USER_MSR (DEFAULT_MSR | MSR_PR) pollution: DEFAULT_WEIGHT #define DEFAULT_WEIGHT 1 pollution: DELAYTIMER_MAX #define DELAYTIMER_MAX _POSIX_DELAYTIMER_MAX pollution: DEV_OFF_MAX #define DEV_OFF_MAX 0xffffffffffLL pollution: DINFINITY #define DINFINITY _DBLINF pollution: DPFD_DEEP #define DPFD_DEEP 5 pollution: DPFD_DEEPER #define DPFD_DEEPER 6 pollution: DPFD_DEEPEST #define DPFD_DEEPEST 7 pollution: DPFD_DEFAULT #define DPFD_DEFAULT 0 pollution: DPFD_MEDIUM #define DPFD_MEDIUM 4 pollution: DPFD_NONE #define DPFD_NONE 1 pollution: DPFD_SHALLOW #define DPFD_SHALLOW 3 pollution: DPFD_SHALLOWEST #define DPFD_SHALLOWEST 2 pollution: DSCR_DLDP #define DSCR_DLDP (1<<5) pollution: DSCR_DPFD_MASK #define DSCR_DPFD_MASK (0x7) pollution: DSCR_DPFD_SHIFT #define DSCR_DPFD_SHIFT (0) pollution: DSCR_GET_PROPERTIES #define DSCR_GET_PROPERTIES 3 pollution: DSCR_HWTE #define DSCR_HWTE (1<<23) pollution: DSCR_HWUE #define DSCR_HWUE (1<<19) pollution: DSCR_LSD #define DSCR_LSD DSCR_DLDP pollution: DSCR_LTE #define DSCR_LTE (1<<21) pollution: DSCR_MASK #define DSCR_MASK 0x0F pollution: DSCR_MASKV205 #define DSCR_MASKV205 DSCR_MASK pollution: DSCR_MASKV206 #define DSCR_MASKV206 0x3F pollution: DSCR_MASKV206_1 #define DSCR_MASKV206_1 0x3F pollution: DSCR_MASKV206_2 #define DSCR_MASKV206_2 0x1FF pollution: DSCR_MASKV207 #define DSCR_MASKV207 0x1FFFFFF pollution: DSCR_PROP_SIZE #define DSCR_PROP_SIZE DSCR_PROP_VER2_SIZE pollution: DSCR_PROP_SMTS #define DSCR_PROP_SMTS 5 pollution: DSCR_PROP_VER #define DSCR_PROP_VER DSCR_PROP_VER2 pollution: DSCR_PROP_VER0 #define DSCR_PROP_VER0 0x44530000 pollution: DSCR_PROP_VER0_SIZE #define DSCR_PROP_VER0_SIZE (offsetof(struct dscr_properties, dscr_version)) pollution: DSCR_PROP_VER1 #define DSCR_PROP_VER1 0x44530001 pollution: DSCR_PROP_VER1_SIZE #define DSCR_PROP_VER1_SIZE (offsetof(struct dscr_properties, dscr_smt)) pollution: DSCR_PROP_VER2 #define DSCR_PROP_VER2 0x44530002 pollution: DSCR_PROP_VER2_SIZE #define DSCR_PROP_VER2_SIZE (sizeof(struct dscr_properties)) pollution: DSCR_READ #define DSCR_READ 2 pollution: DSCR_SET_DEFAULT #define DSCR_SET_DEFAULT 4 pollution: DSCR_SNSE #define DSCR_SNSE (1<<4) pollution: DSCR_SSE #define DSCR_SSE (1<<3) pollution: DSCR_STE #define DSCR_STE (1<<22) pollution: DSCR_SWTE #define DSCR_SWTE (1<<24) pollution: DSCR_SWUE #define DSCR_SWUE (1<<20) pollution: DSCR_SYS_AUTO_OFF #define DSCR_SYS_AUTO_OFF 0 pollution: DSCR_SYS_AUTO_ON #define DSCR_SYS_AUTO_ON 1 pollution: DSCR_UNITCNT #define DSCR_UNITCNT(_cnt) ((_cnt & DSCR_UNITCNT_MASK) << DSCR_UNITCNT_SHIFT) pollution: DSCR_UNITCNT_MASK #define DSCR_UNITCNT_MASK (0x3FF) pollution: DSCR_UNITCNT_SHIFT #define DSCR_UNITCNT_SHIFT (9) pollution: DSCR_URG_MASK #define DSCR_URG_MASK (0x7) pollution: DSCR_URG_SHIFT #define DSCR_URG_SHIFT (6) pollution: DSCR_V205 #define DSCR_V205 0x205 pollution: DSCR_V206 #define DSCR_V206 0x206 pollution: DSCR_V206_1 #define DSCR_V206_1 0x10206 pollution: DSCR_V206_2 #define DSCR_V206_2 0x20206 pollution: DSCR_V207 #define DSCR_V207 0x207 pollution: DSCR_WRITE #define DSCR_WRITE 1 pollution: DSISR_AO_INV #define DSISR_AO_INV 0x00000004 pollution: DSISR_COPV #define DSISR_COPV 0x00004000 pollution: DSISR_COPYV #define DSISR_COPYV 0x00000008 pollution: DSISR_CSMV #define DSISR_CSMV 0x00000010 pollution: DSISR_DABR #define DSISR_DABR 0x00400000 pollution: DSISR_DAC #define DSISR_DAC 0x00400000 pollution: DSISR_DRST #define DSISR_DRST 0x04000000 pollution: DSISR_EAR #define DSISR_EAR 0x00100000 pollution: DSISR_FPIO #define DSISR_FPIO 0x10000000 pollution: DSISR_IMP_DSI #define DSISR_IMP_DSI 0x00020000 pollution: DSISR_IO #define DSISR_IO 0x80000000 pollution: DSISR_LOCK #define DSISR_LOCK 0x20000000 pollution: DSISR_LOOP #define DSISR_LOOP 0x04000000 pollution: DSISR_PFT #define DSISR_PFT 0x40000000 pollution: DSISR_PROT #define DSISR_PROT 0x08000000 pollution: DSISR_SEGB #define DSISR_SEGB 0x01000000 pollution: DSISR_SKEY #define DSISR_SKEY 0x00200000 pollution: DSISR_ST #define DSISR_ST 0x02000000 pollution: DSISR_STAB #define DSISR_STAB 0x00200000 pollution: DST_AUST #define DST_AUST 2 pollution: DST_CAN #define DST_CAN 6 pollution: DST_EET #define DST_EET 5 pollution: DST_MET #define DST_MET 4 pollution: DST_NONE #define DST_NONE 0 pollution: DST_USA #define DST_USA 1 pollution: DST_WET #define DST_WET 3 pollution: EMGR_CID #define EMGR_CID 0xFFFD pollution: EQUIV_CLASS_MAX #define EQUIV_CLASS_MAX 4 pollution: ETHERNET_CSMACD #define ETHERNET_CSMACD IFT_ETHER pollution: EXPR_NEST_MAX #define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX pollution: EYEC_RTENTRYA #define EYEC_RTENTRYA 0x257274656E747241ull pollution: EYEC_RTENTRYC #define EYEC_RTENTRYC 0x257274656E747243ull pollution: EYEC_RTENTRYF #define EYEC_RTENTRYF 0x257274656E747246ull pollution: FALSE #define FALSE 0 pollution: FAVORED_JITTER_DISPATCH_WINDOW #define FAVORED_JITTER_DISPATCH_WINDOW (1) pollution: FDDI #define FDDI IFT_FDDI pollution: FD_CLR #define FD_CLR(n,p) ((p)->fds_bits[(n)/__NFDBITS] &= ~((long)1 << ((n) % __NFDBITS))) pollution: FD_ISSET #define FD_ISSET(n,p) (((p)->fds_bits[(n)/__NFDBITS] & ((long)1 << ((n) % __NFDBITS)))?1:0) pollution: FD_SET #define FD_SET(n,p) ((p)->fds_bits[(n)/__NFDBITS] |= ((long)1 << ((n) % __NFDBITS))) pollution: FD_SETSIZE #define FD_SETSIZE 65534 pollution: FD_ZERO #define FD_ZERO(p) memset((p), 0, sizeof(*(p))) pollution: FHSIZE #define FHSIZE 32 pollution: FLOW6_RAND #define FLOW6_RAND 49 pollution: FLT_DECIMAL_DIG #define FLT_DECIMAL_DIG __FLT_DECIMAL_DIG__ pollution: FLT_DIG #define FLT_DIG __FLT_DIG__ pollution: FLT_EPSILON #define FLT_EPSILON __FLT_EPSILON__ pollution: FLT_EVAL_METHOD #define FLT_EVAL_METHOD __FLT_EVAL_METHOD__ pollution: FLT_HAS_SUBNORM #define FLT_HAS_SUBNORM __FLT_HAS_DENORM__ pollution: FLT_INFINITY #define FLT_INFINITY (*((float *) (&SINFINITY))) pollution: FLT_MANT_DIG #define FLT_MANT_DIG __FLT_MANT_DIG__ pollution: FLT_MAX #define FLT_MAX __FLT_MAX__ pollution: FLT_MAX_10_EXP #define FLT_MAX_10_EXP __FLT_MAX_10_EXP__ pollution: FLT_MAX_EXP #define FLT_MAX_EXP __FLT_MAX_EXP__ pollution: FLT_MIN #define FLT_MIN __FLT_MIN__ pollution: FLT_MIN_10_EXP #define FLT_MIN_10_EXP __FLT_MIN_10_EXP__ pollution: FLT_MIN_EXP #define FLT_MIN_EXP __FLT_MIN_EXP__ pollution: FLT_QNAN #define FLT_QNAN (*((float *) (&SQNAN))) pollution: FLT_RADIX #define FLT_RADIX __FLT_RADIX__ pollution: FLT_ROUNDS #define FLT_ROUNDS (__builtin_flt_rounds()) pollution: FLT_SNAN #define FLT_SNAN (*((float *) (&SSNAN))) pollution: FLT_TRUE_MIN #define FLT_TRUE_MIN __FLT_DENORM_MIN__ pollution: FP_MINUS_DENORM #define FP_MINUS_DENORM 7 pollution: FP_MINUS_INF #define FP_MINUS_INF 5 pollution: FP_MINUS_NORM #define FP_MINUS_NORM 1 pollution: FP_MINUS_ZERO #define FP_MINUS_ZERO 3 pollution: FP_PLUS_DENORM #define FP_PLUS_DENORM 6 pollution: FP_PLUS_INF #define FP_PLUS_INF 4 pollution: FP_PLUS_NORM #define FP_PLUS_NORM 0 pollution: FP_PLUS_ZERO #define FP_PLUS_ZERO 2 pollution: FP_QNAN #define FP_QNAN 9 pollution: FP_RND_RM #define FP_RND_RM 3 pollution: FP_RND_RN #define FP_RND_RN 1 pollution: FP_RND_RP #define FP_RND_RP 2 pollution: FP_RND_RZ #define FP_RND_RZ 0 pollution: FP_SNAN #define FP_SNAN 8 pollution: FRAGINDX #define FRAGINDX 16 pollution: FWADUMP_DATA #define FWADUMP_DATA 0x1 pollution: Free #define Free(p) free((char *)p); pollution: GET_LIOBN #define GET_LIOBN(xp) ((liobn_t)xp->rem_liobn) pollution: GROUP_SOURCE_FILTER_SIZE #define GROUP_SOURCE_FILTER_SIZE(numsrc) (sizeof(struct group_source_filter_req) + ((numsrc) - 1) * sizeof(struct sockaddr_storage)) pollution: HAS_KCS #define HAS_KCS(x,y) (((x & y) == y) && !( ((y == KCS_ACTIVE) && (x != KCS_ACTIVE)) || ((y == KCS_FROZEN) && (x & KCSBIT_START)) || ((y == KCS_STOPPING) && (x & KCSBIT_START)) || ((y == KCS_STARTING) && (x & KCSBIT_STOP)) )) pollution: HDH1822 #define HDH1822 IFT_HDH1822 pollution: HOST_NAME_MAX #define HOST_NAME_MAX 256 pollution: HTONL #define HTONL(x) pollution: HTONLL #define HTONLL(x) pollution: HTONS #define HTONS(x) pollution: HYPERCHANNEL #define HYPERCHANNEL IFT_HY pollution: IA6_TO_ARRAY16 #define IA6_TO_ARRAY16(a) (a).s6_addr16[7], (a).s6_addr16[6], (a).s6_addr16[5], (a).s6_addr16[4], (a).s6_addr16[3], (a).s6_addr16[2], (a).s6_addr16[1], (a).s6_addr16[0] pollution: ICMP6_FILTER #define ICMP6_FILTER 38 pollution: ICMP6_SEC_SEND_DEL #define ICMP6_SEC_SEND_DEL 70 pollution: ICMP6_SEC_SEND_GET #define ICMP6_SEC_SEND_GET 71 pollution: ICMP6_SEC_SEND_SET #define ICMP6_SEC_SEND_SET 68 pollution: ICMP6_SEC_SEND_SET_CGA_ADDR #define ICMP6_SEC_SEND_SET_CGA_ADDR 69 pollution: IF6MULTI_INITLOCK #define IF6MULTI_INITLOCK(ifp) { lock_alloc(&(ifp)->if6_multi_lock, LOCK_ALLOC_PIN, IF6MULTI_LOCK_FAMILY, (short32uint64_t)ifp); simple_lock_init(&(ifp)->if6_multi_lock); } pollution: IF6MULTI_LOCK #define IF6MULTI_LOCK(ifp) _if6ml = disable_lock(PL_IMP, &(ifp)->if6_multi_lock) pollution: IF6MULTI_LOCK_DECL #define IF6MULTI_LOCK_DECL() int _if6ml; pollution: IF6MULTI_LOCK_RECURSIVE #define IF6MULTI_LOCK_RECURSIVE(ifp) IF6MULTI_LOCK(ifp) pollution: IF6MULTI_UNLOCK #define IF6MULTI_UNLOCK(ifp) unlock_enable(_if6ml, &(ifp)->if6_multi_lock) pollution: IF6MULTI_UNLOCK_RECURSIVE #define IF6MULTI_UNLOCK_RECURSIVE(ifp) IF6MULTI_UNLOCK(ifp) pollution: IFADDRLIST_INITLOCK #define IFADDRLIST_INITLOCK(ifp) { lock_alloc(&(ifp)->if_addrlist_lock, LOCK_ALLOC_PIN, IFADDRLIST_LOCK_FAMILY, (short32uint64_t)ifp); simple_lock_init(&(ifp)->if_addrlist_lock); } pollution: IFADDRLIST_LOCK_DECL #define IFADDRLIST_LOCK_DECL() int _ifal; pollution: IFADDRLIST_READ_LOCK #define IFADDRLIST_READ_LOCK(ifp) _ifal = disable_lock(PL_IMP, &(ifp)->if_addrlist_lock) pollution: IFADDRLIST_UNLOCK #define IFADDRLIST_UNLOCK(ifp) unlock_enable(_ifal, &(ifp)->if_addrlist_lock) pollution: IFADDRLIST_WRITE_LOCK #define IFADDRLIST_WRITE_LOCK(ifp) _ifal = disable_lock(PL_IMP, &(ifp)->if_addrlist_lock) pollution: IFARP_COUNT #define IFARP_COUNT 4 pollution: IFARP_INTERVAL_NSEC #define IFARP_INTERVAL_NSEC 1000000 pollution: IFA_FIRSTALIAS #define IFA_FIRSTALIAS RTF_BUL pollution: IFA_ROUTE #define IFA_ROUTE RTF_UP pollution: IFF_64BIT #define IFF_64BIT 0x4000000 pollution: IFF_ALLCAST #define IFF_ALLCAST 0x20000 pollution: IFF_ALLMULTI #define IFF_ALLMULTI 0x200 pollution: IFF_BPF #define IFF_BPF 0x8000000 pollution: IFF_BRIDGE #define IFF_BRIDGE 0x40000 pollution: IFF_BROADCAST #define IFF_BROADCAST 0x2 pollution: IFF_CANTCHANGE #define IFF_CANTCHANGE (IFF_BROADCAST|IFF_POINTOPOINT|IFF_SIMPLEX|IFF_RUNNING|IFF_OACTIVE|IFF_MULTICAST) pollution: IFF_CHECKSUM_OFFLOAD #define IFF_CHECKSUM_OFFLOAD 0x10000000 pollution: IFF_D1 #define IFF_D1 0x8000 pollution: IFF_D2 #define IFF_D2 0x4000 pollution: IFF_D3 #define IFF_D3 0x2000 pollution: IFF_D4 #define IFF_D4 0x1000 pollution: IFF_DEBUG #define IFF_DEBUG 0x4 pollution: IFF_DEVHEALTH #define IFF_DEVHEALTH IFF_D2 pollution: IFF_DO_HW_LOOPBACK #define IFF_DO_HW_LOOPBACK 0x10000 pollution: IFF_GROUP_ROUTING #define IFF_GROUP_ROUTING 0x2000000 pollution: IFF_IFBUFMGT #define IFF_IFBUFMGT 0x800000 pollution: IFF_LINK0 #define IFF_LINK0 0x100000 pollution: IFF_LINK1 #define IFF_LINK1 0x200000 pollution: IFF_LINK2 #define IFF_LINK2 0x400000 pollution: IFF_LOOPBACK #define IFF_LOOPBACK 0x8 pollution: IFF_MULTICAST #define IFF_MULTICAST 0x80000 pollution: IFF_NOARP #define IFF_NOARP 0x80 pollution: IFF_NOECHO #define IFF_NOECHO IFF_SIMPLEX pollution: IFF_NOTRAILERS #define IFF_NOTRAILERS 0x20 pollution: IFF_OACTIVE #define IFF_OACTIVE 0x400 pollution: IFF_POINTOPOINT #define IFF_POINTOPOINT 0x10 pollution: IFF_PROMISC #define IFF_PROMISC 0x100 pollution: IFF_PSEG #define IFF_PSEG 0x40000000 pollution: IFF_RUNNING #define IFF_RUNNING 0x40 pollution: IFF_SIMPLEX #define IFF_SIMPLEX 0x800 pollution: IFF_SNAP #define IFF_SNAP IFF_D1 pollution: IFF_TCP_DISABLE_CKSUM #define IFF_TCP_DISABLE_CKSUM 0x20000000 pollution: IFF_TCP_NOCKSUM #define IFF_TCP_NOCKSUM 0x1000000 pollution: IFF_UP #define IFF_UP 0x1 pollution: IFF_VIPA #define IFF_VIPA 0x80000000 pollution: IFMULTI_INITLOCK #define IFMULTI_INITLOCK(ifp) { lock_alloc(&(ifp)->if_multi_lock, LOCK_ALLOC_PIN, IFMULTI_LOCK_FAMILY, (short32uint64_t)ifp); simple_lock_init(&(ifp)->if_multi_lock); } pollution: IFMULTI_LOCK #define IFMULTI_LOCK(ifp) ifp->ifml = disable_lock(PL_IMP, &(ifp)->if_multi_lock) pollution: IFMULTI_LOCK_RECURSIVE #define IFMULTI_LOCK_RECURSIVE(ifp) IFMULTI_LOCK(ifp) pollution: IFMULTI_UNLOCK #define IFMULTI_UNLOCK(ifp) unlock_enable(ifp->ifml, &(ifp)->if_multi_lock) pollution: IFMULTI_UNLOCK_RECURSIVE #define IFMULTI_UNLOCK_RECURSIVE(ifp) IFMULTI_UNLOCK(ifp) pollution: IFNAMSIZ #define IFNAMSIZ 16 pollution: IFNET_SLOWHZ #define IFNET_SLOWHZ 1 pollution: IFO_AACCT #define IFO_AACCT 0x00000100 pollution: IFO_CSO_IPV6 #define IFO_CSO_IPV6 0x00000800 pollution: IFO_FIRSTALIAS #define IFO_FIRSTALIAS 0x00010000 pollution: IFO_FLUSH #define IFO_FLUSH 0x00000001 pollution: IFO_HIGHFUNC_QOS #define IFO_HIGHFUNC_QOS 0x00000002 pollution: IFO_LARGESEND #define IFO_LARGESEND 0x00000040 pollution: IFO_LARGESEND_PLATFORM #define IFO_LARGESEND_PLATFORM 0x00080000 pollution: IFO_LARGESEND_PLO #define IFO_LARGESEND_PLO 0x00040000 pollution: IFO_LSO_IPV6 #define IFO_LSO_IPV6 0x00001000 pollution: IFO_LVUPDATE #define IFO_LVUPDATE 0x00100000 pollution: IFO_MEDFUNC_QOS #define IFO_MEDFUNC_QOS 0x00000004 pollution: IFO_MINFUNC_QOS #define IFO_MINFUNC_QOS 0x00000008 pollution: IFO_MONITOR #define IFO_MONITOR 0x00000200 pollution: IFO_PARTIAL_CSO_IPV4 #define IFO_PARTIAL_CSO_IPV4 0x00004000 pollution: IFO_PARTIAL_CSO_IPV6 #define IFO_PARTIAL_CSO_IPV6 0x00002000 pollution: IFO_PKTCHAIN #define IFO_PKTCHAIN 0x00000080 pollution: IFO_PSEUDO_CLUSTER #define IFO_PSEUDO_CLUSTER 0x00020000 pollution: IFO_QOS #define IFO_QOS (IFO_HIGHFUNC_QOS|IFO_MEDFUNC_QOS|IFO_MINFUNC_QOS) pollution: IFO_RNIC #define IFO_RNIC 0x00008000 pollution: IFO_SHARED_ETHERNET #define IFO_SHARED_ETHERNET 0x00200000 pollution: IFO_THREAD #define IFO_THREAD 0x00000020 pollution: IFO_VIRTUAL_ETHERNET #define IFO_VIRTUAL_ETHERNET 0x00000400 pollution: IFQ_LOCK #define IFQ_LOCK(ifq) _qs = disable_lock(PL_IMP ,&((ifq)->ifq_slock)) pollution: IFQ_LOCKINIT #define IFQ_LOCKINIT(ifq) { lock_alloc(&((ifq)->ifq_slock), LOCK_ALLOC_PIN, IFQ_LOCK_FAMILY, (short32uint64_t)(ifq)); simple_lock_init(&((ifq)->ifq_slock)); } pollution: IFQ_LOCK_DECL #define IFQ_LOCK_DECL() int _qs; pollution: IFQ_MAXLEN #define IFQ_MAXLEN 50 pollution: IFQ_UNLOCK #define IFQ_UNLOCK(ifq) unlock_enable(_qs, &((ifq)->ifq_slock)) pollution: IFT_1822 #define IFT_1822 0x2 pollution: IFT_AAL5 #define IFT_AAL5 0x31 pollution: IFT_ARCNET #define IFT_ARCNET 0x23 pollution: IFT_ARCNETPLUS #define IFT_ARCNETPLUS 0x24 pollution: IFT_ATM #define IFT_ATM 0x25 pollution: IFT_CEPT #define IFT_CEPT 0x13 pollution: IFT_CLUSTER #define IFT_CLUSTER 0x3e pollution: IFT_DS3 #define IFT_DS3 0x1e pollution: IFT_EON #define IFT_EON 0x19 pollution: IFT_ETHER #define IFT_ETHER 0x6 pollution: IFT_FCS #define IFT_FCS 0x3a pollution: IFT_FDDI #define IFT_FDDI 0xf pollution: IFT_FRELAY #define IFT_FRELAY 0x20 pollution: IFT_FRELAYDCE #define IFT_FRELAYDCE 0x2c pollution: IFT_GIFTUNNEL #define IFT_GIFTUNNEL 0x3c pollution: IFT_HDH1822 #define IFT_HDH1822 0x3 pollution: IFT_HF #define IFT_HF 0x3d pollution: IFT_HIPPI #define IFT_HIPPI 0x2f pollution: IFT_HSSI #define IFT_HSSI 0x2e pollution: IFT_HY #define IFT_HY 0xe pollution: IFT_IB #define IFT_IB 0xc7 pollution: IFT_ISDNBASIC #define IFT_ISDNBASIC 0x14 pollution: IFT_ISDNPRIMARY #define IFT_ISDNPRIMARY 0x15 pollution: IFT_ISO88022LLC #define IFT_ISO88022LLC 0x29 pollution: IFT_ISO88023 #define IFT_ISO88023 0x7 pollution: IFT_ISO88024 #define IFT_ISO88024 0x8 pollution: IFT_ISO88025 #define IFT_ISO88025 0x9 pollution: IFT_ISO88026 #define IFT_ISO88026 0xa pollution: IFT_LAPB #define IFT_LAPB 0x10 pollution: IFT_LOCALTALK #define IFT_LOCALTALK 0x2a pollution: IFT_LOOP #define IFT_LOOP 0x18 pollution: IFT_MIOX25 #define IFT_MIOX25 0x26 pollution: IFT_MODEM #define IFT_MODEM 0x30 pollution: IFT_NSIP #define IFT_NSIP 0x1b pollution: IFT_OTHER #define IFT_OTHER 0x1 pollution: IFT_P10 #define IFT_P10 0xc pollution: IFT_P80 #define IFT_P80 0xd pollution: IFT_PARA #define IFT_PARA 0x22 pollution: IFT_PPP #define IFT_PPP 0x17 pollution: IFT_PROPMUX #define IFT_PROPMUX 0x36 pollution: IFT_PROPVIRTUAL #define IFT_PROPVIRTUAL 0x35 pollution: IFT_PTPSERIAL #define IFT_PTPSERIAL 0x16 pollution: IFT_RS232 #define IFT_RS232 0x21 pollution: IFT_SDLC #define IFT_SDLC 0x11 pollution: IFT_SIP #define IFT_SIP 0x1f pollution: IFT_SLIP #define IFT_SLIP 0x1c pollution: IFT_SMDSDXI #define IFT_SMDSDXI 0x2b pollution: IFT_SMDSICIP #define IFT_SMDSICIP 0x34 pollution: IFT_SN #define IFT_SN 0x38 pollution: IFT_SONET #define IFT_SONET 0x27 pollution: IFT_SONETPATH #define IFT_SONETPATH 0x32 pollution: IFT_SONETVT #define IFT_SONETVT 0x33 pollution: IFT_SP #define IFT_SP 0x39 pollution: IFT_STARLAN #define IFT_STARLAN 0xb pollution: IFT_T1 #define IFT_T1 0x12 pollution: IFT_TUNNEL #define IFT_TUNNEL 0x3b pollution: IFT_ULTRA #define IFT_ULTRA 0x1d pollution: IFT_V35 #define IFT_V35 0x2d pollution: IFT_VIPA #define IFT_VIPA 0x37 pollution: IFT_X25 #define IFT_X25 0x5 pollution: IFT_X25DDN #define IFT_X25DDN 0x4 pollution: IFT_X25PLE #define IFT_X25PLE 0x28 pollution: IFT_XETHER #define IFT_XETHER 0x1a pollution: IN6ADDR_ANY_INIT #define IN6ADDR_ANY_INIT {0, 0, 0, 0} pollution: IN6ADDR_LOOPBACK_INIT #define IN6ADDR_LOOPBACK_INIT {0, 0, 0, 1} pollution: IN6_ADDR_V6_TO_V4 #define IN6_ADDR_V6_TO_V4(a) ((struct in_addr *)&(a)->s6_addr[12]) pollution: IN6_ARE_ADDR_EQUAL #define IN6_ARE_ADDR_EQUAL(pa,pb) SAME_ADDR6(*pa,*pb) pollution: IN6_IS_ADDR_LINKLOCAL #define IN6_IS_ADDR_LINKLOCAL(p) IS_LINKLADDR6(*p) pollution: IN6_IS_ADDR_LOOPBACK #define IN6_IS_ADDR_LOOPBACK(p) IS_LOOPADDR6(*p) pollution: IN6_IS_ADDR_MC_ADMINLOCAL #define IN6_IS_ADDR_MC_ADMINLOCAL(p) (IS_MULTIADDR6(*p) && (MADDR6_SCOPE(*p) == MADDR6_SCP_ADMIN)) pollution: IN6_IS_ADDR_MC_GLOBAL #define IN6_IS_ADDR_MC_GLOBAL(p) (IS_MULTIADDR6(*p) && (MADDR6_SCOPE(*p) == MADDR6_SCP_GLO)) pollution: IN6_IS_ADDR_MC_INTFLOCAL #define IN6_IS_ADDR_MC_INTFLOCAL(p) (IS_MULTIADDR6(*p) && (MADDR6_SCOPE(*p) == MADDR6_SCP_INTF)) pollution: IN6_IS_ADDR_MC_LINKLOCAL #define IN6_IS_ADDR_MC_LINKLOCAL(p) (IS_MULTIADDR6(*p) && (MADDR6_SCOPE(*p) == MADDR6_SCP_LINK)) pollution: IN6_IS_ADDR_MC_NODELOCAL #define IN6_IS_ADDR_MC_NODELOCAL(p) (IS_MULTIADDR6(*p) && (MADDR6_SCOPE(*p) == MADDR6_SCP_NODE)) pollution: IN6_IS_ADDR_MC_ORGLOCAL #define IN6_IS_ADDR_MC_ORGLOCAL(p) (IS_MULTIADDR6(*p) && (MADDR6_SCOPE(*p) == MADDR6_SCP_ORG)) pollution: IN6_IS_ADDR_MC_SITELOCAL #define IN6_IS_ADDR_MC_SITELOCAL(p) (IS_MULTIADDR6(*p) && (MADDR6_SCOPE(*p) == MADDR6_SCP_SITE)) pollution: IN6_IS_ADDR_MULTICAST #define IN6_IS_ADDR_MULTICAST(p) IS_MULTIADDR6(*p) pollution: IN6_IS_ADDR_SITELOCAL #define IN6_IS_ADDR_SITELOCAL(p) IS_SITELADDR6(*p) pollution: IN6_IS_ADDR_UNSPECIFIED #define IN6_IS_ADDR_UNSPECIFIED(p) IS_ANYADDR6(*p) pollution: IN6_IS_ADDR_V4COMPAT #define IN6_IS_ADDR_V4COMPAT(p) IS_COMPATADDR6(*p) pollution: IN6_IS_ADDR_V4MAPPED #define IN6_IS_ADDR_V4MAPPED(p) IS_IPV4ADDR6(*p) pollution: INADDR_ALLHOSTS_GROUP #define INADDR_ALLHOSTS_GROUP (uint32_t)0xe0000001 pollution: INADDR_ALLRTRS_GROUP #define INADDR_ALLRTRS_GROUP (uint32_t)0xe0000002 pollution: INADDR_ANY #define INADDR_ANY ((uint32_t)0x00000000) pollution: INADDR_BROADCAST #define INADDR_BROADCAST ((uint32_t)0xffffffff) pollution: INADDR_LOOPBACK #define INADDR_LOOPBACK (uint32_t)0x7f000001 pollution: INADDR_MAX_LOCAL_GROUP #define INADDR_MAX_LOCAL_GROUP (uint32_t)0xe00000ff pollution: INADDR_NONE #define INADDR_NONE 0xffffffff pollution: INADDR_UNSPEC_GROUP #define INADDR_UNSPEC_GROUP (uint32_t)0xe0000000 pollution: INADDR_V3_DEST_ADDR #define INADDR_V3_DEST_ADDR (uint32_t)0xe0000016 pollution: INCR_STAT_IF #define INCR_STAT_IF(ifp,cpu,field) do { NETSTAT_LOCK_IF_DECL(); if ((ifp) != NULL) { NETSTAT_LOCK_IF((ifp)); if (((ifp)->if_ext != NULL) && ((ifp)->if_ext->if_ipstat_ptr != NULL)) { (ifp)->if_ext->if_ipstat_ptr[(cpu)].field++; } NETSTAT_UNLOCK_IF((ifp)); } } while (0) pollution: INCR_STAT_IFV6 #define INCR_STAT_IFV6(ifp,cpu,field) do { NETSTAT_LOCK_IF_DECL(); if ((ifp) != NULL) { NETSTAT_LOCK_IF((ifp)); if (((ifp)->if_ext != NULL) && ((ifp)->if_ext->if_ip6stat_ptr != NULL)){ (ifp)->if_ext->if_ip6stat_ptr[(cpu)].field++; } NETSTAT_UNLOCK_IF((ifp)); } } while (0) pollution: INET6_ADDRSTRLEN #define INET6_ADDRSTRLEN 46 pollution: INET_ADDRSTRLEN #define INET_ADDRSTRLEN 16 pollution: INITKMEMNAMES #define INITKMEMNAMES { "free", "mbuf", "mcluster", "socket", "pcb", "routetbl", "fragtbl", "ifaddr", "soopts", "soname", "mblk", "mblkdata", "strhead", "strqueue", "strqband", "strmodsw", "strsigs", "strpoll", "strosr", "strsyncq", "streams", "iov", "fhandle", "NFS req", "NFS mount", "file", "file desc", "ioctlops", "select/poll", "devbuf", "pathname", "kernel table", "mount", "superblock", "UFS mount", "S5FS mount", "S5FS superbk", "vnode", "spec info", "spec alias", "spec buf", "locking", "devsw", "", "mls netcred", "mls ruletbl", "", "", "kalloc", "temp", "mcast opts", "mcast addrs", "ll mc addrs", "acf desc", "acf buf", "mcl_group", "mcl_entry", "artifacts", } pollution: INSTALLP_CID #define INSTALLP_CID 0xFFFC pollution: INT16_C #define INT16_C(c) c pollution: INT16_MAX #define INT16_MAX (32767) pollution: INT16_MIN #define INT16_MIN (-32767-1) pollution: INT32_C #define INT32_C(c) c pollution: INT32_MAX #define INT32_MAX (2147483647) pollution: INT32_MIN #define INT32_MIN (-2147483647-1) pollution: INT64_C #define INT64_C(c) __CONCAT__(c,LL) pollution: INT64_MAX #define INT64_MAX (INT64_C(9223372036854775807)) pollution: INT64_MIN #define INT64_MIN (INT64_C(-9223372036854775807)-1) pollution: INT8_C #define INT8_C(c) c pollution: INT8_MAX #define INT8_MAX (127) pollution: INT8_MIN #define INT8_MIN (-128) pollution: INTERNET_TYPE #define INTERNET_TYPE 255 pollution: INTFAST_MAX #define INTFAST_MAX INT32_MAX pollution: INTFAST_MIN #define INTFAST_MIN INT32_MIN pollution: INTMAX_C #define INTMAX_C(c) __CONCAT__(c,LL) pollution: INTMAX_MAX #define INTMAX_MAX INT64_MAX pollution: INTMAX_MIN #define INTMAX_MIN INT64_MIN pollution: INTPTR_MAX #define INTPTR_MAX (2147483647L) pollution: INTPTR_MIN #define INTPTR_MIN (-2147483647L-1) pollution: INT_FAST16_MAX #define INT_FAST16_MAX INT16_MAX pollution: INT_FAST16_MIN #define INT_FAST16_MIN INT16_MIN pollution: INT_FAST32_MAX #define INT_FAST32_MAX INT32_MAX pollution: INT_FAST32_MIN #define INT_FAST32_MIN INT32_MIN pollution: INT_FAST64_MAX #define INT_FAST64_MAX INT64_MAX pollution: INT_FAST64_MIN #define INT_FAST64_MIN INT64_MIN pollution: INT_FAST8_MAX #define INT_FAST8_MAX INT8_MAX pollution: INT_FAST8_MIN #define INT_FAST8_MIN INT8_MIN pollution: INT_LEAST16_MAX #define INT_LEAST16_MAX INT16_MAX pollution: INT_LEAST16_MIN #define INT_LEAST16_MIN INT16_MIN pollution: INT_LEAST32_MAX #define INT_LEAST32_MAX INT32_MAX pollution: INT_LEAST32_MIN #define INT_LEAST32_MIN INT32_MIN pollution: INT_LEAST64_MAX #define INT_LEAST64_MAX INT64_MAX pollution: INT_LEAST64_MIN #define INT_LEAST64_MIN INT64_MIN pollution: INT_LEAST8_MAX #define INT_LEAST8_MAX INT8_MAX pollution: INT_LEAST8_MIN #define INT_LEAST8_MIN INT8_MIN pollution: INT_MAX #define INT_MAX (2147483647) pollution: INT_MIN #define INT_MIN (-INT_MAX - 1) pollution: INVALID_CID #define INVALID_CID 0xFFFF pollution: IN_BADCLASS #define IN_BADCLASS(i) (((int32_t)(i) & 0xf0000000) == 0xf0000000) pollution: IN_CLASSA #define IN_CLASSA(i) (((int32_t)(i) & 0x80000000) == 0) pollution: IN_CLASSA_HOST #define IN_CLASSA_HOST 0x00ffffff pollution: IN_CLASSA_MAX #define IN_CLASSA_MAX 128 pollution: IN_CLASSA_NET #define IN_CLASSA_NET 0xff000000 pollution: IN_CLASSA_NSHIFT #define IN_CLASSA_NSHIFT 24 pollution: IN_CLASSB #define IN_CLASSB(i) (((int32_t)(i) & 0xc0000000) == 0x80000000) pollution: IN_CLASSB_HOST #define IN_CLASSB_HOST 0x0000ffff pollution: IN_CLASSB_MAX #define IN_CLASSB_MAX 65536 pollution: IN_CLASSB_NET #define IN_CLASSB_NET 0xffff0000 pollution: IN_CLASSB_NSHIFT #define IN_CLASSB_NSHIFT 16 pollution: IN_CLASSC #define IN_CLASSC(i) (((int32_t)(i) & 0xe0000000) == 0xc0000000) pollution: IN_CLASSC_HOST #define IN_CLASSC_HOST 0x000000ff pollution: IN_CLASSC_NET #define IN_CLASSC_NET 0xffffff00 pollution: IN_CLASSC_NSHIFT #define IN_CLASSC_NSHIFT 8 pollution: IN_CLASSD #define IN_CLASSD(i) (((int32_t)(i) & 0xf0000000) == 0xe0000000) pollution: IN_CLASSD_HOST #define IN_CLASSD_HOST 0x0fffffff pollution: IN_CLASSD_NET #define IN_CLASSD_NET 0xf0000000 pollution: IN_CLASSD_NSHIFT #define IN_CLASSD_NSHIFT 28 pollution: IN_EXPERIMENTAL #define IN_EXPERIMENTAL(i) (((int32_t)(i) & 0xe0000000) == 0xe0000000) pollution: IN_LOOPBACKNET #define IN_LOOPBACKNET 127 pollution: IN_MULTICAST #define IN_MULTICAST(i) IN_CLASSD(i) pollution: IN_USE #define IN_USE 0x0001 pollution: IOV_MAX #define IOV_MAX 16 pollution: IPNGVERSION #define IPNGVERSION 6 pollution: IPPORT_RESERVED #define IPPORT_RESERVED 1024 pollution: IPPORT_TIMESERVER #define IPPORT_TIMESERVER 37 pollution: IPPORT_USERRESERVED #define IPPORT_USERRESERVED 5000 pollution: IPPROTO_AH #define IPPROTO_AH 51 pollution: IPPROTO_BIP #define IPPROTO_BIP 0x53 pollution: IPPROTO_DSTOPTS #define IPPROTO_DSTOPTS 60 pollution: IPPROTO_EGP #define IPPROTO_EGP 8 pollution: IPPROTO_EON #define IPPROTO_EON 80 pollution: IPPROTO_ESP #define IPPROTO_ESP 50 pollution: IPPROTO_FRAGMENT #define IPPROTO_FRAGMENT 44 pollution: IPPROTO_GGP #define IPPROTO_GGP 3 pollution: IPPROTO_GIF #define IPPROTO_GIF 140 pollution: IPPROTO_GRE #define IPPROTO_GRE 47 pollution: IPPROTO_HOPOPTS #define IPPROTO_HOPOPTS 0 pollution: IPPROTO_ICMP #define IPPROTO_ICMP 1 pollution: IPPROTO_ICMPV6 #define IPPROTO_ICMPV6 58 pollution: IPPROTO_IDP #define IPPROTO_IDP 22 pollution: IPPROTO_IGMP #define IPPROTO_IGMP 2 pollution: IPPROTO_IP #define IPPROTO_IP 0 pollution: IPPROTO_IPIP #define IPPROTO_IPIP 4 pollution: IPPROTO_IPV6 #define IPPROTO_IPV6 41 pollution: IPPROTO_LOCAL #define IPPROTO_LOCAL 63 pollution: IPPROTO_MAX #define IPPROTO_MAX 256 pollution: IPPROTO_MH #define IPPROTO_MH 135 pollution: IPPROTO_NONE #define IPPROTO_NONE 59 pollution: IPPROTO_PUP #define IPPROTO_PUP 12 pollution: IPPROTO_QOS #define IPPROTO_QOS 45 pollution: IPPROTO_RAW #define IPPROTO_RAW 255 pollution: IPPROTO_ROUTING #define IPPROTO_ROUTING 43 pollution: IPPROTO_RSVP #define IPPROTO_RSVP 46 pollution: IPPROTO_SCTP #define IPPROTO_SCTP 132 pollution: IPPROTO_TCP #define IPPROTO_TCP 6 pollution: IPPROTO_TP #define IPPROTO_TP 29 pollution: IPPROTO_UDP #define IPPROTO_UDP 17 pollution: IPV6ADDR_ANY_INIT #define IPV6ADDR_ANY_INIT IN6ADDR_ANY_INIT pollution: IPV6ADDR_LOOPBACK_INIT #define IPV6ADDR_LOOPBACK_INIT IN6ADDR_LOOPBACK_INIT pollution: IPV6_ADDRFORM #define IPV6_ADDRFORM IP_ADDRFORM pollution: IPV6_ADDR_PREFERENCES #define IPV6_ADDR_PREFERENCES 74 pollution: IPV6_ADD_MEMBERSHIP #define IPV6_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP pollution: IPV6_AIXRAWSOCKET #define IPV6_AIXRAWSOCKET 57 pollution: IPV6_CHECKSUM #define IPV6_CHECKSUM 39 pollution: IPV6_DONTFRAG #define IPV6_DONTFRAG 45 pollution: IPV6_DROP_MEMBERSHIP #define IPV6_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP pollution: IPV6_DSTOPTS #define IPV6_DSTOPTS 54 pollution: IPV6_FLOWINFO_FLOWLABEL #define IPV6_FLOWINFO_FLOWLABEL 0x00ffffff pollution: IPV6_FLOWINFO_PRIFLOW #define IPV6_FLOWINFO_PRIFLOW 0x0fffffff pollution: IPV6_FLOWINFO_PRIORITY #define IPV6_FLOWINFO_PRIORITY 0x0f000000 pollution: IPV6_FLOWINFO_SRFLAG #define IPV6_FLOWINFO_SRFLAG 0x10000000 pollution: IPV6_FLOWINFO_VERSION #define IPV6_FLOWINFO_VERSION 0xf0000000 pollution: IPV6_GET_FLOWLABEL #define IPV6_GET_FLOWLABEL(x) (ntohl(x) & 0x00ffffff) pollution: IPV6_GET_PRIORITY #define IPV6_GET_PRIORITY(x) ((ntohl(x) >> 24) & 0xf) pollution: IPV6_GET_VERSION #define IPV6_GET_VERSION(x) ((*((u_char *)&(x)) >> 4) & 0xf) pollution: IPV6_HOPLIMIT #define IPV6_HOPLIMIT 40 pollution: IPV6_HOPOPTS #define IPV6_HOPOPTS 52 pollution: IPV6_JOIN_GROUP #define IPV6_JOIN_GROUP IP_ADD_MEMBERSHIP pollution: IPV6_LEAVE_GROUP #define IPV6_LEAVE_GROUP IP_DROP_MEMBERSHIP pollution: IPV6_MIPDSTOPTS #define IPV6_MIPDSTOPTS IPV6_DSTOPTS pollution: IPV6_MULTICAST_HOPS #define IPV6_MULTICAST_HOPS IP_MULTICAST_TTL pollution: IPV6_MULTICAST_IF #define IPV6_MULTICAST_IF IP_MULTICAST_IF pollution: IPV6_MULTICAST_LOOP #define IPV6_MULTICAST_LOOP IP_MULTICAST_LOOP pollution: IPV6_NEXTHOP #define IPV6_NEXTHOP 48 pollution: IPV6_NOPROBE #define IPV6_NOPROBE 28 pollution: IPV6_PATHMTU #define IPV6_PATHMTU 46 pollution: IPV6_PKTINFO #define IPV6_PKTINFO 33 pollution: IPV6_PKTOPTIONS #define IPV6_PKTOPTIONS 36 pollution: IPV6_PRIORITY_10 #define IPV6_PRIORITY_10 0x0a000000 pollution: IPV6_PRIORITY_11 #define IPV6_PRIORITY_11 0x0b000000 pollution: IPV6_PRIORITY_12 #define IPV6_PRIORITY_12 0x0c000000 pollution: IPV6_PRIORITY_13 #define IPV6_PRIORITY_13 0x0d000000 pollution: IPV6_PRIORITY_14 #define IPV6_PRIORITY_14 0x0e000000 pollution: IPV6_PRIORITY_15 #define IPV6_PRIORITY_15 0x0f000000 pollution: IPV6_PRIORITY_8 #define IPV6_PRIORITY_8 0x08000000 pollution: IPV6_PRIORITY_9 #define IPV6_PRIORITY_9 0x09000000 pollution: IPV6_PRIORITY_BULK #define IPV6_PRIORITY_BULK 0x04000000 pollution: IPV6_PRIORITY_CONTROL #define IPV6_PRIORITY_CONTROL 0x07000000 pollution: IPV6_PRIORITY_FILLER #define IPV6_PRIORITY_FILLER 0x01000000 pollution: IPV6_PRIORITY_INTERACTIVE #define IPV6_PRIORITY_INTERACTIVE 0x06000000 pollution: IPV6_PRIORITY_RESERVED1 #define IPV6_PRIORITY_RESERVED1 0x03000000 pollution: IPV6_PRIORITY_RESERVED2 #define IPV6_PRIORITY_RESERVED2 0x05000000 pollution: IPV6_PRIORITY_UNATTENDED #define IPV6_PRIORITY_UNATTENDED 0x02000000 pollution: IPV6_PRIORITY_UNCHARACTERIZED #define IPV6_PRIORITY_UNCHARACTERIZED 0x00000000 pollution: IPV6_RECVDSTOPTS #define IPV6_RECVDSTOPTS 56 pollution: IPV6_RECVHOPLIMIT #define IPV6_RECVHOPLIMIT 41 pollution: IPV6_RECVHOPOPTS #define IPV6_RECVHOPOPTS 53 pollution: IPV6_RECVHOPS #define IPV6_RECVHOPS IP_RECVTTL pollution: IPV6_RECVIF #define IPV6_RECVIF 30 pollution: IPV6_RECVPATHMTU #define IPV6_RECVPATHMTU 47 pollution: IPV6_RECVPKTINFO #define IPV6_RECVPKTINFO 35 pollution: IPV6_RECVRTHDR #define IPV6_RECVRTHDR 51 pollution: IPV6_RECVSRCRT #define IPV6_RECVSRCRT 29 pollution: IPV6_RECVTCLASS #define IPV6_RECVTCLASS 42 pollution: IPV6_RTHDR #define IPV6_RTHDR 50 pollution: IPV6_RTHDRDSTOPTS #define IPV6_RTHDRDSTOPTS 55 pollution: IPV6_RTHDR_TYPE_0 #define IPV6_RTHDR_TYPE_0 0 pollution: IPV6_RTHDR_TYPE_2 #define IPV6_RTHDR_TYPE_2 2 pollution: IPV6_SENDIF #define IPV6_SENDIF 31 pollution: IPV6_SET_FLOWLABEL #define IPV6_SET_FLOWLABEL(x) (htonl(x) & IPV6_FLOWINFO_FLOWLABEL) pollution: IPV6_SET_PRIORITY #define IPV6_SET_PRIORITY(x) (htonl((x & 0xf) << 24)) pollution: IPV6_SRFLAG_LOOSE #define IPV6_SRFLAG_LOOSE 0x00000000 pollution: IPV6_SRFLAG_STRICT #define IPV6_SRFLAG_STRICT 0x10000000 pollution: IPV6_TCLASS #define IPV6_TCLASS 43 pollution: IPV6_TOKEN_LENGTH #define IPV6_TOKEN_LENGTH 64 pollution: IPV6_UNICAST_HOPS #define IPV6_UNICAST_HOPS IP_TTL pollution: IPV6_USE_MIN_MTU #define IPV6_USE_MIN_MTU 44 pollution: IPV6_V6ONLY #define IPV6_V6ONLY 37 pollution: IPV6_VERSION #define IPV6_VERSION 0x60000000 pollution: IP_ADDRFORM #define IP_ADDRFORM 22 pollution: IP_ADD_MEMBERSHIP #define IP_ADD_MEMBERSHIP 12 pollution: IP_ADD_SOURCE_MEMBERSHIP #define IP_ADD_SOURCE_MEMBERSHIP 60 pollution: IP_BLOCK_SOURCE #define IP_BLOCK_SOURCE 58 pollution: IP_BROADCAST_IF #define IP_BROADCAST_IF 16 pollution: IP_CACHE_LINE_SIZE #define IP_CACHE_LINE_SIZE 128 pollution: IP_DEFAULT_MULTICAST_LOOP #define IP_DEFAULT_MULTICAST_LOOP 1 pollution: IP_DEFAULT_MULTICAST_TTL #define IP_DEFAULT_MULTICAST_TTL 1 pollution: IP_DHCPMODE #define IP_DHCPMODE 17 pollution: IP_DONTFRAG #define IP_DONTFRAG 25 pollution: IP_DROP_MEMBERSHIP #define IP_DROP_MEMBERSHIP 13 pollution: IP_DROP_SOURCE_MEMBERSHIP #define IP_DROP_SOURCE_MEMBERSHIP 61 pollution: IP_EXPAND_EPHEMERAL #define IP_EXPAND_EPHEMERAL 75 pollution: IP_FINDPMTU #define IP_FINDPMTU 26 pollution: IP_HDRINCL #define IP_HDRINCL 2 pollution: IP_INC_MEMBERSHIPS #define IP_INC_MEMBERSHIPS 20 pollution: IP_INIT_MEMBERSHIP #define IP_INIT_MEMBERSHIP 20 pollution: IP_LOCAL_PORT #define IP_LOCAL_PORT 76 pollution: IP_MULTICAST_HOPS #define IP_MULTICAST_HOPS IP_MULTICAST_TTL pollution: IP_MULTICAST_IF #define IP_MULTICAST_IF 9 pollution: IP_MULTICAST_LOOP #define IP_MULTICAST_LOOP 11 pollution: IP_MULTICAST_TTL #define IP_MULTICAST_TTL 10 pollution: IP_OPTIONS #define IP_OPTIONS 1 pollution: IP_PMTUAGE #define IP_PMTUAGE 27 pollution: IP_RECVDSTADDR #define IP_RECVDSTADDR 7 pollution: IP_RECVIF #define IP_RECVIF 20 pollution: IP_RECVIFINFO #define IP_RECVIFINFO 15 pollution: IP_RECVINTERFACE #define IP_RECVINTERFACE 32 pollution: IP_RECVMACHDR #define IP_RECVMACHDR 14 pollution: IP_RECVOPTS #define IP_RECVOPTS 5 pollution: IP_RECVRETOPTS #define IP_RECVRETOPTS 6 pollution: IP_RECVTTL #define IP_RECVTTL 34 pollution: IP_RETOPTS #define IP_RETOPTS 8 pollution: IP_SOURCE_FILTER #define IP_SOURCE_FILTER 72 pollution: IP_SOURCE_FILTER_SIZE #define IP_SOURCE_FILTER_SIZE(numsrc) (sizeof(struct ip_source_filter_req) + ((numsrc) - 1) * sizeof(struct in_addr)) pollution: IP_TOS #define IP_TOS 3 pollution: IP_TTL #define IP_TTL 4 pollution: IP_UNBLOCK_SOURCE #define IP_UNBLOCK_SOURCE 59 pollution: IP_UNICAST_HOPS #define IP_UNICAST_HOPS IP_TTL pollution: ISFR_IF_IADDR #define ISFR_IF_IADDR 2 pollution: ISFR_IF_INDEX #define ISFR_IF_INDEX 1 pollution: ISNO_ALL #define ISNO_ALL 0x7FFFFFFF pollution: ISNO_CWND_DF #define ISNO_CWND_DF 0x0002 pollution: ISNO_CWND_IF #define ISNO_CWND_IF 0x0001 pollution: ISNO_CWND_X #define ISNO_CWND_X 0x0008 pollution: ISNO_CWND_Y #define ISNO_CWND_Y 0x0010 pollution: ISNO_DISABLE #define ISNO_DISABLE 0x80000000 pollution: ISNO_NOTENTER_SSTART #define ISNO_NOTENTER_SSTART 0x0004 pollution: ISNO_OPT_IS_SET #define ISNO_OPT_IS_SET(flags,opt) (((flags & ISNO_ALL) & opt ) == opt) pollution: ISNO_RFC1323 #define ISNO_RFC1323 0x00000020 pollution: ISNO_SBRESERVE #define ISNO_SBRESERVE(sb,cc) { sb_max = MAX( cc, sb_max); sb.sb_hiwat = cc; sb.sb_mbmax = (cc * 2); if (MCLBYTES >= 2048) sb.sb_mbmax *= (MCLBYTES / 2048); if (sb.sb_lowat > sb.sb_hiwat) sb.sb_lowat = sb.sb_hiwat; } pollution: ISNO_TCP_CWND #define ISNO_TCP_CWND 0x00000080 pollution: ISNO_TCP_LOW_RTO #define ISNO_TCP_LOW_RTO 0x00000040 pollution: ISNO_TCP_MSSDFLT #define ISNO_TCP_MSSDFLT 0x00000008 pollution: ISNO_TCP_NODELAY #define ISNO_TCP_NODELAY 0x00000010 pollution: ISNO_TCP_RECVSPACE #define ISNO_TCP_RECVSPACE 0x00000002 pollution: ISNO_TCP_SENDSPACE #define ISNO_TCP_SENDSPACE 0x00000001 pollution: ISO88023_CSMACD #define ISO88023_CSMACD IFT_ISO88023 pollution: ISO88024_TOKBUS #define ISO88024_TOKBUS IFT_ISO88024 pollution: ISO88025_TOKRNG #define ISO88025_TOKRNG IFT_ISO88025 pollution: ISO88026_MAN #define ISO88026_MAN IFT_ISO88026 pollution: IS_ANYADDR6 #define IS_ANYADDR6(a) (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0) && ((a).s6_addr32[2] == 0) && ((a).s6_addr32[3] == 0)) pollution: IS_ANYSOCKADDR #define IS_ANYSOCKADDR(a) (((a)->sin6_addr.s6_addr32[0] == 0) && ((a)->sin6_addr.s6_addr32[1] == 0) && ((a)->sin6_addr.s6_addr32[2] == 0) && ((a)->sin6_addr.s6_addr32[3] == 0)) pollution: IS_COMPATADDR6 #define IS_COMPATADDR6(a) (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0) && ((a).s6_addr32[2] == 0) && ((a).s6_addr32[3] > 1)) pollution: IS_COMPATSOCKADDR #define IS_COMPATSOCKADDR(a) (((a)->sin6_addr.s6_addr32[0] == 0) && ((a)->sin6_addr.s6_addr32[1] == 0) && ((a)->sin6_addr.s6_addr32[2] == 0) && ((a)->sin6_addr.s6_addr8[12] != 0)) pollution: IS_DUP #define IS_DUP(rt) (((struct radix_node *)(rt))->rn_flags & RNF_DUP) pollution: IS_IPV4ADDR6 #define IS_IPV4ADDR6(a) (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0) && ((a).s6_addr32[2] == 0x0000ffff)) pollution: IS_IPV4LOOPADDR6 #define IS_IPV4LOOPADDR6(a) (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0) && ((a).s6_addr32[2] == 0x0000ffff) && ((a).s6_addr32[3] == 0x7f000001)) pollution: IS_IPV4SOCKADDR #define IS_IPV4SOCKADDR(a) (((a)->sin6_addr.s6_addr32[0] == 0) && ((a)->sin6_addr.s6_addr32[1] == 0) && ((a)->sin6_addr.s6_addr32[2] == 0x0000ffff) && ((a)->sin6_addr.s6_addr32[3] != 0)) pollution: IS_IPV4SOCK_ANYADDR #define IS_IPV4SOCK_ANYADDR(a) (((a)->sin6_addr.s6_addr32[0] == 0) && ((a)->sin6_addr.s6_addr32[1] == 0) && ((a)->sin6_addr.s6_addr32[2] == 0x0000ffff) && ((a)->sin6_addr.s6_addr32[3] == 0)) pollution: IS_LINKLADDR6 #define IS_LINKLADDR6(a) (IS_LOCALADDR6(a) && (((a).s6_addr8[1] & 0xC0) == 0x80)) pollution: IS_LOCALADDR6 #define IS_LOCALADDR6(a) ((a).s6_addr8[0] == 0xfe) pollution: IS_LOCKED #define IS_LOCKED(x) ((*(x) != LOCK_AVAIL) && ((tid_t)(*(x) & LOCKL_OWNER_MASK) == thread_self())) pollution: IS_LOOPADDR #define IS_LOOPADDR(a) ( (((struct sockaddr_in *)(a))->sin_family == AF_INET && ((struct sockaddr_in *)(a))->sin_addr.s_addr == INADDR_LOOPBACK) || (((struct sockaddr_in6 *)(a))->sin6_family == AF_INET6 && IS_LOOPADDR6(((struct sockaddr_in6 *)(a))->sin6_addr)) ) pollution: IS_LOOPADDR6 #define IS_LOOPADDR6(a) (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0) && ((a).s6_addr32[2] == 0) && ((a).s6_addr32[3] == 1)) pollution: IS_LOOPSOCKADDR #define IS_LOOPSOCKADDR(a) (((a)->sin6_addr.s6_addr32[0] == 0) && ((a)->sin6_addr.s6_addr32[1] == 0) && ((a)->sin6_addr.s6_addr32[2] == 0) && ((a)->sin6_addr.s6_addr32[3] == 1)) pollution: IS_MULTIADDR6 #define IS_MULTIADDR6(a) ((a).s6_addr8[0] == 0xff) pollution: IS_REMOTE #define IS_REMOTE(xp) (xp->aspace_id == XMEM_REMIO) pollution: IS_SITELADDR6 #define IS_SITELADDR6(a) (IS_LOCALADDR6(a) && ((a).s6_addr8[1] == 0xc0)) pollution: ITIMER_PROF #define ITIMER_PROF 2 pollution: ITIMER_REAL #define ITIMER_REAL 0 pollution: ITIMER_REAL1 #define ITIMER_REAL1 20 pollution: ITIMER_REAL_TH #define ITIMER_REAL_TH ITIMER_REAL1 pollution: ITIMER_VIRT #define ITIMER_VIRT 3 pollution: ITIMER_VIRTUAL #define ITIMER_VIRTUAL 1 pollution: KCSBIT_BLOCKFS #define KCSBIT_BLOCKFS 0x2000 pollution: KCSBIT_CHECKPOINT #define KCSBIT_CHECKPOINT 0x010 pollution: KCSBIT_FREEZE #define KCSBIT_FREEZE 0x040 pollution: KCSBIT_INPROGRESS #define KCSBIT_INPROGRESS 0x001 pollution: KCSBIT_KILL #define KCSBIT_KILL 0x800 pollution: KCSBIT_LOAD #define KCSBIT_LOAD 0x002 pollution: KCSBIT_MAINTENANCE #define KCSBIT_MAINTENANCE 0x4000 pollution: KCSBIT_MOVE #define KCSBIT_MOVE 0x1000 pollution: KCSBIT_PAUSE #define KCSBIT_PAUSE 0x080 pollution: KCSBIT_RESTART #define KCSBIT_RESTART 0x400 pollution: KCSBIT_RESTORE #define KCSBIT_RESTORE 0x200 pollution: KCSBIT_RESUME #define KCSBIT_RESUME 0x100 pollution: KCSBIT_SAVE #define KCSBIT_SAVE 0x020 pollution: KCSBIT_SERVICE #define KCSBIT_SERVICE 0x8000 pollution: KCSBIT_START #define KCSBIT_START 0x004 pollution: KCSBIT_STOP #define KCSBIT_STOP 0x008 pollution: KCS_ACTIVE #define KCS_ACTIVE (KCSBIT_START) pollution: KCS_ALL #define KCS_ALL 0xFFFF pollution: KCS_BLOCKFS #define KCS_BLOCKFS (KCSBIT_BLOCKFS) pollution: KCS_CHECKPOINTING #define KCS_CHECKPOINTING (KCSBIT_CHECKPOINT|KCSBIT_INPROGRESS) pollution: KCS_FREEZING #define KCS_FREEZING (KCSBIT_START|KCSBIT_FREEZE|KCSBIT_INPROGRESS) pollution: KCS_FROZEN #define KCS_FROZEN (KCSBIT_FREEZE) pollution: KCS_KILLING #define KCS_KILLING (KCSBIT_KILL|KCSBIT_INPROGRESS) pollution: KCS_MAINTENANCE #define KCS_MAINTENANCE (KCSBIT_MAINTENANCE) pollution: KCS_MOVING #define KCS_MOVING (KCSBIT_MOVE|KCSBIT_INPROGRESS) pollution: KCS_NONE #define KCS_NONE 0 pollution: KCS_PAUSED #define KCS_PAUSED (KCSBIT_PAUSE) pollution: KCS_REBOOTING #define KCS_REBOOTING (KCS_STARTING|KCS_STOPPING) pollution: KCS_RESTARTING #define KCS_RESTARTING (KCSBIT_RESTART|KCSBIT_INPROGRESS) pollution: KCS_RESTART_LOAD #define KCS_RESTART_LOAD (KCSBIT_RESTART|KCSBIT_LOAD) pollution: KCS_RESTORING #define KCS_RESTORING (KCSBIT_RESTORE|KCSBIT_INPROGRESS) pollution: KCS_RESUMING #define KCS_RESUMING (KCSBIT_RESUME|KCSBIT_INPROGRESS) pollution: KCS_SAVING #define KCS_SAVING (KCSBIT_SAVE|KCSBIT_INPROGRESS) pollution: KCS_SERVICE #define KCS_SERVICE (KCSBIT_SERVICE) pollution: KCS_STARTING #define KCS_STARTING (KCSBIT_START|KCSBIT_INPROGRESS) pollution: KCS_START_LOAD #define KCS_START_LOAD (KCSBIT_START|KCSBIT_LOAD) pollution: KCS_STOPPING #define KCS_STOPPING (KCSBIT_STOP|KCSBIT_INPROGRESS) pollution: KERROR #define KERROR(_errno,_blk,_subblk) (kerrno_t)_KERRNO((_errno), (_blk), (_subblk)) pollution: KERROR2ERRNO #define KERROR2ERRNO(_errcode) (((unsigned int)(_errcode) >= 128) ? (((unsigned int)(_errcode) & __ERRNO_MASK) >> __ERRNO_SHIFT) : (_errcode)) pollution: KMEMNAMSZ #define KMEMNAMSZ 12 pollution: KMEMSTATS #define KMEMSTATS #define KMEM_CACHE_LINE (128/sizeof(long)) pollution: KU_CPU_NONE #define KU_CPU_NONE (-1) pollution: KU_CPU_OFFLINE #define KU_CPU_OFFLINE (-2) pollution: KWNOVIP_GET #define KWNOVIP_GET 0x2 pollution: KWNOVIP_SET #define KWNOVIP_SET 0x1 pollution: K_GIDLIST #define K_GIDLIST 0x00010000 pollution: K_KCID #define K_KCID 0x00000100 pollution: LAPB #define LAPB IFT_LAPB pollution: LARGEBUCKETCPU #define LARGEBUCKETCPU (-3) pollution: LARGEBUCKETS #define LARGEBUCKETS (BUCKETSPERCPU+10) pollution: LDBL_DECIMAL_DIG #define LDBL_DECIMAL_DIG __LDBL_DECIMAL_DIG__ pollution: LDBL_DIG #define LDBL_DIG __LDBL_DIG__ pollution: LDBL_EPSILON #define LDBL_EPSILON __LDBL_EPSILON__ pollution: LDBL_HAS_SUBNORM #define LDBL_HAS_SUBNORM __LDBL_HAS_DENORM__ pollution: LDBL_INFINITY #define LDBL_INFINITY DBL_INFINITY pollution: LDBL_MANT_DIG #define LDBL_MANT_DIG __LDBL_MANT_DIG__ pollution: LDBL_MAX #define LDBL_MAX __LDBL_MAX__ pollution: LDBL_MAX_10_EXP #define LDBL_MAX_10_EXP __LDBL_MAX_10_EXP__ pollution: LDBL_MAX_EXP #define LDBL_MAX_EXP __LDBL_MAX_EXP__ pollution: LDBL_MIN #define LDBL_MIN __LDBL_MIN__ pollution: LDBL_MIN_10_EXP #define LDBL_MIN_10_EXP __LDBL_MIN_10_EXP__ pollution: LDBL_MIN_EXP #define LDBL_MIN_EXP __LDBL_MIN_EXP__ pollution: LDBL_TRUE_MIN #define LDBL_TRUE_MIN __LDBL_DENORM_MIN__ pollution: LINE_MAX #define LINE_MAX _POSIX2_LINE_MAX pollution: LINK_MAX #define LINK_MAX SHRT_MAX pollution: LIST_ENTRY #define LIST_ENTRY(type) struct { struct type *le_next; struct type **le_prev; } pollution: LIST_HEAD #define LIST_HEAD(name,type) struct name { struct type *lh_first; } pollution: LIST_INIT #define LIST_INIT(head) { (head)->lh_first = NULL; } pollution: LIST_INSERT_AFTER #define LIST_INSERT_AFTER(listelm,elm,field) { if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) (listelm)->field.le_next->field.le_prev = &(elm)->field.le_next; (listelm)->field.le_next = (elm); (elm)->field.le_prev = &(listelm)->field.le_next; } pollution: LIST_INSERT_HEAD #define LIST_INSERT_HEAD(head,elm,field) { if (((elm)->field.le_next = (head)->lh_first) != NULL) (head)->lh_first->field.le_prev = &(elm)->field.le_next; (head)->lh_first = (elm); (elm)->field.le_prev = &(head)->lh_first; } pollution: LIST_REMOVE #define LIST_REMOVE(elm,field) { if ((elm)->field.le_next != NULL) (elm)->field.le_next->field.le_prev = (elm)->field.le_prev; *(elm)->field.le_prev = (elm)->field.le_next; } pollution: LITTLE_ENDIAN #define LITTLE_ENDIAN 1234 pollution: LKPUB #define LKPUB 2 pollution: LLONG_MAX #define LLONG_MAX (9223372036854775807LL) pollution: LLONG_MIN #define LLONG_MIN (-9223372036854775807LL -1LL) pollution: LOCKL_OWNER_MASK #define LOCKL_OWNER_MASK 0x3fffffff pollution: LOCK_ALLOCATED #define LOCK_ALLOCATED 2 pollution: LOCK_AVAIL #define LOCK_AVAIL ((lock_t) -1) pollution: LOCK_FAIL #define LOCK_FAIL (-1) pollution: LOCK_NDELAY #define LOCK_NDELAY (1) pollution: LOCK_NEST #define LOCK_NEST (1) pollution: LOCK_SHORT #define LOCK_SHORT (0) pollution: LOCK_SIG #define LOCK_SIG (-2) pollution: LOCK_SIGRET #define LOCK_SIGRET (4) pollution: LOCK_SIGWAKE #define LOCK_SIGWAKE (2) pollution: LOCK_SUCC #define LOCK_SUCC (0) pollution: LOGIN_NAME_MAX #define LOGIN_NAME_MAX 9 pollution: LONGLONG_MAX #define LONGLONG_MAX (0x7fffffffffffffffLL) pollution: LONGLONG_MIN #define LONGLONG_MIN (-LONGLONG_MAX - 1) pollution: LONG_BIT #define LONG_BIT 32 pollution: LONG_MAX #define LONG_MAX (2147483647L) pollution: LONG_MIN #define LONG_MIN (-LONG_MAX - 1) pollution: LOOK #define LOOK 1 pollution: LW_XMATTACH #define LW_XMATTACH 4 pollution: MACHINE_ALIGNMENT #define MACHINE_ALIGNMENT sizeof (void *) pollution: MADDR6_ALLHOSTS #define MADDR6_ALLHOSTS 3 pollution: MADDR6_ALLNODES #define MADDR6_ALLNODES 1 pollution: MADDR6_ALLROUTERS #define MADDR6_ALLROUTERS 2 pollution: MADDR6_FLAGS #define MADDR6_FLAGS(a) ((a).s6_addr8[1] >> 4) pollution: MADDR6_FLG_TS #define MADDR6_FLG_TS 1 pollution: MADDR6_FLG_WK #define MADDR6_FLG_WK 0 pollution: MADDR6_SCOPE #define MADDR6_SCOPE(a) ((a).s6_addr8[1] & 0x0f) pollution: MADDR6_SCOPE_MAX #define MADDR6_SCOPE_MAX MADDR6_SCP_GLO pollution: MADDR6_SCOPE_MIN #define MADDR6_SCOPE_MIN 0 pollution: MADDR6_SCP_3 #define MADDR6_SCP_3 ADDR6_SCP_3 pollution: MADDR6_SCP_6 #define MADDR6_SCP_6 ADDR6_SCP_6 pollution: MADDR6_SCP_7 #define MADDR6_SCP_7 ADDR6_SCP_7 pollution: MADDR6_SCP_9 #define MADDR6_SCP_9 ADDR6_SCP_9 pollution: MADDR6_SCP_A #define MADDR6_SCP_A ADDR6_SCP_A pollution: MADDR6_SCP_ADMIN #define MADDR6_SCP_ADMIN ADDR6_SCP_ADMIN pollution: MADDR6_SCP_B #define MADDR6_SCP_B ADDR6_SCP_B pollution: MADDR6_SCP_C #define MADDR6_SCP_C ADDR6_SCP_C pollution: MADDR6_SCP_D #define MADDR6_SCP_D ADDR6_SCP_D pollution: MADDR6_SCP_GLO #define MADDR6_SCP_GLO ADDR6_SCP_GLOBAL pollution: MADDR6_SCP_INTF #define MADDR6_SCP_INTF ADDR6_SCP_INTF pollution: MADDR6_SCP_LINK #define MADDR6_SCP_LINK ADDR6_SCP_LINK pollution: MADDR6_SCP_NODE #define MADDR6_SCP_NODE ADDR6_SCP_NODE pollution: MADDR6_SCP_ORG #define MADDR6_SCP_ORG ADDR6_SCP_ORG pollution: MADDR6_SCP_SITE #define MADDR6_SCP_SITE ADDR6_SCP_SITE pollution: MAXBUCKET #define MAXBUCKET (MINBUCKET+11) pollution: MAXCORRALNAMELEN #define MAXCORRALNAMELEN 25 pollution: MAXFIDSZ #define MAXFIDSZ 20 pollution: MAXLARGEBUCKET #define MAXLARGEBUCKET (MAXBUCKET+10) pollution: MAXWPARNAMELEN #define MAXWPARNAMELEN MAXCORRALNAMELEN pollution: MAX_ARP_RETRIES_PER_MINUTE #define MAX_ARP_RETRIES_PER_MINUTE 60 pollution: MAX_CANON #define MAX_CANON 256 pollution: MAX_DEC_NS #define MAX_DEC_NS 147483647 pollution: MAX_DEC_SECS #define MAX_DEC_SECS 2 pollution: MAX_DF #define MAX_DF 100 pollution: MAX_DUPLIST #define MAX_DUPLIST 256 pollution: MAX_HWADDR #define MAX_HWADDR 20 pollution: MAX_HWADDR_LEN #define MAX_HWADDR_LEN 64 pollution: MAX_IF #define MAX_IF 100 pollution: MAX_INPUT #define MAX_INPUT 512 pollution: MAX_NASTIES #define MAX_NASTIES 69 pollution: MAX_NS_TO_uS #define MAX_NS_TO_uS 294967296 pollution: MAX_PACKET_Q_SIZE #define MAX_PACKET_Q_SIZE 7 pollution: MAX_RT_COST #define MAX_RT_COST INT_MAX pollution: MAX_SECS_TO_uS #define MAX_SECS_TO_uS 4000 pollution: MAX_TCE_MAP_SIZE #define MAX_TCE_MAP_SIZE 0x100000000ULL pollution: MB_LEN_MAX #define MB_LEN_MAX 4 pollution: MCAST_BLOCK_SOURCE #define MCAST_BLOCK_SOURCE 64 pollution: MCAST_EXCLUDE #define MCAST_EXCLUDE 2 pollution: MCAST_INCLUDE #define MCAST_INCLUDE 1 pollution: MCAST_JOIN_GROUP #define MCAST_JOIN_GROUP 62 pollution: MCAST_JOIN_SOURCE_GROUP #define MCAST_JOIN_SOURCE_GROUP 66 pollution: MCAST_LEAVE_GROUP #define MCAST_LEAVE_GROUP 63 pollution: MCAST_LEAVE_SOURCE_GROUP #define MCAST_LEAVE_SOURCE_GROUP 67 pollution: MCAST_SOURCE_FILTER #define MCAST_SOURCE_FILTER 73 pollution: MCAST_UNBLOCK_SOURCE #define MCAST_UNBLOCK_SOURCE 65 pollution: MFC_PACKET_Q_SIZE #define MFC_PACKET_Q_SIZE 5 pollution: MINBUCKET #define MINBUCKET 6 pollution: MIN_SECS_SINCE_EPOCH #define MIN_SECS_SINCE_EPOCH 0 pollution: MKFree #define MKFree(m) { (m)->rm_mklist = rn_mkfreelist; rn_mkfreelist = (m);} pollution: MKGet #define MKGet(m) { if (rn_mkfreelist) { m = rn_mkfreelist; rn_mkfreelist = (m)->rm_mklist; } else R_Malloc(m, struct radix_mask *, sizeof (*(m))); } pollution: MOB_CHECKPOINT_END #define MOB_CHECKPOINT_END 4 pollution: MOB_CHECKPOINT_FAILED #define MOB_CHECKPOINT_FAILED 5 pollution: MOB_CHECKPOINT_START #define MOB_CHECKPOINT_START 3 pollution: MOB_RESTART_END #define MOB_RESTART_END 7 pollution: MOB_RESTART_FAILED #define MOB_RESTART_FAILED 8 pollution: MOB_RESTART_START #define MOB_RESTART_START 6 pollution: MPR_DEFAULT #define MPR_DEFAULT 0 pollution: MPR_HASHED #define MPR_HASHED 5 pollution: MPR_LIMIT #define MPR_LIMIT 6 pollution: MPR_LOW_UTIL #define MPR_LOW_UTIL 4 pollution: MPR_PREFERENCE #define MPR_PREFERENCE 6 pollution: MPR_RANDOM #define MPR_RANDOM 2 pollution: MPR_WEIGHTED_RANDOM #define MPR_WEIGHTED_RANDOM 3 pollution: MPR_WEIGHTED_RR #define MPR_WEIGHTED_RR 1 pollution: MQ_OPEN_MAX #define MQ_OPEN_MAX 32768 pollution: MQ_PRIO_MAX #define MQ_PRIO_MAX 128 pollution: MSG_ARGEXT #define MSG_ARGEXT 0x400 pollution: MSG_COMPAT #define MSG_COMPAT 0x8000 pollution: MSG_CTRUNC #define MSG_CTRUNC 0x20 pollution: MSG_DONTROUTE #define MSG_DONTROUTE 0x4 pollution: MSG_EOR #define MSG_EOR 0x8 pollution: MSG_MAXIOVLEN #define MSG_MAXIOVLEN 16 pollution: MSG_MPEG2 #define MSG_MPEG2 0x80 pollution: MSG_NONBLOCK #define MSG_NONBLOCK 0x4000 pollution: MSG_NOSIGNAL #define MSG_NOSIGNAL 0x100 pollution: MSG_OOB #define MSG_OOB 0x1 pollution: MSG_PEEK #define MSG_PEEK 0x2 pollution: MSG_TRUNC #define MSG_TRUNC 0x10 pollution: MSG_WAITALL #define MSG_WAITALL 0x40 pollution: MSG_WAITFORONE #define MSG_WAITFORONE 0x200 pollution: MSR_AL #define MSR_AL 0x0000 pollution: MSR_BE #define MSR_BE 0x0200 pollution: MSR_DR #define MSR_DR 0x0010 pollution: MSR_EE #define MSR_EE 0x8000 pollution: MSR_FE #define MSR_FE MSR_FE0 pollution: MSR_FE0 #define MSR_FE0 0x0800 pollution: MSR_FE1 #define MSR_FE1 0x0100 pollution: MSR_FP #define MSR_FP 0x2000 pollution: MSR_HYPERVISOR #define MSR_HYPERVISOR 0x1000000000000000LL pollution: MSR_IE #define MSR_IE MSR_FE1 pollution: MSR_IP #define MSR_IP 0x0000 pollution: MSR_IR #define MSR_IR 0x0020 pollution: MSR_ME #define MSR_ME 0x1000 pollution: MSR_PM #define MSR_PM 0x0004 pollution: MSR_PR #define MSR_PR 0x4000 pollution: MSR_RI #define MSR_RI 0x0002 pollution: MSR_RSVD #define MSR_RSVD 0x0000 pollution: MSR_SE #define MSR_SE 0x0400 pollution: MSR_SF_H #define MSR_SF_H 0x80000000 pollution: MSR_TM #define MSR_TM 0x100000000 pollution: MSR_TS #define MSR_TS 0x600000000 pollution: MSR_TS_SUSP #define MSR_TS_SUSP 0x200000000 pollution: MSR_TS_TRANS #define MSR_TS_TRANS 0x400000000 pollution: MSR_VMX #define MSR_VMX 0x2000000 pollution: MSR_VSX #define MSR_VSX 0x800000 pollution: MS_PER_SEC #define MS_PER_SEC 1000 pollution: M_ACF_B #define M_ACF_B 54 pollution: M_ACF_D #define M_ACF_D 53 pollution: M_BYSRAD #define M_BYSRAD 0x0008 pollution: M_CLUSTER #define M_CLUSTER 2 pollution: M_DEVBUF #define M_DEVBUF 29 pollution: M_DEVSW #define M_DEVSW 42 pollution: M_FHANDLE #define M_FHANDLE 22 pollution: M_FILE #define M_FILE 25 pollution: M_FILEDESC #define M_FILEDESC 26 pollution: M_FREE #define M_FREE 0 pollution: M_FTABLE #define M_FTABLE 6 pollution: M_IFADDR #define M_IFADDR 7 pollution: M_IFMADDR #define M_IFMADDR 52 pollution: M_IOCTLOPS #define M_IOCTLOPS 27 pollution: M_IOV #define M_IOV 21 pollution: M_IPMADDR #define M_IPMADDR 51 pollution: M_IPMOPTS #define M_IPMOPTS 50 pollution: M_IPSEC #define M_IPSEC 43 pollution: M_KALLOC #define M_KALLOC 48 pollution: M_KTABLE #define M_KTABLE 31 pollution: M_LAST #define M_LAST 58 pollution: M_LOCKF #define M_LOCKF 41 pollution: M_MBDATA #define M_MBDATA 11 pollution: M_MBLK #define M_MBLK 10 pollution: M_MBUF #define M_MBUF 1 pollution: M_MCL_ENTRY #define M_MCL_ENTRY 56 pollution: M_MCL_GROUP #define M_MCL_GROUP 55 pollution: M_MOUNT #define M_MOUNT 32 pollution: M_NETCRED #define M_NETCRED 44 pollution: M_NETTBL #define M_NETTBL 45 pollution: M_NFSMNT #define M_NFSMNT 24 pollution: M_NFSREQ #define M_NFSREQ 23 pollution: M_NO4KPAGES #define M_NO4KPAGES 0x0004 pollution: M_NOWAIT #define M_NOWAIT 0x0001 pollution: M_PATHNAME #define M_PATHNAME 30 pollution: M_PCB #define M_PCB 4 pollution: M_RAS_ART #define M_RAS_ART 57 pollution: M_RTABLE #define M_RTABLE 5 pollution: M_S5MNT #define M_S5MNT 35 pollution: M_S5SUPERBLK #define M_S5SUPERBLK 36 pollution: M_SELPOLL #define M_SELPOLL 28 pollution: M_SOCKET #define M_SOCKET 3 pollution: M_SONAME #define M_SONAME 9 pollution: M_SOOPTS #define M_SOOPTS 8 pollution: M_SPECALIAS #define M_SPECALIAS 39 pollution: M_SPECBUF #define M_SPECBUF 40 pollution: M_SPECINFO #define M_SPECINFO 38 pollution: M_STREAMS #define M_STREAMS 20 pollution: M_STRHEAD #define M_STRHEAD 12 pollution: M_STRMODSW #define M_STRMODSW 15 pollution: M_STROSR #define M_STROSR 18 pollution: M_STRPOLLS #define M_STRPOLLS 17 pollution: M_STRQBAND #define M_STRQBAND 14 pollution: M_STRQUEUE #define M_STRQUEUE 13 pollution: M_STRSIGS #define M_STRSIGS 16 pollution: M_STRSQ #define M_STRSQ 19 pollution: M_SUPERBLK #define M_SUPERBLK 33 pollution: M_TEMP #define M_TEMP 49 pollution: M_UFSMNT #define M_UFSMNT 34 pollution: M_VSRAD #define M_VSRAD 37 pollution: M_WAITMIN #define M_WAITMIN 0x0002 pollution: M_WAITOK #define M_WAITOK 0x0000 pollution: NALRM #define NALRM 1 pollution: NALRM_THREAD #define NALRM_THREAD 1 pollution: NBBY #define NBBY 8 pollution: NETMAXCPU #define NETMAXCPU (64) pollution: NETMAXCPU_V1 #define NETMAXCPU_V1 (1024) pollution: NETMAXSRADS #define NETMAXSRADS 16 pollution: NETSTAT_LOCK_IF #define NETSTAT_LOCK_IF(ifp) pollution: NETSTAT_LOCK_IF_DECL #define NETSTAT_LOCK_IF_DECL() pollution: NETSTAT_LOCK_IF_EXCL #define NETSTAT_LOCK_IF_EXCL(ifp) pollution: NETSTAT_LOCK_IF_INIT #define NETSTAT_LOCK_IF_INIT(ifp) pollution: NETSTAT_UNLOCK_IF #define NETSTAT_UNLOCK_IF(ifp) pollution: NETSTAT_UNLOCK_IF_EXCL #define NETSTAT_UNLOCK_IF_EXCL(ifp) pollution: NGROUPS_MAX #define NGROUPS_MAX 2048 pollution: NGROUPS_MIN #define NGROUPS_MIN 128 pollution: NL_ARGMAX #define NL_ARGMAX 9 pollution: NL_LANGMAX #define NL_LANGMAX 14 pollution: NL_MSGMAX #define NL_MSGMAX 65535 pollution: NL_SETMAX #define NL_SETMAX 65535 pollution: NL_TEXTMAX #define NL_TEXTMAX 16384 pollution: NMD_FRAG #define NMD_FRAG 0x00000001 pollution: NMD_GUARDPAGE #define NMD_GUARDPAGE 0x00000002 pollution: NMD_HIDDEN #define NMD_HIDDEN 0x00000004 pollution: NMD_HIDE #define NMD_HIDE 0x00000008 pollution: NMD_PAGE_16G #define NMD_PAGE_16G 0x00000080 pollution: NMD_PAGE_16M #define NMD_PAGE_16M 0x00000040 pollution: NMD_PAGE_4K #define NMD_PAGE_4K 0x00000010 pollution: NMD_PAGE_64K #define NMD_PAGE_64K 0x00000020 pollution: NMD_UNUSED #define NMD_UNUSED 0x00000100 pollution: NPROF #define NPROF 1 pollution: NS_PER_MSEC #define NS_PER_MSEC (NS_PER_SEC / 1000) pollution: NS_PER_SEC #define NS_PER_SEC 1000000000 pollution: NS_PER_TICK #define NS_PER_TICK (NS_PER_SEC/HZ) pollution: NS_PER_uS #define NS_PER_uS (1000) pollution: NTIMEOFDAY #define NTIMEOFDAY 5 pollution: NTIMERS #define NTIMERS (NALRM + NPROF + NVIRTUAL + NTIMEOFDAY) pollution: NTIMERS_THREAD #define NTIMERS_THREAD (NALRM_THREAD) pollution: NTOHL #define NTOHL(x) pollution: NTOHLL #define NTOHLL(x) pollution: NTOHS #define NTOHS(x) pollution: NUCAST_TYPE #define NUCAST_TYPE 2 pollution: NULL #define NULL 0 pollution: NVIRTUAL #define NVIRTUAL 2 pollution: NZERO #define NZERO 20 pollution: OFF_MAX #define OFF_MAX 0x7fffffff pollution: OPEN_MAX #define OPEN_MAX 65534 pollution: OSTDIDX #define OSTDIDX(addr,ostd_array_size) ((u_long)(addr) % ostd_array_size) pollution: OSTD_ALLOW_EXP #define OSTD_ALLOW_EXP 0 pollution: OSTD_ARRAY #define OSTD_ARRAY 11 pollution: OSTD_DOING_EXP #define OSTD_DOING_EXP 2 pollution: OSTD_NEED_EXP #define OSTD_NEED_EXP 1 pollution: OTHER_TYPE #define OTHER_TYPE IFT_OTHER pollution: PAGESIZE #define PAGESIZE PAGE_SIZE pollution: PAGE_SIZE #define PAGE_SIZE 4096 pollution: PASS_MAX #define PASS_MAX 255 pollution: PATH_MAX #define PATH_MAX 1023 pollution: PDP_ENDIAN #define PDP_ENDIAN 3412 pollution: PF_APPLETALK #define PF_APPLETALK AF_APPLETALK pollution: PF_CCITT #define PF_CCITT AF_CCITT pollution: PF_CHAOS #define PF_CHAOS AF_CHAOS pollution: PF_DATAKIT #define PF_DATAKIT AF_DATAKIT pollution: PF_DECnet #define PF_DECnet AF_DECnet pollution: PF_DLI #define PF_DLI AF_DLI pollution: PF_ECMA #define PF_ECMA AF_ECMA pollution: PF_HYLINK #define PF_HYLINK AF_HYLINK pollution: PF_IMPLINK #define PF_IMPLINK AF_IMPLINK pollution: PF_INET #define PF_INET AF_INET pollution: PF_INET6 #define PF_INET6 AF_INET6 pollution: PF_INTF #define PF_INTF AF_INTF pollution: PF_ISO #define PF_ISO AF_ISO pollution: PF_LAT #define PF_LAT AF_LAT pollution: PF_LINK #define PF_LINK AF_LINK pollution: PF_MAX #define PF_MAX AF_MAX pollution: PF_NDD #define PF_NDD AF_NDD pollution: PF_NS #define PF_NS AF_NS pollution: PF_OSI #define PF_OSI AF_ISO pollution: PF_PUP #define PF_PUP AF_PUP pollution: PF_RIF #define PF_RIF AF_RIF pollution: PF_ROUTE #define PF_ROUTE AF_ROUTE pollution: PF_SNA #define PF_SNA AF_SNA pollution: PF_UNIX #define PF_UNIX AF_UNIX pollution: PF_UNSPEC #define PF_UNSPEC AF_UNSPEC pollution: PF_XTP #define PF_XTP pseudo_AF_XTP pollution: PID_MAX #define PID_MAX INT_MAX pollution: PIPE_BUF #define PIPE_BUF 32768 pollution: PMTU_ISR_TCP_UPDATE #define PMTU_ISR_TCP_UPDATE 1 pollution: PMTU_ISR_TIMEOUT #define PMTU_ISR_TIMEOUT 0 pollution: PMTU_ISR_UDP_UPDATE #define PMTU_ISR_UDP_UPDATE 2 pollution: PMTU_RT_DEL #define PMTU_RT_DEL 0x01 pollution: PMTU_USR_DEL #define PMTU_USR_DEL 0x02 pollution: POLICE_CALLERS #define POLICE_CALLERS 16 pollution: PRIMARYISDN #define PRIMARYISDN IFT_ISDNPRIMARY pollution: PRIX16 #define PRIX16 "hX" pollution: PRIX32 #define PRIX32 "X" pollution: PRIX64 #define PRIX64 "llX" pollution: PRIX8 #define PRIX8 "hhX" pollution: PRIXFAST16 #define PRIXFAST16 "hX" pollution: PRIXFAST32 #define PRIXFAST32 "X" pollution: PRIXFAST64 #define PRIXFAST64 "llX" pollution: PRIXFAST8 #define PRIXFAST8 "hhX" pollution: PRIXLEAST16 #define PRIXLEAST16 "hX" pollution: PRIXLEAST32 #define PRIXLEAST32 "X" pollution: PRIXLEAST64 #define PRIXLEAST64 "llX" pollution: PRIXLEAST8 #define PRIXLEAST8 "hhX" pollution: PRIXMAX #define PRIXMAX "llX" pollution: PRIXPTR #define PRIXPTR "lX" pollution: PRId16 #define PRId16 "hd" pollution: PRId32 #define PRId32 "d" pollution: PRId64 #define PRId64 "lld" pollution: PRId8 #define PRId8 "hhd" pollution: PRIdFAST #define PRIdFAST "d" pollution: PRIdFAST16 #define PRIdFAST16 "hd" pollution: PRIdFAST32 #define PRIdFAST32 "d" pollution: PRIdFAST64 #define PRIdFAST64 "lld" pollution: PRIdFAST8 #define PRIdFAST8 "hhd" pollution: PRIdLEAST16 #define PRIdLEAST16 "hd" pollution: PRIdLEAST32 #define PRIdLEAST32 "d" pollution: PRIdLEAST64 #define PRIdLEAST64 "lld" pollution: PRIdLEAST8 #define PRIdLEAST8 "hhd" pollution: PRIdMAX #define PRIdMAX "lld" pollution: PRIdPTR #define PRIdPTR "ld" pollution: PRIi16 #define PRIi16 "hi" pollution: PRIi32 #define PRIi32 "i" pollution: PRIi64 #define PRIi64 "lli" pollution: PRIi8 #define PRIi8 "hhi" pollution: PRIiFAST16 #define PRIiFAST16 "hi" pollution: PRIiFAST32 #define PRIiFAST32 "i" pollution: PRIiFAST64 #define PRIiFAST64 "lli" pollution: PRIiFAST8 #define PRIiFAST8 "hhi" pollution: PRIiLEAST16 #define PRIiLEAST16 "hi" pollution: PRIiLEAST32 #define PRIiLEAST32 "i" pollution: PRIiLEAST64 #define PRIiLEAST64 "lli" pollution: PRIiLEAST8 #define PRIiLEAST8 "hhi" pollution: PRIiMAX #define PRIiMAX "lld" pollution: PRIiPTR #define PRIiPTR "ld" pollution: PRIo16 #define PRIo16 "ho" pollution: PRIo32 #define PRIo32 "o" pollution: PRIo64 #define PRIo64 "llo" pollution: PRIo8 #define PRIo8 "hho" pollution: PRIoFAST #define PRIoFAST "o" pollution: PRIoFAST16 #define PRIoFAST16 "ho" pollution: PRIoFAST32 #define PRIoFAST32 "o" pollution: PRIoFAST64 #define PRIoFAST64 "llo" pollution: PRIoFAST8 #define PRIoFAST8 "hho" pollution: PRIoLEAST16 #define PRIoLEAST16 "ho" pollution: PRIoLEAST32 #define PRIoLEAST32 "o" pollution: PRIoLEAST64 #define PRIoLEAST64 "llo" pollution: PRIoLEAST8 #define PRIoLEAST8 "ho" pollution: PRIoMAX #define PRIoMAX "llo" pollution: PRIoPTR #define PRIoPTR "lo" pollution: PRIu16 #define PRIu16 "hu" pollution: PRIu32 #define PRIu32 "u" pollution: PRIu64 #define PRIu64 "llu" pollution: PRIu8 #define PRIu8 "hhu" pollution: PRIuFAST #define PRIuFAST "u" pollution: PRIuFAST16 #define PRIuFAST16 "hu" pollution: PRIuFAST32 #define PRIuFAST32 "u" pollution: PRIuFAST64 #define PRIuFAST64 "llu" pollution: PRIuFAST8 #define PRIuFAST8 "hhu" pollution: PRIuLEAST16 #define PRIuLEAST16 "hu" pollution: PRIuLEAST32 #define PRIuLEAST32 "u" pollution: PRIuLEAST64 #define PRIuLEAST64 "llu" pollution: PRIuLEAST8 #define PRIuLEAST8 "hhu" pollution: PRIuMAX #define PRIuMAX "llu" pollution: PRIuPTR #define PRIuPTR "lu" pollution: PRIx16 #define PRIx16 "hx" pollution: PRIx32 #define PRIx32 "x" pollution: PRIx64 #define PRIx64 "llx" pollution: PRIx8 #define PRIx8 "hhx" pollution: PRIxFAST #define PRIxFAST "x" pollution: PRIxFAST16 #define PRIxFAST16 "hx" pollution: PRIxFAST32 #define PRIxFAST32 "x" pollution: PRIxFAST64 #define PRIxFAST64 "llx" pollution: PRIxFAST8 #define PRIxFAST8 "hhx" pollution: PRIxLEAST16 #define PRIxLEAST16 "hx" pollution: PRIxLEAST32 #define PRIxLEAST32 "x" pollution: PRIxLEAST64 #define PRIxLEAST64 "llx" pollution: PRIxLEAST8 #define PRIxLEAST8 "hhx" pollution: PRIxMAX #define PRIxMAX "llx" pollution: PRIxPTR #define PRIxPTR "lx" pollution: PROCESSOR_CLASS_ANY #define PROCESSOR_CLASS_ANY ((cpu_t)(-1)) pollution: PROPPTPSERIAL #define PROPPTPSERIAL IFT_PTPSERIAL pollution: PROTEON_10MBIT #define PROTEON_10MBIT IFT_P10 pollution: PROTEON_80MBIT #define PROTEON_80MBIT IFT_P80 pollution: PTHREAD_DATAKEYS_MAX #define PTHREAD_DATAKEYS_MAX PTHREAD_KEYS_MAX pollution: PTHREAD_DESTRUCTOR_ITERATIONS #define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS pollution: PTHREAD_KEYS_MAX #define PTHREAD_KEYS_MAX 450 pollution: PTHREAD_STACK_MIN #define PTHREAD_STACK_MIN ( PAGESIZE * 2 ) pollution: PTHREAD_THREADS_MAX #define PTHREAD_THREADS_MAX 512 pollution: PTRDIFF_MAX #define PTRDIFF_MAX (2147483647L) pollution: PTRDIFF_MIN #define PTRDIFF_MIN (-2147483647L-1) pollution: REGULAR1822 #define REGULAR1822 IFT_1822 pollution: REVARP #define REVARP 4 pollution: RE_DUP_MAX #define RE_DUP_MAX _POSIX2_RE_DUP_MAX pollution: RFC877_X25 #define RFC877_X25 IFT_X25 pollution: RNF_ACTIVE #define RNF_ACTIVE 4 pollution: RNF_DUP #define RNF_DUP 8 pollution: RNF_NORMAL #define RNF_NORMAL 1 pollution: RNF_ROOT #define RNF_ROOT 2 pollution: RN_EXACT #define RN_EXACT 0x00000001 pollution: RN_FIRST #define RN_FIRST 0x00000002 pollution: RN_NOMULTIPATH #define RN_NOMULTIPATH 0x00000004 pollution: ROUTE_H #define ROUTE_H #define RTAX_AUTHOR 6 pollution: RTAX_BRD #define RTAX_BRD 7 pollution: RTAX_DST #define RTAX_DST 0 pollution: RTAX_GATEWAY #define RTAX_GATEWAY 1 pollution: RTAX_GENMASK #define RTAX_GENMASK 3 pollution: RTAX_IFA #define RTAX_IFA 5 pollution: RTAX_IFP #define RTAX_IFP 4 pollution: RTAX_MAX #define RTAX_MAX 8 pollution: RTAX_NETMASK #define RTAX_NETMASK 2 pollution: RTA_AUTHOR #define RTA_AUTHOR 0x40 pollution: RTA_BRD #define RTA_BRD 0x80 pollution: RTA_DOWNSTREAM #define RTA_DOWNSTREAM 0x100 pollution: RTA_DST #define RTA_DST 0x1 pollution: RTA_GATEWAY #define RTA_GATEWAY 0x2 pollution: RTA_GENMASK #define RTA_GENMASK 0x8 pollution: RTA_IFA #define RTA_IFA 0x20 pollution: RTA_IFP #define RTA_IFP 0x10 pollution: RTA_NETMASK #define RTA_NETMASK 0x4 pollution: RTENTRY_REF #define RTENTRY_REF(rt) fetch_and_add_h(&(rt)->rt_refcnt, 1); pollution: RTENTRY_UNREF #define RTENTRY_UNREF(rt) fetch_and_add_h(&(rt)->rt_refcnt, -1); pollution: RTF_ACTIVE_DGD #define RTF_ACTIVE_DGD 0x1000000 pollution: RTF_BCE #define RTF_BCE 0x80000 pollution: RTF_BLACKHOLE #define RTF_BLACKHOLE 0x1000 pollution: RTF_BROADCAST #define RTF_BROADCAST 0x400000 pollution: RTF_BUL #define RTF_BUL 0x2000 pollution: RTF_CACHED #define RTF_CACHED 0x20000000 pollution: RTF_CLONE #define RTF_CLONE 0x10000 pollution: RTF_CLONED #define RTF_CLONED 0x20000 pollution: RTF_CLONING #define RTF_CLONING 0x100 pollution: RTF_DONE #define RTF_DONE 0x40 pollution: RTF_DYNAMIC #define RTF_DYNAMIC 0x10 pollution: RTF_FREE_IN_PROG #define RTF_FREE_IN_PROG 0x4000000 pollution: RTF_GATEWAY #define RTF_GATEWAY 0x2 pollution: RTF_HOST #define RTF_HOST 0x4 pollution: RTF_LLINFO #define RTF_LLINFO 0x400 pollution: RTF_LOCAL #define RTF_LOCAL 0x200000 pollution: RTF_MASK #define RTF_MASK 0x80 pollution: RTF_MODIFIED #define RTF_MODIFIED 0x20 pollution: RTF_MULTICAST #define RTF_MULTICAST 0x800000 pollution: RTF_PERMANENT6 #define RTF_PERMANENT6 0x8000000 pollution: RTF_PINNED #define RTF_PINNED 0x100000 pollution: RTF_PROTO1 #define RTF_PROTO1 0x8000 pollution: RTF_PROTO2 #define RTF_PROTO2 0x4000 pollution: RTF_PROTO3 #define RTF_PROTO3 0x40000 pollution: RTF_REJECT #define RTF_REJECT 0x8 pollution: RTF_SMALLMTU #define RTF_SMALLMTU 0x40000 pollution: RTF_STATIC #define RTF_STATIC 0x800 pollution: RTF_STOPSRCH #define RTF_STOPSRCH 0x2000000 pollution: RTF_UNREACHABLE #define RTF_UNREACHABLE 0x10000000 pollution: RTF_UP #define RTF_UP 0x1 pollution: RTF_XRESOLVE #define RTF_XRESOLVE 0x200 pollution: RTM_ADD #define RTM_ADD 0x1 pollution: RTM_CHANGE #define RTM_CHANGE 0x3 pollution: RTM_DELADDR #define RTM_DELADDR 0xd pollution: RTM_DELETE #define RTM_DELETE 0x2 pollution: RTM_EXPIRE #define RTM_EXPIRE 0xf pollution: RTM_GET #define RTM_GET 0x4 pollution: RTM_GETNEXT #define RTM_GETNEXT 0x11 pollution: RTM_IFINFO #define RTM_IFINFO 0xe pollution: RTM_LOCK #define RTM_LOCK 0x8 pollution: RTM_LOSING #define RTM_LOSING 0x5 pollution: RTM_MISS #define RTM_MISS 0x7 pollution: RTM_NEWADDR #define RTM_NEWADDR 0xc pollution: RTM_OLDADD #define RTM_OLDADD 0x9 pollution: RTM_OLDDEL #define RTM_OLDDEL 0xa pollution: RTM_REDIRECT #define RTM_REDIRECT 0x6 pollution: RTM_RESOLVE #define RTM_RESOLVE 0xb pollution: RTM_RTLOST #define RTM_RTLOST 0x10 pollution: RTM_RTTUNIT #define RTM_RTTUNIT 1000000 pollution: RTM_SAMEADDR #define RTM_SAMEADDR 0x12 pollution: RTM_SET #define RTM_SET 0x13 pollution: RTM_VERSION #define RTM_VERSION 2 pollution: RTM_VERSION_GR #define RTM_VERSION_GR 4 pollution: RTM_VERSION_GR_COMPAT #define RTM_VERSION_GR_COMPAT 3 pollution: RTM_VERSION_POLICY #define RTM_VERSION_POLICY 5 pollution: RTM_VERSION_POLICY_EXT #define RTM_VERSION_POLICY_EXT 6 pollution: RTM_VERSION_POLICY_PRFN #define RTM_VERSION_POLICY_PRFN 7 pollution: RTSIG_MAX #define RTSIG_MAX _POSIX_RTSIG_MAX pollution: RTTTOPRHZ #define RTTTOPRHZ(r) ((r) / (RTM_RTTUNIT / PR_SLOWHZ)) pollution: RTV_EXPIRE #define RTV_EXPIRE 0x4 pollution: RTV_HOPCOUNT #define RTV_HOPCOUNT 0x2 pollution: RTV_MTU #define RTV_MTU 0x1 pollution: RTV_RPIPE #define RTV_RPIPE 0x8 pollution: RTV_RTT #define RTV_RTT 0x40 pollution: RTV_RTTVAR #define RTV_RTTVAR 0x80 pollution: RTV_SPIPE #define RTV_SPIPE 0x10 pollution: RTV_SSTHRESH #define RTV_SSTHRESH 0x20 pollution: RT_ROUNDUP #define RT_ROUNDUP(sa) ((sa)->sa_len > 0 ? (1 + (((sa)->sa_len-1) | (sizeof(int)-1))) : sizeof(int)) pollution: R_Malloc #define R_Malloc(p,t,n) (p = (t) malloc((unsigned int)(n))) pollution: SAME_ADDR6 #define SAME_ADDR6(a,b) (((a).s6_addr32[0] == (b).s6_addr32[0]) && ((a).s6_addr32[1] == (b).s6_addr32[1]) && ((a).s6_addr32[2] == (b).s6_addr32[2]) && ((a).s6_addr32[3] == (b).s6_addr32[3])) pollution: SAME_PREFIX6 #define SAME_PREFIX6(a,b,m) ((((a).s6_addr32[0] & (m).s6_addr32[0]) == (b).s6_addr32[0]) && (((a).s6_addr32[1] & (m).s6_addr32[1]) == (b).s6_addr32[1]) && (((a).s6_addr32[2] & (m).s6_addr32[2]) == (b).s6_addr32[2]) && (((a).s6_addr32[3] & (m).s6_addr32[3]) == (b).s6_addr32[3])) pollution: SAME_SOCKADDR #define SAME_SOCKADDR(a,b) (((a)->sin6_addr.s6_addr32[0] == (b)->sin6_addr.s6_addr32[0]) && ((a)->sin6_addr.s6_addr32[1] == (b)->sin6_addr.s6_addr32[1]) && ((a)->sin6_addr.s6_addr32[2] == (b)->sin6_addr.s6_addr32[2]) && ((a)->sin6_addr.s6_addr32[3] == (b)->sin6_addr.s6_addr32[3])) pollution: SCHAR_MAX #define SCHAR_MAX (127) pollution: SCHAR_MIN #define SCHAR_MIN (-SCHAR_MAX - 1) pollution: SCM_RIGHTS #define SCM_RIGHTS 0x01 pollution: SCNd16 #define SCNd16 "hd" pollution: SCNd32 #define SCNd32 "d" pollution: SCNd64 #define SCNd64 "lld" pollution: SCNd8 #define SCNd8 "hhd" pollution: SCNdFAST #define SCNdFAST "d" pollution: SCNdFAST16 #define SCNdFAST16 "hd" pollution: SCNdFAST32 #define SCNdFAST32 "d" pollution: SCNdFAST64 #define SCNdFAST64 "lld" pollution: SCNdFAST8 #define SCNdFAST8 "hhd" pollution: SCNdLEAST16 #define SCNdLEAST16 "hd" pollution: SCNdLEAST32 #define SCNdLEAST32 "d" pollution: SCNdLEAST64 #define SCNdLEAST64 "lld" pollution: SCNdLEAST8 #define SCNdLEAST8 "hhd" pollution: SCNdMAX #define SCNdMAX "lld" pollution: SCNdPTR #define SCNdPTR "ld" pollution: SCNi16 #define SCNi16 "hi" pollution: SCNi32 #define SCNi32 "i" pollution: SCNi64 #define SCNi64 "lli" pollution: SCNi8 #define SCNi8 "hhi" pollution: SCNiFAST16 #define SCNiFAST16 "hi" pollution: SCNiFAST32 #define SCNiFAST32 "i" pollution: SCNiFAST64 #define SCNiFAST64 "lli" pollution: SCNiFAST8 #define SCNiFAST8 "hhi" pollution: SCNiLEAST16 #define SCNiLEAST16 "hi" pollution: SCNiLEAST32 #define SCNiLEAST32 "i" pollution: SCNiLEAST64 #define SCNiLEAST64 "lli" pollution: SCNiLEAST8 #define SCNiLEAST8 "hhi" pollution: SCNiMAX #define SCNiMAX "lld" pollution: SCNiPTR #define SCNiPTR "ld" pollution: SCNo16 #define SCNo16 "ho" pollution: SCNo32 #define SCNo32 "o" pollution: SCNo64 #define SCNo64 "llo" pollution: SCNo8 #define SCNo8 "hho" pollution: SCNoFAST #define SCNoFAST "o" pollution: SCNoFAST16 #define SCNoFAST16 "ho" pollution: SCNoFAST32 #define SCNoFAST32 "o" pollution: SCNoFAST64 #define SCNoFAST64 "llo" pollution: SCNoFAST8 #define SCNoFAST8 "hho" pollution: SCNoLEAST16 #define SCNoLEAST16 "ho" pollution: SCNoLEAST32 #define SCNoLEAST32 "o" pollution: SCNoLEAST64 #define SCNoLEAST64 "llo" pollution: SCNoLEAST8 #define SCNoLEAST8 "hho" pollution: SCNoMAX #define SCNoMAX "llo" pollution: SCNoPTR #define SCNoPTR "lo" pollution: SCNu16 #define SCNu16 "hu" pollution: SCNu32 #define SCNu32 "u" pollution: SCNu64 #define SCNu64 "llu" pollution: SCNu8 #define SCNu8 "hhu" pollution: SCNuFAST #define SCNuFAST "u" pollution: SCNuFAST16 #define SCNuFAST16 "hu" pollution: SCNuFAST32 #define SCNuFAST32 "u" pollution: SCNuFAST64 #define SCNuFAST64 "llu" pollution: SCNuFAST8 #define SCNuFAST8 "hhu" pollution: SCNuLEAST16 #define SCNuLEAST16 "hu" pollution: SCNuLEAST32 #define SCNuLEAST32 "u" pollution: SCNuLEAST64 #define SCNuLEAST64 "llu" pollution: SCNuLEAST8 #define SCNuLEAST8 "hhu" pollution: SCNuMAX #define SCNuMAX "llu" pollution: SCNuPTR #define SCNuPTR "lu" pollution: SCNx16 #define SCNx16 "hx" pollution: SCNx32 #define SCNx32 "x" pollution: SCNx64 #define SCNx64 "llx" pollution: SCNx8 #define SCNx8 "hhx" pollution: SCNxFAST #define SCNxFAST "x" pollution: SCNxFAST16 #define SCNxFAST16 "hx" pollution: SCNxFAST32 #define SCNxFAST32 "x" pollution: SCNxFAST64 #define SCNxFAST64 "llx" pollution: SCNxFAST8 #define SCNxFAST8 "hhx" pollution: SCNxLEAST16 #define SCNxLEAST16 "hx" pollution: SCNxLEAST32 #define SCNxLEAST32 "x" pollution: SCNxLEAST64 #define SCNxLEAST64 "llx" pollution: SCNxLEAST8 #define SCNxLEAST8 "hhx" pollution: SCNxMAX #define SCNxMAX "llx" pollution: SCNxPTR #define SCNxPTR "lx" pollution: SDLC #define SDLC IFT_SDLC pollution: SELECTIVE_TRACE #define SELECTIVE_TRACE 1 pollution: SEM_NSEMS_MAX #define SEM_NSEMS_MAX 32768 pollution: SEM_VALUE_MAX #define SEM_VALUE_MAX _POSIX_SEM_VALUE_MAX pollution: SF_CLOSE #define SF_CLOSE 0x00000001 pollution: SF_DONT_CACHE #define SF_DONT_CACHE 0x00000004 pollution: SF_INT64 #define SF_INT64(x) int64_t x; pollution: SF_REUSE #define SF_REUSE 0x00000002 pollution: SF_SYNC_CACHE #define SF_SYNC_CACHE 0x00000008 pollution: SF_UINT64 #define SF_UINT64(x) uint64_t x; pollution: SHRT_MAX #define SHRT_MAX (32767) pollution: SHRT_MIN #define SHRT_MIN (-SHRT_MAX - 1) pollution: SHUT_RD #define SHUT_RD 0 pollution: SHUT_RDWR #define SHUT_RDWR 2 pollution: SHUT_WR #define SHUT_WR 1 pollution: SIGQUEUE_MAX #define SIGQUEUE_MAX _POSIX_SIGQUEUE_MAX pollution: SIG_ATOMIC_MAX #define SIG_ATOMIC_MAX INT32_MAX pollution: SIG_ATOMIC_MIN #define SIG_ATOMIC_MIN INT32_MIN pollution: SIMPLE_LOCK_AVAIL #define SIMPLE_LOCK_AVAIL ((simple_lock_data)0) pollution: SIN6_LEN #define SIN6_LEN #define SIZE_MAX (4294967295UL) pollution: SOCKTHRESH #define SOCKTHRESH 85 pollution: SOCK_CONN_DGRAM #define SOCK_CONN_DGRAM 6 pollution: SOCK_DGRAM #define SOCK_DGRAM 2 pollution: SOCK_RAW #define SOCK_RAW 3 pollution: SOCK_RDM #define SOCK_RDM 4 pollution: SOCK_SEQPACKET #define SOCK_SEQPACKET 5 pollution: SOCK_SMCR #define SOCK_SMCR 7 pollution: SOCK_STREAM #define SOCK_STREAM 1 pollution: SOL_SOCKET #define SOL_SOCKET 0xffff pollution: SOMAXCONN #define SOMAXCONN 1024 pollution: SO_ACCEPTCONN #define SO_ACCEPTCONN 0x0002 pollution: SO_AUDIT #define SO_AUDIT 0x8000 pollution: SO_BROADCAST #define SO_BROADCAST 0x0020 pollution: SO_CKSUMRECV #define SO_CKSUMRECV 0x0800 pollution: SO_DEBUG #define SO_DEBUG 0x0001 pollution: SO_DONTROUTE #define SO_DONTROUTE 0x0010 pollution: SO_ERROR #define SO_ERROR 0x1007 pollution: SO_KEEPALIVE #define SO_KEEPALIVE 0x0008 pollution: SO_KERNACCEPT #define SO_KERNACCEPT 0x2000 pollution: SO_LINGER #define SO_LINGER 0x0080 pollution: SO_NOMULTIPATH #define SO_NOMULTIPATH 0x4000 pollution: SO_NOREUSEADDR #define SO_NOREUSEADDR 0x1000 pollution: SO_OOBINLINE #define SO_OOBINLINE 0x0100 pollution: SO_PEERID #define SO_PEERID 0x1009 pollution: SO_RASART #define SO_RASART 0x1010 pollution: SO_RCVBUF #define SO_RCVBUF 0x1002 pollution: SO_RCVLOWAT #define SO_RCVLOWAT 0x1004 pollution: SO_RCVTIMEO #define SO_RCVTIMEO 0x1006 pollution: SO_REUSEADDR #define SO_REUSEADDR 0x0004 pollution: SO_REUSEPORT #define SO_REUSEPORT 0x0200 pollution: SO_SNDBUF #define SO_SNDBUF 0x1001 pollution: SO_SNDLOWAT #define SO_SNDLOWAT 0x1003 pollution: SO_SNDTIMEO #define SO_SNDTIMEO 0x1005 pollution: SO_TIMESTAMPNS #define SO_TIMESTAMPNS 0x100A pollution: SO_TIMESTAMPNS_HW #define SO_TIMESTAMPNS_HW 0x100B pollution: SO_TYPE #define SO_TYPE 0x1008 pollution: SO_USELOOPBACK #define SO_USELOOPBACK 0x0040 pollution: SO_USE_IFBUFS #define SO_USE_IFBUFS 0x0400 pollution: SRR_IS_GUARD #define SRR_IS_GUARD 0x10000000 pollution: SRR_IS_IIO #define SRR_IS_IIO 0x10000000 pollution: SRR_IS_ISPEC #define SRR_IS_ISPEC 0x20000000 pollution: SRR_IS_LOOP #define SRR_IS_LOOP 0x04000000 pollution: SRR_IS_PFT #define SRR_IS_PFT 0x40000000 pollution: SRR_IS_PROT #define SRR_IS_PROT 0x08000000 pollution: SRR_PR_FPEN #define SRR_PR_FPEN 0x00100000 pollution: SRR_PR_IMPRE #define SRR_PR_IMPRE 0x00010000 pollution: SRR_PR_INVAL #define SRR_PR_INVAL 0x00080000 pollution: SRR_PR_PRIV #define SRR_PR_PRIV 0x00040000 pollution: SRR_PR_TM_BAD #define SRR_PR_TM_BAD 0x00200000 pollution: SRR_PR_TRAP #define SRR_PR_TRAP 0x00020000 pollution: SSIZE_MAX #define SSIZE_MAX LONG_MAX pollution: STARLAN #define STARLAN IFT_STARLAN pollution: STREAM_MAX #define STREAM_MAX 32767 pollution: SYMLOOP_MAX #define SYMLOOP_MAX 20 pollution: SYS_ADSPACE #define SYS_ADSPACE 1 pollution: SYS_ADSPACE_ASSIGN_KEYSET #define SYS_ADSPACE_ASSIGN_KEYSET 5 pollution: T1_CARRIER #define T1_CARRIER IFT_T1 pollution: TAILQ_ENTRY #define TAILQ_ENTRY(type) struct { struct type *tqe_next; struct type **tqe_prev; } pollution: TAILQ_HEAD #define TAILQ_HEAD(name,type) struct name { struct type *tqh_first; struct type **tqh_last; } pollution: TAILQ_INIT #define TAILQ_INIT(head) { (head)->tqh_first = NULL; (head)->tqh_last = &(head)->tqh_first; } pollution: TAILQ_INSERT_AFTER #define TAILQ_INSERT_AFTER(head,listelm,elm,field) { if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL) (elm)->field.tqe_next->field.tqe_prev = &(elm)->field.tqe_next; else (head)->tqh_last = &(elm)->field.tqe_next; (listelm)->field.tqe_next = (elm); (elm)->field.tqe_prev = &(listelm)->field.tqe_next; } pollution: TAILQ_INSERT_BEFORE #define TAILQ_INSERT_BEFORE(listelm,elm,field) { (elm)->field.tqe_prev = (listelm)->field.tqe_prev; (elm)->field.tqe_next = (listelm); *(listelm)->field.tqe_prev = (elm); (listelm)->field.tqe_prev = &(elm)->field.tqe_next; } pollution: TAILQ_INSERT_HEAD #define TAILQ_INSERT_HEAD(head,elm,field) { if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) (elm)->field.tqe_next->field.tqe_prev = &(elm)->field.tqe_next; else (head)->tqh_last = &(elm)->field.tqe_next; (head)->tqh_first = (elm); (elm)->field.tqe_prev = &(head)->tqh_first; } pollution: TAILQ_INSERT_TAIL #define TAILQ_INSERT_TAIL(head,elm,field) { (elm)->field.tqe_next = NULL; (elm)->field.tqe_prev = (head)->tqh_last; *(head)->tqh_last = (elm); (head)->tqh_last = &(elm)->field.tqe_next; } pollution: TAILQ_REMOVE #define TAILQ_REMOVE(head,elm,field) { if (((elm)->field.tqe_next) != NULL) (elm)->field.tqe_next->field.tqe_prev = (elm)->field.tqe_prev; else (head)->tqh_last = (elm)->field.tqe_prev; *(elm)->field.tqe_prev = (elm)->field.tqe_next; } pollution: TEXASR_ABORT #define TEXASR_ABORT 0x0000000100000000L pollution: TEXASR_DISALLOW #define TEXASR_DISALLOW 0x0080000000000000L pollution: TEXASR_FC #define TEXASR_FC 0xFE00000000000000L pollution: TEXASR_FOOT_OV #define TEXASR_FOOT_OV 0x0020000000000000L pollution: TEXASR_FS #define TEXASR_FS 0x0000000008000000L pollution: TEXASR_IMP_SPEC #define TEXASR_IMP_SPEC 0x0001000000000000L pollution: TEXASR_NEST_OV #define TEXASR_NEST_OV 0x0040000000000000L pollution: TEXASR_NON_TR_CONF #define TEXASR_NON_TR_CONF 0x0008000000000000L pollution: TEXASR_PERSISTENT #define TEXASR_PERSISTENT 0x0100000000000000L pollution: TEXASR_PR #define TEXASR_PR 0x0000000030000000L pollution: TEXASR_ROT #define TEXASR_ROT 0x0000000002000000L pollution: TEXASR_SELF_CONF #define TEXASR_SELF_CONF 0x0010000000000000L pollution: TEXASR_SUSPENDED #define TEXASR_SUSPENDED 0x0000000080000000L pollution: TEXASR_TFIAR_EXACT #define TEXASR_TFIAR_EXACT 0x0000000004000000L pollution: TEXASR_TL #define TEXASR_TL 0x0000000000000FFFL pollution: TEXASR_TLB_INV_CONF #define TEXASR_TLB_INV_CONF 0x0002000000000000L pollution: TEXASR_TR_CONF #define TEXASR_TR_CONF 0x0004000000000000L pollution: TEXASR_USER_STATE #define TEXASR_USER_STATE 0x0000000040000000L pollution: TIMEBASE_SZ #define TIMEBASE_SZ (sizeof (struct timebasestruct)) pollution: TIMEOFDAY #define TIMEOFDAY 9 pollution: TIMERID_ALRM #define TIMERID_ALRM (ITIMER_REAL) pollution: TIMERID_PROF #define TIMERID_PROF (ITIMER_PROF) pollution: TIMERID_REAL #define TIMERID_REAL (ITIMER_REAL) pollution: TIMERID_REAL1 #define TIMERID_REAL1 (ITIMER_REAL1) pollution: TIMERID_REAL_TH #define TIMERID_REAL_TH TIMERID_REAL1 pollution: TIMERID_TOD #define TIMERID_TOD (TIMERID_VIRT+1) pollution: TIMERID_VIRT #define TIMERID_VIRT (ITIMER_VIRT) pollution: TIMERID_VIRTUAL #define TIMERID_VIRTUAL (ITIMER_VIRTUAL) pollution: TIMER_MAX #define TIMER_MAX _POSIX_TIMER_MAX pollution: TMP_MAX #define TMP_MAX 16384 pollution: TM_ALIGN_INT #define TM_ALIGN_INT 0x17 pollution: TM_BAD_THING #define TM_BAD_THING 0x13 pollution: TM_CPU_SPARED #define TM_CPU_SPARED 0x0C pollution: TM_ILL_SC #define TM_ILL_SC 0x03 pollution: TM_INV_OP #define TM_INV_OP 0x15 pollution: TM_KDB_ENTERED #define TM_KDB_ENTERED 0x14 pollution: TM_LIBC #define TM_LIBC 0x0D pollution: TM_NOT_FAC_OWNER #define TM_NOT_FAC_OWNER 0x0A pollution: TM_NOT_FP_OWNER #define TM_NOT_FP_OWNER 0x04 pollution: TM_NOT_VMX_OWNER #define TM_NOT_VMX_OWNER 0x06 pollution: TM_NOT_VSX_OWNER #define TM_NOT_VSX_OWNER 0x08 pollution: TM_PERSISTENT #define TM_PERSISTENT 0x01 pollution: TM_PREEMPTED #define TM_PREEMPTED 0x02 pollution: TM_PROC_TERMINATED #define TM_PROC_TERMINATED 0x05 pollution: TM_PROG_EXEC #define TM_PROG_EXEC 0x0B pollution: TM_PTH_PREEMPTED #define TM_PTH_PREEMPTED 0x0F pollution: TM_SIG_DELIVERED #define TM_SIG_DELIVERED 0x10 pollution: TM_SYNC_SIGNAL #define TM_SYNC_SIGNAL 0x11 pollution: TM_THREAD_FORKED #define TM_THREAD_FORKED 0x07 pollution: TM_THREAD_START #define TM_THREAD_START 0x12 pollution: TM_THREAD_SUSP #define TM_THREAD_SUSP 0x0E pollution: TM_THREAD_TERMINATED #define TM_THREAD_TERMINATED 0x09 pollution: TRACE_EVENT_NAME_MAX #define TRACE_EVENT_NAME_MAX 255 pollution: TRACE_NAME_MAX #define TRACE_NAME_MAX 255 pollution: TRACE_SYS_MAX #define TRACE_SYS_MAX 64 pollution: TRACE_USER_EVENT_MAX #define TRACE_USER_EVENT_MAX 56 pollution: TRUE #define TRUE 1 pollution: TTY_NAME_MAX #define TTY_NAME_MAX PATH_MAX pollution: TZNAME_MAX #define TZNAME_MAX 255 pollution: UADDR6_SCOPE_MAX #define UADDR6_SCOPE_MAX 0xF pollution: UADDR6_SELECT_GLOBAL #define UADDR6_SELECT_GLOBAL ADDR6_SCP_GLOBAL pollution: UADDR6_SELECT_INTF #define UADDR6_SELECT_INTF ADDR6_SCP_INTF pollution: UADDR6_SELECT_LINK #define UADDR6_SELECT_LINK ADDR6_SCP_LINK pollution: UADDR6_SELECT_NODE #define UADDR6_SELECT_NODE ADDR6_SCP_NODE pollution: UADDR6_SELECT_ORG #define UADDR6_SELECT_ORG ADDR6_SCP_ORG pollution: UADDR6_SELECT_SITE #define UADDR6_SELECT_SITE ADDR6_SCP_SITE pollution: UCAST_TYPE #define UCAST_TYPE 1 pollution: UCHAR_MAX #define UCHAR_MAX (255) pollution: UID_MAX #define UID_MAX UINT_MAX pollution: UINT16_C #define UINT16_C(c) c pollution: UINT16_MAX #define UINT16_MAX (65535) pollution: UINT32_C #define UINT32_C(c) __CONCAT__(c,U) pollution: UINT32_MAX #define UINT32_MAX (4294967295U) pollution: UINT64_C #define UINT64_C(c) __CONCAT__(c,ULL) pollution: UINT64_MAX #define UINT64_MAX (UINT64_C(18446744073709551615)) pollution: UINT8_C #define UINT8_C(c) c pollution: UINT8_MAX #define UINT8_MAX (255) pollution: UINTFAST_MAX #define UINTFAST_MAX UINT32_MAX pollution: UINTMAX_C #define UINTMAX_C(c) __CONCAT__(c,ULL) pollution: UINTMAX_MAX #define UINTMAX_MAX UINT64_MAX pollution: UINTPTR_MAX #define UINTPTR_MAX (4294967295UL) pollution: UINT_FAST16_MAX #define UINT_FAST16_MAX UINT16_MAX pollution: UINT_FAST32_MAX #define UINT_FAST32_MAX UINT32_MAX pollution: UINT_FAST64_MAX #define UINT_FAST64_MAX UINT64_MAX pollution: UINT_FAST8_MAX #define UINT_FAST8_MAX UINT8_MAX pollution: UINT_LEAST16_MAX #define UINT_LEAST16_MAX UINT16_MAX pollution: UINT_LEAST32_MAX #define UINT_LEAST32_MAX UINT32_MAX pollution: UINT_LEAST64_MAX #define UINT_LEAST64_MAX UINT64_MAX pollution: UINT_LEAST8_MAX #define UINT_LEAST8_MAX UINT8_MAX pollution: UINT_MAX #define UINT_MAX (4294967295U) pollution: UIO_MAXIOV #define UIO_MAXIOV 1024 pollution: UIO_SMALLIOV #define UIO_SMALLIOV 8 pollution: UIO_SYSSPACE #define UIO_SYSSPACE SYS_ADSPACE pollution: UIO_USERISPACE #define UIO_USERISPACE USERI_ADSPACE pollution: UIO_USERSPACE #define UIO_USERSPACE USER_ADSPACE pollution: UIO_XMEM #define UIO_XMEM 3 pollution: ULLONG_MAX #define ULLONG_MAX (18446744073709551615ULL) pollution: ULONGLONG_MAX #define ULONGLONG_MAX (0xffffffffffffffffuLL) pollution: ULONG_MAX #define ULONG_MAX (4294967295UL) pollution: UNFAVORED_JITTER_DISPATCH_WINDOW #define UNFAVORED_JITTER_DISPATCH_WINDOW (0) pollution: UPDT #define UPDT 3 pollution: URG_DEFAULT #define URG_DEFAULT (0<= CRE_AIX_71_BTL)) pollution: VALID_CRE_LVL #define VALID_CRE_LVL(x) (V5_VWPAR_LVL(x) || V71_VWPAR_LVL(x)) pollution: VRSAVE_NONE #define VRSAVE_NONE 0x0000 pollution: VRSAVE_TM #define VRSAVE_TM 0x0002 pollution: VRSAVE_VX #define VRSAVE_VX 0x0001 pollution: VSCR_NJ #define VSCR_NJ 0x00010000 pollution: VSCR_SAT #define VSCR_SAT 0x00000001 pollution: VWPAR_FMT_MASK #define VWPAR_FMT_MASK 0xC000 pollution: VWPAR_FMT_SHIFT #define VWPAR_FMT_SHIFT 14 pollution: VWPAR_MIN_REL #define VWPAR_MIN_REL 1 pollution: VWPAR_MIN_VER #define VWPAR_MIN_VER 5 pollution: VWPAR_REL_MASK #define VWPAR_REL_MASK 0x600 pollution: VWPAR_REL_SHIFT #define VWPAR_REL_SHIFT 9 pollution: VWPAR_SC_MASK #define VWPAR_SC_MASK 0x1F pollution: VWPAR_SC_SHIFT #define VWPAR_SC_SHIFT 0 pollution: VWPAR_TL_LVL #define VWPAR_TL_LVL(x) ((x) & (VWPAR_TL_MASK)) pollution: VWPAR_TL_MASK #define VWPAR_TL_MASK 0x1E0 pollution: VWPAR_TL_SHIFT #define VWPAR_TL_SHIFT 5 pollution: VWPAR_VER_MASK #define VWPAR_VER_MASK 0x3800 pollution: VWPAR_VER_SHIFT #define VWPAR_VER_SHIFT 11 pollution: VWPAR_VRT_LVL #define VWPAR_VRT_LVL(x) ((x) & (VWPAR_VER_MASK|VWPAR_REL_MASK|VWPAR_TL_MASK)) pollution: VWPAR_VR_LVL #define VWPAR_VR_LVL(x) ((x) & (VWPAR_VER_MASK|VWPAR_REL_MASK)) pollution: VWPAR_V_LVL #define VWPAR_V_LVL(x) ((x) & (VWPAR_VER_MASK)) pollution: WCHAR_MAX #define WCHAR_MAX UINT16_MAX pollution: WCHAR_MIN #define WCHAR_MIN 0 pollution: WINT_MAX #define WINT_MAX INT32_MAX pollution: WINT_MIN #define WINT_MIN INT32_MIN pollution: WORD_BIT #define WORD_BIT 32 pollution: WPARCID_MAX #define WPARCID_MAX CORRAL_MAX pollution: WPARSTART #define WPARSTART 1 pollution: WPARSTOP #define WPARSTOP 2 pollution: WPARTTYNAME #define WPARTTYNAME "Global" pollution: WPAR_CHECKPOINT_ALLOW #define WPAR_CHECKPOINT_ALLOW 0x3 pollution: WPAR_CHECKPOINT_CLEAR #define WPAR_CHECKPOINT_CLEAR 0x4 pollution: WPAR_CHECKPOINT_CROSS_LEVEL_MIG #define WPAR_CHECKPOINT_CROSS_LEVEL_MIG 0x8 pollution: WPAR_CHECKPOINT_DENY #define WPAR_CHECKPOINT_DENY 0x2 pollution: WPAR_CHECKPOINT_DENY_ALL #define WPAR_CHECKPOINT_DENY_ALL 0x7 pollution: WPAR_CHECKPOINT_QUERY #define WPAR_CHECKPOINT_QUERY 0x6 pollution: WPAR_CHECKPOINT_SAME_LEVEL_MIG #define WPAR_CHECKPOINT_SAME_LEVEL_MIG 0x9 pollution: WPAR_CHECKPOINT_TRY #define WPAR_CHECKPOINT_TRY 0x1 pollution: WPAR_GLOBAL #define WPAR_GLOBAL CORRAL_GLOBAL pollution: WPAR_MAX #define WPAR_MAX 8193 pollution: WPAR_RESTART_CLEAR #define WPAR_RESTART_CLEAR 0x5 pollution: WRC_PCT_MSGIDS #define WRC_PCT_MSGIDS 1 pollution: WRC_PCT_PINMEM #define WRC_PCT_PINMEM 3 pollution: WRC_PCT_SEMIDS #define WRC_PCT_SEMIDS 0 pollution: WRC_PCT_SHMIDS #define WRC_PCT_SHMIDS 2 pollution: XER_CA #define XER_CA 0x20000000 pollution: XER_COMP_BYTE #define XER_COMP_BYTE(xer) ((xer >> 8) & 0x000000FF) pollution: XER_LENGTH #define XER_LENGTH(xer) (xer & 0x0000007F) pollution: XER_OV #define XER_OV 0x40000000 pollution: XER_SO #define XER_SO 0x80000000 pollution: XLATE_ALLOC #define XLATE_ALLOC 0x4 pollution: XLATE_DR_SAFE #define XLATE_DR_SAFE 0x10 pollution: XLATE_FAST #define XLATE_FAST 0x40 pollution: XLATE_PERSISTENT #define XLATE_PERSISTENT 0x1 pollution: XLATE_PRESENT #define XLATE_PRESENT 0x2 pollution: XLATE_SPARSE #define XLATE_SPARSE 0x8 pollution: XLATE_TRANSIENT #define XLATE_TRANSIENT 0x20 pollution: XMEM_ACC_CHK #define XMEM_ACC_CHK 0x00000002 pollution: XMEM_AGAIN #define XMEM_AGAIN (-2) pollution: XMEM_DR_RETRY #define XMEM_DR_RETRY 0x00000010 pollution: XMEM_DR_SAFE #define XMEM_DR_SAFE 0x00000008 pollution: XMEM_FAIL #define XMEM_FAIL (-1) pollution: XMEM_GLOBAL #define XMEM_GLOBAL (-1) pollution: XMEM_HIDE #define XMEM_HIDE 0x00000000 pollution: XMEM_INVAL #define XMEM_INVAL (-2) pollution: XMEM_NOACC #define XMEM_NOACC 2 pollution: XMEM_PROC #define XMEM_PROC ( 0) pollution: XMEM_PROC2 #define XMEM_PROC2 (-3) pollution: XMEM_RDONLY #define XMEM_RDONLY 0 pollution: XMEM_RDWR #define XMEM_RDWR 1 pollution: XMEM_REMIO #define XMEM_REMIO (-5) pollution: XMEM_SUCC #define XMEM_SUCC (0) pollution: XMEM_UNHIDE #define XMEM_UNHIDE 0x00000001 pollution: XMEM_WRITE_ONLY #define XMEM_WRITE_ONLY 0x00000004 pollution: XMEM_XLATE #define XMEM_XLATE (-4) pollution: XM_UE_XCP #define XM_UE_XCP 0x0001 pollution: ac_enaddr #define ac_enaddr ac_hwaddr pollution: ac_fcaddr #define ac_fcaddr ac_hwaddr pollution: ac_fdaddr #define ac_fdaddr ac_hwaddr pollution: ac_traddr #define ac_traddr ac_hwaddr pollution: accept #define accept naccept pollution: acf_BLOCK_00 #define acf_BLOCK_00 0x98C pollution: acf_BLOCK_01 #define acf_BLOCK_01 0x98D pollution: adsp_is_alloc #define adsp_is_alloc(_a,_x) ((_a)->alloc & ADSP_MASK(_x)) pollution: arp_fddi_rcf #define arp_fddi_rcf ifd.fddi.u_rcf pollution: arp_fddi_seg #define arp_fddi_seg ifd.fddi.u_seg pollution: arp_rcf #define arp_rcf ifd.token.u_rcf pollution: arp_seg #define arp_seg ifd.token.u_seg pollution: arp_session_id #define arp_session_id ifd.x25.u_session_id pollution: arp_x25unit #define arp_x25unit ifd.x25.u_unit pollution: artic_sw_BLOCK_00 #define artic_sw_BLOCK_00 0x000 pollution: aspace_id #define aspace_id _u._aspace_id pollution: at_enaddr #define at_enaddr hwaddr pollution: at_fcaddr #define at_fcaddr hwaddr pollution: at_fdaddr #define at_fdaddr hwaddr pollution: at_fddi_rcf #define at_fddi_rcf if_dependent.fddi.u_rcf pollution: at_fddi_seg #define at_fddi_seg if_dependent.fddi.u_seg pollution: at_ie3addr #define at_ie3addr hwaddr pollution: at_rcf #define at_rcf if_dependent.token.u_rcf pollution: at_seg #define at_seg if_dependent.token.u_seg pollution: at_session_id #define at_session_id if_dependent.x25.u_session_id pollution: at_traddr #define at_traddr hwaddr pollution: at_x25addr #define at_x25addr hwaddr pollution: at_x25unit #define at_x25unit if_dependent.x25.u_unit pollution: atmif_BLOCK_00 #define atmif_BLOCK_00 0x008 pollution: atmle_BLOCK_00 #define atmle_BLOCK_00 0x010 pollution: atmsvc_BLOCK_00 #define atmsvc_BLOCK_00 0x018 pollution: autofs_BLOCK_00 #define autofs_BLOCK_00 0x020 pollution: bbldd_BLOCK_00 #define bbldd_BLOCK_00 0x028 pollution: bluedd_BLOCK_00 #define bluedd_BLOCK_00 0x030 pollution: cachefskern_BLOCK_00 #define cachefskern_BLOCK_00 0x038 pollution: cdide_BLOCK_00 #define cdide_BLOCK_00 0x040 pollution: cfg_nls_BLOCK_00 #define cfg_nls_BLOCK_00 0x048 pollution: cifs_fs_BLOCK_00 #define cifs_fs_BLOCK_00 0x050 pollution: cmdmirror_BLOCK_00 #define cmdmirror_BLOCK_00 0x058 pollution: cormob_C_pmemfstranstbl #define cormob_C_pmemfstranstbl 0xA90 pollution: crypt4769_BLOCK_00 #define crypt4769_BLOCK_00 0xAA1 pollution: diagddent_BLOCK_00 #define diagddent_BLOCK_00 0x060 pollution: diagddfddi_BLOCK_00 #define diagddfddi_BLOCK_00 0x068 pollution: diagddient_BLOCK_00 #define diagddient_BLOCK_00 0x070 pollution: diagddtok_BLOCK_00 #define diagddtok_BLOCK_00 0x078 pollution: diskide_BLOCK_00 #define diskide_BLOCK_00 0x080 pollution: dispccm_BLOCK_00 #define dispccm_BLOCK_00 0x088 pollution: dmxhdlc_BLOCK_00 #define dmxhdlc_BLOCK_00 0x090 pollution: en_addr #define en_addr en_ac.ac_enaddr pollution: en_if #define en_if en_ac.ac_if pollution: entcom_BLOCK_00 #define entcom_BLOCK_00 0x911 pollution: entcom_BLOCK_01 #define entcom_BLOCK_01 0x912 pollution: entcom_BLOCK_02 #define entcom_BLOCK_02 0x913 pollution: entcom_BLOCK_03 #define entcom_BLOCK_03 0x914 pollution: entcom_BLOCK_04 #define entcom_BLOCK_04 0x915 pollution: entcom_BLOCK_05 #define entcom_BLOCK_05 0x916 pollution: entcom_BLOCK_06 #define entcom_BLOCK_06 0x917 pollution: entcom_BLOCK_07 #define entcom_BLOCK_07 0x918 pollution: entcore_v1_BLOCK_00 #define entcore_v1_BLOCK_00 0x9B9 pollution: entcore_v1_BLOCK_01 #define entcore_v1_BLOCK_01 0x9BA pollution: entcore_v1_BLOCK_02 #define entcore_v1_BLOCK_02 0x9BB pollution: entcore_v1_BLOCK_03 #define entcore_v1_BLOCK_03 0x9BC pollution: entcore_v1_BLOCK_04 #define entcore_v1_BLOCK_04 0x9BD pollution: entcore_v1_BLOCK_05 #define entcore_v1_BLOCK_05 0x9BE pollution: entcore_v1_BLOCK_06 #define entcore_v1_BLOCK_06 0x9BF pollution: entcore_v1_BLOCK_07 #define entcore_v1_BLOCK_07 0x9C0 pollution: entcore_v2_BLOCK_00 #define entcore_v2_BLOCK_00 0x9C1 pollution: entcore_v2_BLOCK_01 #define entcore_v2_BLOCK_01 0x9C2 pollution: entcore_v2_BLOCK_02 #define entcore_v2_BLOCK_02 0x9C3 pollution: entcore_v2_BLOCK_03 #define entcore_v2_BLOCK_03 0x9C4 pollution: fc_addr #define fc_addr fc_ac.ac_fcaddr pollution: fc_if #define fc_if fc_ac.ac_if pollution: fh_dev #define fh_dev fh_fsid.fsid_dev pollution: fh_gen #define fh_gen fh_fid.fid_gen pollution: fh_ino #define fh_ino fh_fid.fid_ino pollution: fh_len #define fh_len fh_fid.fid_len pollution: fh_type #define fh_type fh_fsid.fsid_type pollution: flashsysdisk_BLOCK_00 #define flashsysdisk_BLOCK_00 0x660 pollution: fsid_dev #define fsid_dev val[0] pollution: fsid_type #define fsid_type val[1] pollution: getpeername #define getpeername ngetpeername pollution: getsockname #define getsockname ngetsockname pollution: gxme_BLOCK_00 #define gxme_BLOCK_00 0x098 pollution: htonl #define htonl(hostlong) (hostlong) pollution: htonll #define htonll(hostlong) (hostlong) pollution: htons #define htons(hostshort) (unsigned short)(hostshort) pollution: ica_BLOCK_00 #define ica_BLOCK_00 0x0A0 pollution: ifa_broadaddr #define ifa_broadaddr ifa_dstaddr pollution: ifc_buf #define ifc_buf ifc_ifcu.ifcu_buf pollution: ifc_req #define ifc_req ifc_ifcu.ifcu_req pollution: ifr_addr #define ifr_addr ifr_ifru.ifru_addr pollution: ifr_baudrate #define ifr_baudrate ifr_ifru.ifru_baudrate pollution: ifr_broadaddr #define ifr_broadaddr ifr_ifru.ifru_broadaddr pollution: ifr_checksum_offload #define ifr_checksum_offload ifr_ifru.ifru_checksum_offload[1] pollution: ifr_data #define ifr_data ifr_ifru.ifru_data pollution: ifr_dstaddr #define ifr_dstaddr ifr_ifru.ifru_dstaddr pollution: ifr_flags #define ifr_flags ifr_ifru.ifru_flags pollution: ifr_isno #define ifr_isno ifr_ifru.ifru_data pollution: ifr_metric #define ifr_metric ifr_ifru.ifru_metric pollution: ifr_mtu #define ifr_mtu ifr_ifru.ifru_mtu pollution: ifr_obaudrate #define ifr_obaudrate ifr_ifru.ifru_obaudrate pollution: ifr_site6 #define ifr_site6 ifr_ifru.ifru_site6 pollution: inputdd_BLOCK_00 #define inputdd_BLOCK_00 0x0A8 pollution: ipifsInAddrErrors #define ipifsInAddrErrors if_stat.ipif_InAddrErrors pollution: ipifsInDiscards #define ipifsInDiscards if_stat.ipif_InDiscards pollution: ipifsInHdrErrors #define ipifsInHdrErrors if_stat.ipif_InHdrErrors pollution: ipifsInMAddrErrors #define ipifsInMAddrErrors if_stat.ipif_InMAddrErrors pollution: ipifs_cantforward #define ipifs_cantforward if_stat.ipif_cantforward pollution: ipifs_cantfrag #define ipifs_cantfrag if_stat.ipif_cantfrag pollution: ipifs_delivered #define ipifs_delivered if_stat.ipif_delivered pollution: ipifs_disconttime #define ipifs_disconttime if_stat.ipif_disconttime pollution: ipifs_forward #define ipifs_forward if_stat.ipif_forward pollution: ipifs_fragdropped #define ipifs_fragdropped if_stat.ipif_fragdropped pollution: ipifs_fragmented #define ipifs_fragmented if_stat.ipif_fragmented pollution: ipifs_fragments #define ipifs_fragments if_stat.ipif_fragments pollution: ipifs_fragtimeout #define ipifs_fragtimeout if_stat.ipif_fragtimeout pollution: ipifs_inbcastpacks #define ipifs_inbcastpacks if_stat.ipif_inbcastpacks pollution: ipifs_inmcastoctets #define ipifs_inmcastoctets if_stat.ipif_inmcastoctets pollution: ipifs_inmcastpacks #define ipifs_inmcastpacks if_stat.ipif_inmcastpacks pollution: ipifs_inoctets #define ipifs_inoctets if_stat.ipif_inoctets pollution: ipifs_localout #define ipifs_localout if_stat.ipif_localout pollution: ipifs_noproto #define ipifs_noproto if_stat.ipif_noproto pollution: ipifs_noroute #define ipifs_noroute if_stat.ipif_noroute pollution: ipifs_odropped #define ipifs_odropped if_stat.ipif_odropped pollution: ipifs_ofragments #define ipifs_ofragments if_stat.ipif_ofragments pollution: ipifs_outbcastpacks #define ipifs_outbcastpacks if_stat.ipif_outbcastpacks pollution: ipifs_outmcastoctets #define ipifs_outmcastoctets if_stat.ipif_outmcastoctets pollution: ipifs_outmcastpacks #define ipifs_outmcastpacks if_stat.ipif_outmcastpacks pollution: ipifs_outoctets #define ipifs_outoctets if_stat.ipif_outoctets pollution: ipifs_reassembled #define ipifs_reassembled if_stat.ipif_reassembled pollution: ipifs_tooshort #define ipifs_tooshort if_stat.ipif_tooshort pollution: ipifs_toosmall #define ipifs_toosmall if_stat.ipif_toosmall pollution: ipifs_total #define ipifs_total if_stat.ipif_total pollution: ips_tun_BLOCK_00 #define ips_tun_BLOCK_00 0x0B0 pollution: isafd_BLOCK_00 #define isafd_BLOCK_00 0x0B8 pollution: isamouse_BLOCK_00 #define isamouse_BLOCK_00 0x0C0 pollution: isatty_BLOCK_00 #define isatty_BLOCK_00 0x0C8 pollution: isfr_if_iaddr #define isfr_if_iaddr isfr_interface.isfr_if_iaddr pollution: isfr_if_index #define isfr_if_index isfr_interface.isfr_if_index pollution: kauaidd_BLOCK_00 #define kauaidd_BLOCK_00 0x0D0 pollution: ku_freecnt #define ku_freecnt ku_un.freecnt pollution: ku_pagecnt #define ku_pagecnt ku_un.pagecnt pollution: lanaidd_BLOCK_00 #define lanaidd_BLOCK_00 0x0D8 pollution: lftdd_BLOCK_00 #define lftdd_BLOCK_00 0x0E0 pollution: magdd_BLOCK_00 #define magdd_BLOCK_00 0x0E8 pollution: mauidd_BLOCK_00 #define mauidd_BLOCK_00 0x0F0 pollution: mintdd_BLOCK_00 #define mintdd_BLOCK_00 0x0F8 pollution: miragedd_BLOCK_00 #define miragedd_BLOCK_00 0x100 pollution: mpiopcm_BLOCK_00 #define mpiopcm_BLOCK_00 0x108 pollution: mrcdd_BLOCK_00 #define mrcdd_BLOCK_00 0x110 pollution: mstcheck_BLOCK_00 #define mstcheck_BLOCK_00 0x510 pollution: mtndd_BLOCK_00 #define mtndd_BLOCK_00 0x118 pollution: musent_BLOCK_00 #define musent_BLOCK_00 0x9c5 pollution: ntimeradd #define ntimeradd(tvp,svp,rvp) { (rvp).tv_sec = (tvp).tv_sec + (svp).tv_sec; (rvp).tv_nsec = (tvp).tv_nsec + (svp).tv_nsec; if((rvp).tv_nsec > (NS_PER_SEC - 1)) { (rvp).tv_nsec -= NS_PER_SEC; (rvp).tv_sec++; } assert((rvp).tv_nsec <= NS_PER_SEC); } pollution: ntimerclear #define ntimerclear(tvp) (tvp)->tv_sec = (tvp)->tv_nsec = 0 pollution: ntimercmp #define ntimercmp(tvp,fvp,cmp) ((tvp).tv_sec cmp (fvp).tv_sec || (tvp).tv_sec == (fvp).tv_sec && (tvp).tv_nsec cmp (fvp).tv_nsec) pollution: ntimerisset #define ntimerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_nsec) pollution: ntimersub #define ntimersub(tvp,svp,rvp) { assert((tvp).tv_nsec <= NS_PER_SEC); assert((svp).tv_nsec <= NS_PER_SEC); assert(!((tvp).tv_sec == 0 && ((svp).tv_nsec > (tvp).tv_nsec))); if((tvp).tv_sec == (svp).tv_sec) { assert((tvp).tv_nsec >= (svp).tv_nsec); } else { assert((tvp).tv_sec > (svp).tv_sec); } if((svp).tv_nsec > (tvp).tv_nsec) { assert((tvp).tv_sec > (svp).tv_sec); (rvp).tv_sec = ((tvp).tv_sec - 1) - (svp).tv_sec; (rvp).tv_nsec = ((int)(((uint)((tvp).tv_nsec) + NS_PER_SEC) - (uint)((svp).tv_nsec))); } else { (rvp).tv_sec = (tvp).tv_sec - (svp).tv_sec; (rvp).tv_nsec = (tvp).tv_nsec - (svp).tv_nsec; } assert((tvp).tv_nsec <= NS_PER_SEC); assert((svp).tv_nsec <= NS_PER_SEC); assert((rvp).tv_nsec <= NS_PER_SEC); } pollution: ntohl #define ntohl(netlong) (netlong) pollution: ntohll #define ntohll(netlong) (netlong) pollution: ntohs #define ntohs(netshort) (unsigned short)(netshort) pollution: ofed_BLOCK_00 #define ofed_BLOCK_00 0x940 pollution: ofed_BLOCK_00_END #define ofed_BLOCK_00_END 0x97F pollution: ofed_BLOCK_01 #define ofed_BLOCK_01 0x990 pollution: ofed_BLOCK_01_END #define ofed_BLOCK_01_END 0x9AE pollution: ofed_COMMON_HASH_TABLES_C #define ofed_COMMON_HASH_TABLES_C (ofed_BLOCK_00 + 0x21) pollution: ofed_COMMON_IDR_C #define ofed_COMMON_IDR_C (ofed_BLOCK_00 + 0x36) pollution: ofed_COMMON_LINKED_LISTS_C #define ofed_COMMON_LINKED_LISTS_C ofed_BLOCK_00 pollution: ofed_COMMON_MEMORY_MANAGEMENT_C #define ofed_COMMON_MEMORY_MANAGEMENT_C (ofed_BLOCK_00 + 0x15) pollution: ofed_COMMON_MULTIPROCESSOR_C #define ofed_COMMON_MULTIPROCESSOR_C (ofed_BLOCK_00 + 0x16) pollution: ofed_COMMON_OFED_MISC_WRAPPERS_C #define ofed_COMMON_OFED_MISC_WRAPPERS_C (ofed_BLOCK_00 + 0x20) pollution: ofed_COMMON_OFED_RAS_C #define ofed_COMMON_OFED_RAS_C (ofed_BLOCK_00 + 0x13) pollution: ofed_COMMON_OFED_SKBUFF_C #define ofed_COMMON_OFED_SKBUFF_C (ofed_BLOCK_01 + 0x04) pollution: ofed_COMMON_OFED_TASKLETS_C #define ofed_COMMON_OFED_TASKLETS_C (ofed_BLOCK_01 + 0x03) pollution: ofed_COMMON_OFED_TIMERS_C #define ofed_COMMON_OFED_TIMERS_C (ofed_BLOCK_00 + 0x3C) pollution: ofed_COMMON_PERCPU_COUNTER_C #define ofed_COMMON_PERCPU_COUNTER_C ofed_BLOCK_00_END pollution: ofed_COMMON_RED_BLACK_TREES_C #define ofed_COMMON_RED_BLACK_TREES_C (ofed_BLOCK_00 + 0x22) pollution: ofed_COMMON_SYNCRONIZATION_PRIMITIVES_C #define ofed_COMMON_SYNCRONIZATION_PRIMITIVES_C (ofed_BLOCK_00 + 0x01) pollution: ofed_COMMON_WORK_QUEUES_C #define ofed_COMMON_WORK_QUEUES_C (ofed_BLOCK_00 + 0x02) pollution: ofed_CORE_ADDR_C #define ofed_CORE_ADDR_C (ofed_BLOCK_00 + 0x34) pollution: ofed_CORE_AGENT_C #define ofed_CORE_AGENT_C (ofed_BLOCK_00 + 0x3B) pollution: ofed_CORE_AIX_ADDR_C #define ofed_CORE_AIX_ADDR_C (ofed_BLOCK_00 + 0x35) pollution: ofed_CORE_AIX_DMA_VERBS_C #define ofed_CORE_AIX_DMA_VERBS_C (ofed_BLOCK_01) pollution: ofed_CORE_AIX_OFED_CORE_C #define ofed_CORE_AIX_OFED_CORE_C (ofed_BLOCK_00 + 0x2a) pollution: ofed_CORE_CACHE_C #define ofed_CORE_CACHE_C (ofed_BLOCK_00 + 0x2f) pollution: ofed_CORE_CMA_C #define ofed_CORE_CMA_C (ofed_BLOCK_00 + 0x2d) pollution: ofed_CORE_CM_C #define ofed_CORE_CM_C (ofed_BLOCK_00 + 0x38) pollution: ofed_CORE_DEVICE_C #define ofed_CORE_DEVICE_C (ofed_BLOCK_00 + 0x2e) pollution: ofed_CORE_FMR_POOL_C #define ofed_CORE_FMR_POOL_C (ofed_BLOCK_01 + 0x02) pollution: ofed_CORE_IWCM_C #define ofed_CORE_IWCM_C (ofed_BLOCK_00 + 0x2b) pollution: ofed_CORE_LOCAL_SA_C #define ofed_CORE_LOCAL_SA_C (ofed_BLOCK_00 + 0x3E) pollution: ofed_CORE_MAD_C #define ofed_CORE_MAD_C (ofed_BLOCK_00 + 0x3A) pollution: ofed_CORE_MULTICAST_C #define ofed_CORE_MULTICAST_C (ofed_BLOCK_00 + 0x3D) pollution: ofed_CORE_PACKER_C #define ofed_CORE_PACKER_C (ofed_BLOCK_00 + 0x30) pollution: ofed_CORE_SA_QUERY_C #define ofed_CORE_SA_QUERY_C (ofed_BLOCK_00 + 0x39) pollution: ofed_CORE_UCMA_C #define ofed_CORE_UCMA_C (ofed_BLOCK_00 + 0x31) pollution: ofed_CORE_UD_HEADER_C #define ofed_CORE_UD_HEADER_C (ofed_BLOCK_00 + 0x32) pollution: ofed_CORE_UMEM_C #define ofed_CORE_UMEM_C (ofed_BLOCK_01 + 0x01) pollution: ofed_CORE_UVERBS_CMD_C #define ofed_CORE_UVERBS_CMD_C (ofed_BLOCK_00 + 0x37) pollution: ofed_CORE_UVERBS_MAIN_C #define ofed_CORE_UVERBS_MAIN_C (ofed_BLOCK_00 + 0x33) pollution: ofed_CORE_VERBS_C #define ofed_CORE_VERBS_C (ofed_BLOCK_00 + 0x2c) pollution: ofed_RDS_AF_RDS_C #define ofed_RDS_AF_RDS_C (ofed_BLOCK_00 + 0x03) pollution: ofed_RDS_AIX_IB_ARP_PROVIDER_C #define ofed_RDS_AIX_IB_ARP_PROVIDER_C (ofed_BLOCK_00 + 0x1f) pollution: ofed_RDS_AIX_IB_CM_C #define ofed_RDS_AIX_IB_CM_C (ofed_BLOCK_00 + 0x23) pollution: ofed_RDS_AIX_IB_DEVICE_C #define ofed_RDS_AIX_IB_DEVICE_C (ofed_BLOCK_00 + 0x26) pollution: ofed_RDS_AIX_IB_DMA_PAGE_POOL_C #define ofed_RDS_AIX_IB_DMA_PAGE_POOL_C (ofed_BLOCK_00 + 0x27) pollution: ofed_RDS_AIX_IB_WRAPPER_C #define ofed_RDS_AIX_IB_WRAPPER_C (ofed_BLOCK_00 + 0x1e) pollution: ofed_RDS_AIX_OFED_DMA_PAGE_POOL_C #define ofed_RDS_AIX_OFED_DMA_PAGE_POOL_C (ofed_BLOCK_01 + 0x12) pollution: ofed_RDS_AIX_OFED_IB_DEVICE_C #define ofed_RDS_AIX_OFED_IB_DEVICE_C (ofed_BLOCK_01 + 0x11) pollution: ofed_RDS_AIX_OFED_IB_DMA_C #define ofed_RDS_AIX_OFED_IB_DMA_C (ofed_BLOCK_00 + 0x1d) pollution: ofed_RDS_AIX_OFED_SOCKET_C #define ofed_RDS_AIX_OFED_SOCKET_C (ofed_BLOCK_00 + 0x05) pollution: ofed_RDS_AIX_RDMA_WRAPPERS_C #define ofed_RDS_AIX_RDMA_WRAPPERS_C (ofed_BLOCK_00 + 0x28) pollution: ofed_RDS_AIX_RDS_CONFIG_C #define ofed_RDS_AIX_RDS_CONFIG_C (ofed_BLOCK_00 + 0x04) pollution: ofed_RDS_AIX_RDS_PROTO_C #define ofed_RDS_AIX_RDS_PROTO_C (ofed_BLOCK_00 + 0x14) pollution: ofed_RDS_AIX_RDS_SYSCTL_C #define ofed_RDS_AIX_RDS_SYSCTL_C (ofed_BLOCK_00 + 0x10) pollution: ofed_RDS_AIX_RDS_WIRE_TRACING_C #define ofed_RDS_AIX_RDS_WIRE_TRACING_C (ofed_BLOCK_00 + 0x29) pollution: ofed_RDS_BIND_C #define ofed_RDS_BIND_C (ofed_BLOCK_00 + 0x06) pollution: ofed_RDS_CONG_C #define ofed_RDS_CONG_C (ofed_BLOCK_00 + 0x07) pollution: ofed_RDS_CONNECTION_C #define ofed_RDS_CONNECTION_C (ofed_BLOCK_00 + 0x08) pollution: ofed_RDS_IB_C #define ofed_RDS_IB_C (ofed_BLOCK_00 + 0x17) pollution: ofed_RDS_IB_CM_C #define ofed_RDS_IB_CM_C (ofed_BLOCK_00 + 0x18) pollution: ofed_RDS_IB_RDMA_C #define ofed_RDS_IB_RDMA_C (ofed_BLOCK_00 + 0x25) pollution: ofed_RDS_IB_RECV_C #define ofed_RDS_IB_RECV_C (ofed_BLOCK_00 + 0x1b) pollution: ofed_RDS_IB_RING_C #define ofed_RDS_IB_RING_C (ofed_BLOCK_00 + 0x19) pollution: ofed_RDS_IB_SEND_C #define ofed_RDS_IB_SEND_C (ofed_BLOCK_00 + 0x1c) pollution: ofed_RDS_IB_STATS_C #define ofed_RDS_IB_STATS_C (ofed_BLOCK_00 + 0x1a) pollution: ofed_RDS_INFO_C #define ofed_RDS_INFO_C (ofed_BLOCK_00 + 0x09) pollution: ofed_RDS_LOOP_C #define ofed_RDS_LOOP_C (ofed_BLOCK_00 + 0x0a) pollution: ofed_RDS_MESSAGE_C #define ofed_RDS_MESSAGE_C (ofed_BLOCK_00 + 0x0b) pollution: ofed_RDS_PAGE_C #define ofed_RDS_PAGE_C (ofed_BLOCK_00 + 0x0c) pollution: ofed_RDS_RDMA_C #define ofed_RDS_RDMA_C (ofed_BLOCK_00 + 0x24) pollution: ofed_RDS_RECV_C #define ofed_RDS_RECV_C (ofed_BLOCK_00 + 0x0d) pollution: ofed_RDS_SEND_C #define ofed_RDS_SEND_C (ofed_BLOCK_00 + 0x0e) pollution: ofed_RDS_STATS_C #define ofed_RDS_STATS_C (ofed_BLOCK_00 + 0x0f) pollution: ofed_RDS_THREADS_C #define ofed_RDS_THREADS_C (ofed_BLOCK_00 + 0x11) pollution: ofed_RDS_TRANSPORT_C #define ofed_RDS_TRANSPORT_C (ofed_BLOCK_00 + 0x12) pollution: ofed_SDP_AIX_OFED_SOCKET_C #define ofed_SDP_AIX_OFED_SOCKET_C (ofed_BLOCK_01 + 0x0E) pollution: ofed_SDP_AIX_OFED_TIMER_C #define ofed_SDP_AIX_OFED_TIMER_C (ofed_BLOCK_01 + 0x10) pollution: ofed_SDP_AIX_SDP_CONFIG_C #define ofed_SDP_AIX_SDP_CONFIG_C (ofed_BLOCK_01 + 0x0C) pollution: ofed_SDP_AIX_SDP_PROC_C #define ofed_SDP_AIX_SDP_PROC_C (ofed_BLOCK_01 + 0x0F) pollution: ofed_SDP_AIX_SDP_PROTO_C #define ofed_SDP_AIX_SDP_PROTO_C (ofed_BLOCK_01 + 0x0D) pollution: ofed_SDP_SDP_BCOPY_C #define ofed_SDP_SDP_BCOPY_C (ofed_BLOCK_01 + 0x06) pollution: ofed_SDP_SDP_CMA_C #define ofed_SDP_SDP_CMA_C (ofed_BLOCK_01 + 0x0A) pollution: ofed_SDP_SDP_MAIN_C #define ofed_SDP_SDP_MAIN_C (ofed_BLOCK_01 + 0x05) pollution: ofed_SDP_SDP_PROC_C #define ofed_SDP_SDP_PROC_C (ofed_BLOCK_01 + 0x0B) pollution: ofed_SDP_SDP_RX_C #define ofed_SDP_SDP_RX_C (ofed_BLOCK_01 + 0x08) pollution: ofed_SDP_SDP_TX_C #define ofed_SDP_SDP_TX_C (ofed_BLOCK_01 + 0x09) pollution: ofed_SDP_SDP_ZCOPY_C #define ofed_SDP_SDP_ZCOPY_C (ofed_BLOCK_01 + 0x07) pollution: onckern_BLOCK_00 #define onckern_BLOCK_00 0x120 pollution: orig_xmem #define orig_xmem u2._orig_xmem pollution: paud_BLOCK_00 #define paud_BLOCK_00 0x128 pollution: pci4758_BLOCK_00 #define pci4758_BLOCK_00 0x130 pollution: pcibatm_BLOCK_00 #define pcibatm_BLOCK_00 0x138 pollution: pcibent_BLOCK_00 #define pcibent_BLOCK_00 0x140 pollution: pciccmdd_BLOCK_00 #define pciccmdd_BLOCK_00 0x148 pollution: pcichatm_BLOCK_00 #define pcichatm_BLOCK_00 0x150 pollution: pcictok_BLOCK_00 #define pcictok_BLOCK_00 0x158 pollution: pcient_BLOCK_00 #define pcient_BLOCK_00 0x160 pollution: pcigoent_BLOCK_00 #define pcigoent_BLOCK_00 0x168 pollution: pcigxent_BLOCK_00 #define pcigxent_BLOCK_00 0x170 pollution: pciiga_BLOCK_00 #define pciiga_BLOCK_00 0x178 pollution: pcijatm_BLOCK_00 #define pcijatm_BLOCK_00 0x180 pollution: pcilibrrhba_BLOCK_00 #define pcilibrrhba_BLOCK_00 0x908 pollution: pcilncent_BLOCK_00 #define pcilncent_BLOCK_00 0x988 pollution: pcilncent_BLOCK_01 #define pcilncent_BLOCK_01 0x989 pollution: pcilncent_BLOCK_02 #define pcilncent_BLOCK_02 0x98A pollution: pcimga_BLOCK_00 #define pcimga_BLOCK_00 0x188 pollution: pcimlxcent_BLOCK_00 #define pcimlxcent_BLOCK_00 0x9C8 pollution: pcimlxcent_BLOCK_01 #define pcimlxcent_BLOCK_01 0x9C9 pollution: pcimlxent_BLOCK_00 #define pcimlxent_BLOCK_00 0x9B0 pollution: pcimlxent_BLOCK_01 #define pcimlxent_BLOCK_01 0x9B1 pollution: pcimlxent_BLOCK_02 #define pcimlxent_BLOCK_02 0x9B2 pollution: pcimlxent_BLOCK_03 #define pcimlxent_BLOCK_03 0x9B3 pollution: pcimlxent_BLOCK_04 #define pcimlxent_BLOCK_04 0x9B4 pollution: pcimlxent_BLOCK_05 #define pcimlxent_BLOCK_05 0x9B5 pollution: pcimlxent_BLOCK_06 #define pcimlxent_BLOCK_06 0x9B6 pollution: pcimlxent_BLOCK_07 #define pcimlxent_BLOCK_07 0x9B7 pollution: pcimlxent_BLOCK_08 #define pcimlxent_BLOCK_08 0x9B8 pollution: pciphxent_BLOCK_00 #define pciphxent_BLOCK_00 0x190 pollution: pciraid_BLOCK_00 #define pciraid_BLOCK_00 0x198 pollution: pcirr2ent_BLOCK_00 #define pcirr2ent_BLOCK_00 0x920 pollution: pcirr2ent_BLOCK_01 #define pcirr2ent_BLOCK_01 0x921 pollution: pcirr2ent_BLOCK_02 #define pcirr2ent_BLOCK_02 0x922 pollution: pcirr2ent_BLOCK_03 #define pcirr2ent_BLOCK_03 0x923 pollution: pcirr2ent_BLOCK_04 #define pcirr2ent_BLOCK_04 0x924 pollution: pcirr2ent_BLOCK_05 #define pcirr2ent_BLOCK_05 0x925 pollution: pcirr2ent_BLOCK_06 #define pcirr2ent_BLOCK_06 0x926 pollution: pcirr2ent_BLOCK_07 #define pcirr2ent_BLOCK_07 0x927 pollution: pcirr2ent_BLOCK_08 #define pcirr2ent_BLOCK_08 0x928 pollution: pcirrent_BLOCK_00 #define pcirrent_BLOCK_00 0x910 pollution: pcirrhba_BLOCK_00 #define pcirrhba_BLOCK_00 0x900 pollution: pcirrhba_BLOCK_01 #define pcirrhba_BLOCK_01 0x901 pollution: pcirrhba_BLOCK_02 #define pcirrhba_BLOCK_02 0x902 pollution: pcirrhba_BLOCK_03 #define pcirrhba_BLOCK_03 0x903 pollution: pcirrhba_BLOCK_04 #define pcirrhba_BLOCK_04 0x904 pollution: pcirrhba_BLOCK_05 #define pcirrhba_BLOCK_05 0x905 pollution: pcirrhba_BLOCK_06 #define pcirrhba_BLOCK_06 0x906 pollution: pcirrhba_BLOCK_07 #define pcirrhba_BLOCK_07 0x907 pollution: pciscent_BLOCK_00 #define pciscent_BLOCK_00 0x1A0 pollution: pciscsi_BLOCK_00 #define pciscsi_BLOCK_00 0x1A8 pollution: pcitok_BLOCK_00 #define pcitok_BLOCK_00 0x1B0 pollution: pcivent_BLOCK_00 #define pcivent_BLOCK_00 0x1B8 pollution: peddd_BLOCK_00 #define peddd_BLOCK_00 0x1C0 pollution: perfstat_BLOCK_00 #define perfstat_BLOCK_00 0x1C8 pollution: pmapi_BLOCK_00 #define pmapi_BLOCK_00 0x1D0 pollution: prexflags #define prexflags u1._prexflags pollution: procfs_BLOCK_00 #define procfs_BLOCK_00 0x1D8 pollution: pseudo_AF_XTP #define pseudo_AF_XTP 19 pollution: rcm_BLOCK_00 #define rcm_BLOCK_00 0x1E0 pollution: recvfrom #define recvfrom nrecvfrom pollution: recvmsg #define recvmsg nrecvmsg pollution: rem_addr #define rem_addr u1._subspace_id pollution: rem_liobn #define rem_liobn uaddr pollution: rem_size #define rem_size u2._subspace_id2 pollution: rlist #define rlist uaddr pollution: rm_leaf #define rm_leaf rm_rmu.rmu_leaf pollution: rm_mask #define rm_mask rm_rmu.rmu_mask pollution: rn_dupedkey #define rn_dupedkey rn_u.rn_leaf.rn_Dupedkey pollution: rn_key #define rn_key rn_u.rn_leaf.rn_Key pollution: rn_l #define rn_l rn_u.rn_node.rn_L pollution: rn_mask #define rn_mask rn_u.rn_leaf.rn_Mask pollution: rn_off #define rn_off rn_u.rn_node.rn_Off pollution: rn_r #define rn_r rn_u.rn_node.rn_R pollution: rspcios_BLOCK_00 #define rspcios_BLOCK_00 0x1E8 pollution: rspcios_BLOCK_01 #define rspcios_BLOCK_01 0x1E9 pollution: rspcpal_BLOCK_00 #define rspcpal_BLOCK_00 0x1F0 pollution: rt_cost #define rt_cost rt_rmx.rmx_hopcount pollution: rt_key #define rt_key(r) ((struct sockaddr *)((r)->rt_nodes->rn_key)) pollution: rt_mask #define rt_mask(r) ((struct sockaddr *)((r)->rt_nodes->rn_mask)) pollution: rt_to_rtp #define rt_to_rtp(rt) ((struct rtentry_plus *)((char *)(rt) - sizeof(eye_catch8b_t))) pollution: rt_use #define rt_use rt_rmx.rmx_pksent pollution: s6_addr #define s6_addr u6_addr.u6_addr8 pollution: s6_addr16 #define s6_addr16 u6_addr.u6_addr16 pollution: s6_addr32 #define s6_addr32 u6_addr.u6_addr32 pollution: s6_addr8 #define s6_addr8 u6_addr.u6_addr8 pollution: sendmsg #define sendmsg nsendmsg pollution: sgadd_BLOCK_00 #define sgadd_BLOCK_00 0x1F8 pollution: shaent_BLOCK_00 #define shaent_BLOCK_00 0xAA2 pollution: shaent_BLOCK_01 #define shaent_BLOCK_01 0xAA3 pollution: sisadd_BLOCK_00 #define sisadd_BLOCK_00 0x200 pollution: sncrypt_BLOCK_00 #define sncrypt_BLOCK_00 0xAB0 pollution: sonoradd_BLOCK_00 #define sonoradd_BLOCK_00 0x208 pollution: ssaadapdd_BLOCK_00 #define ssaadapdd_BLOCK_00 0x210 pollution: ssadiskdd_BLOCK_00 #define ssadiskdd_BLOCK_00 0x218 pollution: stnfs_BLOCK_00 #define stnfs_BLOCK_00 0x21C pollution: subspace_id #define subspace_id u1._subspace_id pollution: subspace_id2 #define subspace_id2 u2._subspace_id2 pollution: sysalloc_BLOCK_00 #define sysalloc_BLOCK_00 0x518 pollution: sysalloc_BLOCK_01 #define sysalloc_BLOCK_01 0x519 pollution: sysalloc_BLOCK_02 #define sysalloc_BLOCK_02 0x51A pollution: sysalloc_BLOCK_03 #define sysalloc_BLOCK_03 0x51B pollution: sysalloc_BLOCK_04 #define sysalloc_BLOCK_04 0x51C pollution: syscu_BLOCK_00 #define syscu_BLOCK_00 0x890 pollution: sysdump_BLOCK_00 #define sysdump_BLOCK_00 0x220 pollution: syserrlg_BLOCK_00 #define syserrlg_BLOCK_00 0x228 pollution: sysient_BLOCK_00 #define sysient_BLOCK_00 0x230 pollution: sysios_BLOCK_00 #define sysios_BLOCK_00 0x238 pollution: sysios_C_caccel #define sysios_C_caccel 0xA01 pollution: sysios_C_caccelinit #define sysios_C_caccelinit 0xA00 pollution: sysios_C_caccelstat #define sysios_C_caccelstat 0xA03 pollution: sysios_C_caccelutil #define sysios_C_caccelutil 0xA02 pollution: sysios_C_selnotify #define sysios_C_selnotify 0xA80 pollution: sysios_N_nxgzip #define sysios_N_nxgzip 0x0A23 pollution: sysios_N_nxinit #define sysios_N_nxinit 0x0A21 pollution: sysios_N_nxserv #define sysios_N_nxserv 0x0A22 pollution: sysios_N_nxutil #define sysios_N_nxutil 0x0A20 pollution: sysipc_C_bsr_shm #define sysipc_C_bsr_shm 0x680 pollution: sysipc_C_shm_mem64 #define sysipc_C_shm_mem64 0x681 pollution: sysipc_H_kipc #define sysipc_H_kipc 0x240 pollution: sysj2_BLOCK_00 #define sysj2_BLOCK_00 0x248 pollution: sysj2_BLOCK_01 #define sysj2_BLOCK_01 0x249 pollution: sysj2_BLOCK_02 #define sysj2_BLOCK_02 0x24A pollution: sysj2_BLOCK_03 #define sysj2_BLOCK_03 0x24B pollution: sysj2_BLOCK_04 #define sysj2_BLOCK_04 0x24C pollution: sysj2_BLOCK_05 #define sysj2_BLOCK_05 0x24D pollution: sysj2_BLOCK_06 #define sysj2_BLOCK_06 0x24E pollution: sysj2_BLOCK_07 #define sysj2_BLOCK_07 0x24F pollution: sysldr_BLOCK_00 #define sysldr_BLOCK_00 0x250 pollution: syslfs_BLOCK_00 #define syslfs_BLOCK_00 0x258 pollution: sysmemcopy_C_memcopy #define sysmemcopy_C_memcopy 0xA10 pollution: sysml_BLOCK_00 #define sysml_BLOCK_00 0x508 pollution: sysml_BLOCK_01 #define sysml_BLOCK_01 0x509 pollution: sysmobip6_BLOCK_00 #define sysmobip6_BLOCK_00 0x260 pollution: sysnet_BLOCK_00 #define sysnet_BLOCK_00 0x268 pollution: sysnet_NETWORK_RAS_C #define sysnet_NETWORK_RAS_C 0x888 pollution: sysnet_NETWORK_RTEC_PRIV_H #define sysnet_NETWORK_RTEC_PRIV_H 0x880 pollution: sysnfs4_BLOCK_01 #define sysnfs4_BLOCK_01 0x601 pollution: sysnfs4_BLOCK_02 #define sysnfs4_BLOCK_02 0x602 pollution: sysnfs4_BLOCK_03 #define sysnfs4_BLOCK_03 0x603 pollution: sysnfs_BLOCK_00 #define sysnfs_BLOCK_00 0x600 pollution: sysnfs_BLOCK_04 #define sysnfs_BLOCK_04 0x604 pollution: sysnfs_BLOCK_05 #define sysnfs_BLOCK_05 0x605 pollution: sysnfs_BLOCK_06 #define sysnfs_BLOCK_06 0x606 pollution: sysnfs_BLOCK_07 #define sysnfs_BLOCK_07 0x607 pollution: syspfs_BLOCK_00 #define syspfs_BLOCK_00 0x270 pollution: sysproc_BLOCK_00 #define sysproc_BLOCK_00 0x278 pollution: sysproc_BLOCK_01 #define sysproc_BLOCK_01 0x279 pollution: sysproc_BLOCK_02 #define sysproc_BLOCK_02 0x27A pollution: sysproc_BLOCK_03 #define sysproc_BLOCK_03 0x27B pollution: sysproc_BLOCK_04 #define sysproc_BLOCK_04 0x27C pollution: sysproc_BLOCK_06 #define sysproc_BLOCK_06 0x27E pollution: sysproc_C_migrate #define sysproc_C_migrate 0x27F pollution: sysproc_C_tmm_except #define sysproc_C_tmm_except 0x27D pollution: sysras_BLOCK_00 #define sysras_BLOCK_00 0x280 pollution: sysras_BLOCK_01 #define sysras_BLOCK_01 0x281 pollution: sysras_BLOCK_02 #define sysras_BLOCK_02 0x282 pollution: sysras_BLOCK_03 #define sysras_BLOCK_03 0x283 pollution: sysras_BLOCK_04 #define sysras_BLOCK_04 0x284 pollution: sysras_BLOCK_05 #define sysras_BLOCK_05 0x285 pollution: sysras_BLOCK_06 #define sysras_BLOCK_06 0x286 pollution: sysras_BLOCK_07 #define sysras_BLOCK_07 0x287 pollution: sysras_BLOCK_08 #define sysras_BLOCK_08 0x520 pollution: sysras_BLOCK_09 #define sysras_BLOCK_09 0x521 pollution: sysras_BLOCK_10 #define sysras_BLOCK_10 0x522 pollution: syssec_BLOCK_00 #define syssec_BLOCK_00 0x288 pollution: syssi_BLOCK_00 #define syssi_BLOCK_00 0x290 pollution: sysspks_BLOCK_00 #define sysspks_BLOCK_00 0xAA0 pollution: syssrng_BLOCK_00 #define syssrng_BLOCK_00 0x298 pollution: systrace_BLOCK_00 #define systrace_BLOCK_00 0x2A0 pollution: sysuipc_MBUF_KERRNO_H #define sysuipc_MBUF_KERRNO_H 0x889 pollution: sysuipc_SOCKET_KERRNO_H #define sysuipc_SOCKET_KERRNO_H 0x886 pollution: sysvcm_BLOCK_00 #define sysvcm_BLOCK_00 0x620 pollution: sysvmm_BLOCK_00 #define sysvmm_BLOCK_00 0x2B0 pollution: sysvmm_BLOCK_01 #define sysvmm_BLOCK_01 0x2B1 pollution: sysvmm_BLOCK_02 #define sysvmm_BLOCK_02 0x2B2 pollution: sysvmm_BLOCK_03 #define sysvmm_BLOCK_03 0x2B3 pollution: sysvmm_BLOCK_04 #define sysvmm_BLOCK_04 0x2B4 pollution: sysvmm_BLOCK_05 #define sysvmm_BLOCK_05 0x2B5 pollution: sysvmm_C_userio #define sysvmm_C_userio 0x700 pollution: sysvmm_C_v_affin #define sysvmm_C_v_affin 0x735 pollution: sysvmm_C_v_alloc #define sysvmm_C_v_alloc 0x701 pollution: sysvmm_C_v_aptsubs #define sysvmm_C_v_aptsubs 0x702 pollution: sysvmm_C_v_cmem #define sysvmm_C_v_cmem 0x772 pollution: sysvmm_C_v_cmem_842bd #define sysvmm_C_v_cmem_842bd 0x77A pollution: sysvmm_C_v_cmem_c #define sysvmm_C_v_cmem_c 0x773 pollution: sysvmm_C_v_cmem_cmxd #define sysvmm_C_v_cmem_cmxd 0x774 pollution: sysvmm_C_v_compsubs #define sysvmm_C_v_compsubs 0x703 pollution: sysvmm_C_v_cpfsubs #define sysvmm_C_v_cpfsubs 0x704 pollution: sysvmm_C_v_diosubs #define sysvmm_C_v_diosubs 0x705 pollution: sysvmm_C_v_disksubs #define sysvmm_C_v_disksubs 0x706 pollution: sysvmm_C_v_dps #define sysvmm_C_v_dps 0x707 pollution: sysvmm_C_v_dr #define sysvmm_C_v_dr 0x708 pollution: sysvmm_C_v_exception #define sysvmm_C_v_exception 0x709 pollution: sysvmm_C_v_fragsubs #define sysvmm_C_v_fragsubs 0x70A pollution: sysvmm_C_v_freelist #define sysvmm_C_v_freelist 0x70B pollution: sysvmm_C_v_fssubs #define sysvmm_C_v_fssubs 0x70C pollution: sysvmm_C_v_galloc #define sysvmm_C_v_galloc 0x70D pollution: sysvmm_C_v_getsubs #define sysvmm_C_v_getsubs 0x70E pollution: sysvmm_C_v_getsubs1 #define sysvmm_C_v_getsubs1 0x70F pollution: sysvmm_C_v_getsubs64 #define sysvmm_C_v_getsubs64 0x710 pollution: sysvmm_C_v_interrupt #define sysvmm_C_v_interrupt 0x711 pollution: sysvmm_C_v_lgpg #define sysvmm_C_v_lgpg 0x712 pollution: sysvmm_C_v_lists #define sysvmm_C_v_lists 0x713 pollution: sysvmm_C_v_lookup #define sysvmm_C_v_lookup 0x714 pollution: sysvmm_C_v_lru #define sysvmm_C_v_lru 0x715 pollution: sysvmm_C_v_lrubylist #define sysvmm_C_v_lrubylist 0x716 pollution: sysvmm_C_v_lrulist #define sysvmm_C_v_lrulist 0x717 pollution: sysvmm_C_v_lruphys #define sysvmm_C_v_lruphys 0x718 pollution: sysvmm_C_v_map #define sysvmm_C_v_map 0x719 pollution: sysvmm_C_v_mapsubs #define sysvmm_C_v_mapsubs 0x71A pollution: sysvmm_C_v_misc64 #define sysvmm_C_v_misc64 0x76E pollution: sysvmm_C_v_mpsubs #define sysvmm_C_v_mpsubs 0x71B pollution: sysvmm_C_v_mvfork #define sysvmm_C_v_mvfork 0x71C pollution: sysvmm_C_v_numa #define sysvmm_C_v_numa 0x71D pollution: sysvmm_C_v_patch #define sysvmm_C_v_patch 0x71E pollution: sysvmm_C_v_pdtsubs #define sysvmm_C_v_pdtsubs 0x71F pollution: sysvmm_C_v_pfend #define sysvmm_C_v_pfend 0x720 pollution: sysvmm_C_v_pinsubs #define sysvmm_C_v_pinsubs 0x721 pollution: sysvmm_C_v_power_64 #define sysvmm_C_v_power_64 0x76B pollution: sysvmm_C_v_power_lpar #define sysvmm_C_v_power_lpar 0x76C pollution: sysvmm_C_v_protsubs #define sysvmm_C_v_protsubs 0x722 pollution: sysvmm_C_v_psgc #define sysvmm_C_v_psgc 0x723 pollution: sysvmm_C_v_putsubs #define sysvmm_C_v_putsubs 0x724 pollution: sysvmm_C_v_relsubs #define sysvmm_C_v_relsubs 0x725 pollution: sysvmm_C_v_scblist #define sysvmm_C_v_scblist 0x726 pollution: sysvmm_C_v_scbsubs #define sysvmm_C_v_scbsubs 0x727 pollution: sysvmm_C_v_segsubs #define sysvmm_C_v_segsubs 0x728 pollution: sysvmm_C_v_spaceok #define sysvmm_C_v_spaceok 0x729 pollution: sysvmm_C_v_stab_64 #define sysvmm_C_v_stab_64 0x769 pollution: sysvmm_C_v_stab_sslb #define sysvmm_C_v_stab_sslb 0x76A pollution: sysvmm_C_v_thrpgio #define sysvmm_C_v_thrpgio 0x72A pollution: sysvmm_C_v_trackp #define sysvmm_C_v_trackp 0x72B pollution: sysvmm_C_v_vtiol #define sysvmm_C_v_vtiol 0x809 pollution: sysvmm_C_v_wlm #define sysvmm_C_v_wlm 0x72C pollution: sysvmm_C_v_xptsubs #define sysvmm_C_v_xptsubs 0x72D pollution: sysvmm_C_vm_affin #define sysvmm_C_vm_affin 0x736 pollution: sysvmm_C_vm_aso #define sysvmm_C_vm_aso 0x779 pollution: sysvmm_C_vm_chlmb #define sysvmm_C_vm_chlmb 0x77B pollution: sysvmm_C_vm_ckrs #define sysvmm_C_vm_ckrs 0x72E pollution: sysvmm_C_vm_dps #define sysvmm_C_vm_dps 0x72F pollution: sysvmm_C_vm_map #define sysvmm_C_vm_map 0x730 pollution: sysvmm_C_vm_mmap #define sysvmm_C_vm_mmap 0x731 pollution: sysvmm_C_vm_numa #define sysvmm_C_vm_numa 0x732 pollution: sysvmm_C_vmaccel #define sysvmm_C_vmaccel 0x77C pollution: sysvmm_C_vmadjunct #define sysvmm_C_vmadjunct 0x777 pollution: sysvmm_C_vmadsp #define sysvmm_C_vmadsp 0x733 pollution: sysvmm_C_vmadsp64 #define sysvmm_C_vmadsp64 0x734 pollution: sysvmm_C_vmadsplock #define sysvmm_C_vmadsplock 0x775 pollution: sysvmm_C_vmadsputil #define sysvmm_C_vmadsputil 0x776 pollution: sysvmm_C_vmahafs #define sysvmm_C_vmahafs 0x76F pollution: sysvmm_C_vmcaccel #define sysvmm_C_vmcaccel 0x77D pollution: sysvmm_C_vmcleardata #define sysvmm_C_vmcleardata 0x737 pollution: sysvmm_C_vmcmem #define sysvmm_C_vmcmem 0x771 pollution: sysvmm_C_vmcreate #define sysvmm_C_vmcreate 0x738 pollution: sysvmm_C_vmdelete #define sysvmm_C_vmdelete 0x739 pollution: sysvmm_C_vmdevices #define sysvmm_C_vmdevices 0x73A pollution: sysvmm_C_vmdr #define sysvmm_C_vmdr 0x73B pollution: sysvmm_C_vmdump #define sysvmm_C_vmdump 0x73C pollution: sysvmm_C_vmforkcopy #define sysvmm_C_vmforkcopy 0x73D pollution: sysvmm_C_vmfwad #define sysvmm_C_vmfwad 0x73E pollution: sysvmm_C_vmgalloc #define sysvmm_C_vmgalloc 0x73F pollution: sysvmm_C_vmgetinfo #define sysvmm_C_vmgetinfo 0x740 pollution: sysvmm_C_vmint #define sysvmm_C_vmint 0x741 pollution: sysvmm_C_vmiowait #define sysvmm_C_vmiowait 0x742 pollution: sysvmm_C_vmkmodules #define sysvmm_C_vmkmodules 0x743 pollution: sysvmm_C_vmlimits #define sysvmm_C_vmlimits 0x744 pollution: sysvmm_C_vmloan #define sysvmm_C_vmloan 0x768 pollution: sysvmm_C_vmlrulist #define sysvmm_C_vmlrulist 0x745 pollution: sysvmm_C_vmlsa #define sysvmm_C_vmlsa 0x778 pollution: sysvmm_C_vmmakep #define sysvmm_C_vmmakep 0x746 pollution: sysvmm_C_vmmap #define sysvmm_C_vmmap 0x747 pollution: sysvmm_C_vmmisc #define sysvmm_C_vmmisc 0x748 pollution: sysvmm_C_vmmisc64 #define sysvmm_C_vmmisc64 0x749 pollution: sysvmm_C_vmmove #define sysvmm_C_vmmove 0x74A pollution: sysvmm_C_vmmove64 #define sysvmm_C_vmmove64 0x74B pollution: sysvmm_C_vmpattr #define sysvmm_C_vmpattr 0x74C pollution: sysvmm_C_vmperf #define sysvmm_C_vmperf 0x74D pollution: sysvmm_C_vmpgzero #define sysvmm_C_vmpgzero 0x77E pollution: sysvmm_C_vmpinsubs #define sysvmm_C_vmpinsubs 0x74E pollution: sysvmm_C_vmpool #define sysvmm_C_vmpool 0x74F pollution: sysvmm_C_vmproc #define sysvmm_C_vmproc 0x750 pollution: sysvmm_C_vmprotect #define sysvmm_C_vmprotect 0x751 pollution: sysvmm_C_vmpsize #define sysvmm_C_vmpsize 0x752 pollution: sysvmm_C_vmpspace #define sysvmm_C_vmpspace 0x753 pollution: sysvmm_C_vmpvlist #define sysvmm_C_vmpvlist 0x754 pollution: sysvmm_C_vmqmodify #define sysvmm_C_vmqmodify 0x755 pollution: sysvmm_C_vmras #define sysvmm_C_vmras 0x756 pollution: sysvmm_C_vmrelease #define sysvmm_C_vmrelease 0x757 pollution: sysvmm_C_vmrmmap #define sysvmm_C_vmrmmap 0x759 pollution: sysvmm_C_vmscan #define sysvmm_C_vmscan 0x759 pollution: sysvmm_C_vmsi #define sysvmm_C_vmsi 0x75A pollution: sysvmm_C_vmsi64k #define sysvmm_C_vmsi64k 0x75B pollution: sysvmm_C_vmsi_alloc #define sysvmm_C_vmsi_alloc 0x75C pollution: sysvmm_C_vmsi_common #define sysvmm_C_vmsi_common 0x75D pollution: sysvmm_C_vmsi_lgpage #define sysvmm_C_vmsi_lgpage 0x75E pollution: sysvmm_C_vmsi_rma #define sysvmm_C_vmsi_rma 0x75F pollution: sysvmm_C_vmthrpgio #define sysvmm_C_vmthrpgio 0x760 pollution: sysvmm_C_vmtimes #define sysvmm_C_vmtimes 0x761 pollution: sysvmm_C_vmtmm #define sysvmm_C_vmtmm 0x770 pollution: sysvmm_C_vmusage #define sysvmm_C_vmusage 0x762 pollution: sysvmm_C_vmwlm #define sysvmm_C_vmwlm 0x763 pollution: sysvmm_C_vmwlmbio #define sysvmm_C_vmwlmbio 0x764 pollution: sysvmm_C_vmwrite #define sysvmm_C_vmwrite 0x765 pollution: sysvmm_C_vmxmdbg #define sysvmm_C_vmxmdbg 0x766 pollution: sysvmm_C_vrme #define sysvmm_C_vrme 0x76D pollution: sysvmm_C_xmem #define sysvmm_C_xmem 0x767 pollution: sysvmm_H_mplock #define sysvmm_H_mplock 0x802 pollution: sysvmm_H_vm_map #define sysvmm_H_vm_map 0x805 pollution: sysvmm_H_vmcmem #define sysvmm_H_vmcmem 0x807 pollution: sysvmm_H_vminline #define sysvmm_H_vminline 0x806 pollution: sysvmm_H_vmlsa #define sysvmm_H_vmlsa 0x808 pollution: sysvmm_H_vmm_eyec #define sysvmm_H_vmm_eyec 0x800 pollution: sysvmm_H_vmmacs #define sysvmm_H_vmmacs 0x80A pollution: sysvmm_H_vmpool #define sysvmm_H_vmpool 0x804 pollution: sysvmm_H_vmpriv_misc #define sysvmm_H_vmpriv_misc 0x80B pollution: sysvmm_H_vmras #define sysvmm_H_vmras 0x801 pollution: sysvmm_H_vmwlm #define sysvmm_H_vmwlm 0x803 pollution: syswpar_BLOCK_00 #define syswpar_BLOCK_00 0x98B pollution: sysx327_BLOCK_00 #define sysx327_BLOCK_00 0x2B8 pollution: sysxaio_BLOCK_00 #define sysxaio_BLOCK_00 0x2C0 pollution: sysxaixif_BLOCK_00 #define sysxaixif_BLOCK_00 0x2C8 pollution: sysxarray_BLOCK_00 #define sysxarray_BLOCK_00 0x2D0 pollution: sysxatm_BLOCK_00 #define sysxatm_BLOCK_00 0x2D8 pollution: sysxbpf_BLOCK_00 #define sysxbpf_BLOCK_00 0x2E0 pollution: sysxcat_BLOCK_00 #define sysxcat_BLOCK_00 0x2E8 pollution: sysxcfs_BLOCK_00 #define sysxcfs_BLOCK_00 0x2F0 pollution: sysxcie_BLOCK_00 #define sysxcie_BLOCK_00 0x2F8 pollution: sysxcvfc_BLOCK_00 #define sysxcvfc_BLOCK_00 0x9E0 pollution: sysxcvfcp_BLOCK_00 #define sysxcvfcp_BLOCK_00 0x9E1 pollution: sysxdisk_BLOCK_00 #define sysxdisk_BLOCK_00 0x308 pollution: sysxdispgem_BLOCK_00 #define sysxdispgem_BLOCK_00 0x310 pollution: sysxdispsky_BLOCK_00 #define sysxdispsky_BLOCK_00 0x318 pollution: sysxdlc_BLOCK_00 #define sysxdlc_BLOCK_00 0x300 pollution: sysxdlpi_BLOCK_00 #define sysxdlpi_BLOCK_00 0x320 pollution: sysxdmx_BLOCK_00 #define sysxdmx_BLOCK_00 0x328 pollution: sysxdpmp_BLOCK_00 #define sysxdpmp_BLOCK_00 0x330 pollution: sysxemfc_BLOCK_00 #define sysxemfc_BLOCK_00 0x630 pollution: sysxemfcnvme_BLOCK_00 #define sysxemfcnvme_BLOCK_00 0x640 pollution: sysxemfcp_BLOCK_00 #define sysxemfcp_BLOCK_00 0x638 pollution: sysxent_BLOCK_00 #define sysxent_BLOCK_00 0x338 pollution: sysxentchan_BLOCK_00 #define sysxentchan_BLOCK_00 0x340 pollution: sysxewlm_BLOCK_00 #define sysxewlm_BLOCK_00 0x348 pollution: sysxfc_BLOCK_00 #define sysxfc_BLOCK_00 0x350 pollution: sysxfcp_BLOCK_00 #define sysxfcp_BLOCK_00 0x358 pollution: sysxfd_BLOCK_00 #define sysxfd_BLOCK_00 0x360 pollution: sysxfddi_BLOCK_00 #define sysxfddi_BLOCK_00 0x368 pollution: sysxfpga_BLOCK_00 #define sysxfpga_BLOCK_00 0x650 pollution: sysxfpga_BLOCK_01 #define sysxfpga_BLOCK_01 0x651 pollution: sysxfrca_BLOCK_00 #define sysxfrca_BLOCK_00 0x370 pollution: sysxide_BLOCK_00 #define sysxide_BLOCK_00 0x378 pollution: sysxinet_IPV4_KERRNO_H #define sysxinet_IPV4_KERRNO_H 0x881 pollution: sysxinet_UDP_KERRNO_H #define sysxinet_UDP_KERRNO_H 0x884 pollution: sysxinet_ipv6_IPV6_KERRNO_H #define sysxinet_ipv6_IPV6_KERRNO_H 0x882 pollution: sysxinet_sctp_SCTP_KERRNO_H #define sysxinet_sctp_SCTP_KERRNO_H 0x885 pollution: sysxinet_tcp_TCP_KERRNO_H #define sysxinet_tcp_TCP_KERRNO_H 0x883 pollution: sysxintf_BLOCK_00 #define sysxintf_BLOCK_00 0x398 pollution: sysxiocp_BLOCK_00 #define sysxiocp_BLOCK_00 0x3A0 pollution: sysxipfc_BLOCK_00 #define sysxipfc_BLOCK_00 0x3A8 pollution: sysxiscsi_sw_BLOCK_00 #define sysxiscsi_sw_BLOCK_00 0x3B0 pollution: sysxlce_BLOCK_00 #define sysxlce_BLOCK_00 0x3B8 pollution: sysxldbg_BLOCK_00 #define sysxldbg_BLOCK_00 0x3C0 pollution: sysxloop_BLOCK_00 #define sysxloop_BLOCK_00 0x91F pollution: sysxlvm_BLOCK_00 #define sysxlvm_BLOCK_00 0x3C8 pollution: sysxmpa_BLOCK_00 #define sysxmpa_BLOCK_00 0x3D0 pollution: sysxmpqp_BLOCK_00 #define sysxmpqp_BLOCK_00 0x3D8 pollution: sysxpciaudio_BLOCK_00 #define sysxpciaudio_BLOCK_00 0x3E0 pollution: sysxppp_BLOCK_00 #define sysxppp_BLOCK_00 0x3E8 pollution: sysxprnt_BLOCK_00 #define sysxprnt_BLOCK_00 0x3F0 pollution: sysxpse_BLOCK_00 #define sysxpse_BLOCK_00 0x3F8 pollution: sysxpty_BLOCK_00 #define sysxpty_BLOCK_00 0x400 pollution: sysxqfc_BLOCK_00 #define sysxqfc_BLOCK_00 0x408 pollution: sysxqfcp_BLOCK_00 #define sysxqfcp_BLOCK_00 0x410 pollution: sysxqliscsi_BLOCK_00 #define sysxqliscsi_BLOCK_00 0x418 pollution: sysxqlto_BLOCK_00 #define sysxqlto_BLOCK_00 0x420 pollution: sysxqos_QOS_KERRNO_H #define sysxqos_QOS_KERRNO_H 0x887 pollution: sysxramd_BLOCK_00 #define sysxramd_BLOCK_00 0x430 pollution: sysxrif_BLOCK_00 #define sysxrif_BLOCK_00 0x438 pollution: sysxs128_BLOCK_00 #define sysxs128_BLOCK_00 0x440 pollution: sysxscie_BLOCK_00 #define sysxscie_BLOCK_00 0x448 pollution: sysxsea_BLOCK_00 #define sysxsea_BLOCK_00 0x450 pollution: sysxses_BLOCK_00 #define sysxses_BLOCK_00 0x458 pollution: sysxsfw_BLOCK_00 #define sysxsfw_BLOCK_00 0x980 pollution: sysxsfw_BLOCK_01 #define sysxsfw_BLOCK_01 0x981 pollution: sysxsfw_BLOCK_02 #define sysxsfw_BLOCK_02 0x982 pollution: sysxsfw_BLOCK_03 #define sysxsfw_BLOCK_03 0x983 pollution: sysxsfw_BLOCK_04 #define sysxsfw_BLOCK_04 0x984 pollution: sysxsfw_BLOCK_05 #define sysxsfw_BLOCK_05 0x985 pollution: sysxsfw_BLOCK_06 #define sysxsfw_BLOCK_06 0x986 pollution: sysxsfw_BLOCK_07 #define sysxsfw_BLOCK_07 0x987 pollution: sysxsol_BLOCK_00 #define sysxsol_BLOCK_00 0x460 pollution: sysxtape_BLOCK_00 #define sysxtape_BLOCK_00 0x468 pollution: sysxtm_BLOCK_00 #define sysxtm_BLOCK_00 0x470 pollution: sysxtok_BLOCK_00 #define sysxtok_BLOCK_00 0x478 pollution: sysxts_BLOCK_00 #define sysxts_BLOCK_00 0x480 pollution: sysxtty_BLOCK_00 #define sysxtty_BLOCK_00 0x488 pollution: sysxudf_BLOCK_00 #define sysxudf_BLOCK_00 0x490 pollution: sysxusb_BLOCK_00 #define sysxusb_BLOCK_00 0x498 pollution: sysxusb_cdrom_BLOCK_00 #define sysxusb_cdrom_BLOCK_00 0x4A0 pollution: sysxusb_kbd_BLOCK_00 #define sysxusb_kbd_BLOCK_00 0x4A8 pollution: sysxusb_mse_BLOCK_00 #define sysxusb_mse_BLOCK_00 0x4B0 pollution: sysxusb_ufd_BLOCK_00 #define sysxusb_ufd_BLOCK_00 0x4B8 pollution: sysxvio_BLOCK_00 #define sysxvio_BLOCK_00 0x4C0 pollution: sysxvonc_BLOCK_00 #define sysxvonc_BLOCK_00 0x4C8 pollution: sysxx25_BLOCK_00 #define sysxx25_BLOCK_00 0x4D0 pollution: sysxxns_BLOCK_00 #define sysxxns_BLOCK_00 0x4D8 pollution: timerclear #define timerclear(tvp) (tvp)->tv_sec = (tvp)->tv_usec = 0 pollution: timercmp #define timercmp(tvp,fvp,cmp) ((tvp)->tv_sec cmp (fvp)->tv_sec || (tvp)->tv_sec == (fvp)->tv_sec && (tvp)->tv_usec cmp (fvp)->tv_usec) pollution: timerisset #define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec) pollution: tmssadd_BLOCK_00 #define tmssadd_BLOCK_00 0x4E0 pollution: uS_PER_SEC #define uS_PER_SEC (NS_PER_SEC / 1000) pollution: uS_PER_SECOND #define uS_PER_SECOND (1000000) pollution: vddrby_BLOCK_00 #define vddrby_BLOCK_00 0x4E8 pollution: vioent_BLOCK_00 #define vioent_BLOCK_00 0x4F0 pollution: vlan_BLOCK_00 #define vlan_BLOCK_00 0x4F8 pollution: vnic_BLOCK_00 #define vnic_BLOCK_00 0x929 pollution: vnic_BLOCK_01 #define vnic_BLOCK_01 0x92A pollution: vnic_BLOCK_02 #define vnic_BLOCK_02 0x92B pollution: vnic_BLOCK_03 #define vnic_BLOCK_03 0x92C pollution: vnic_BLOCK_04 #define vnic_BLOCK_04 0x92D pollution: vnic_BLOCK_05 #define vnic_BLOCK_05 0x92E pollution: vnic_BLOCK_06 #define vnic_BLOCK_06 0x92F pollution: vnic_BLOCK_07 #define vnic_BLOCK_07 0x930 pollution: vnicserver_BLOCK_00 #define vnicserver_BLOCK_00 0x9C6 pollution: vnicserver_BLOCK_01 #define vnicserver_BLOCK_01 0x9C7 pollution: vrtcore_BLOCK_00 #define vrtcore_BLOCK_00 0x9D0 pollution: vrtent_BLOCK_00 #define vrtent_BLOCK_00 0x9D8 pollution: vrtscsi_BLOCK_00 #define vrtscsi_BLOCK_00 0x9D4 pollution: wgadd_BLOCK_00 #define wgadd_BLOCK_00 0x500 pollution: xm_flag #define xm_flag _u.s.flag pollution: xm_version #define xm_version _u.s.version pollution: xmemat #define xmemat(vaddr,count,dp) xmattach(vaddr,count,dp,SYS_ADSPACE) pollution: xmemdt #define xmemdt(dp) xmdetach(dp)