/* IBM_PROLOG_BEGIN_TAG */ /* This is an automatically generated prolog. */ /* */ /* bos72Q src/bos/kernel/sys/dump.h 1.110.2.3 */ /* */ /* Licensed Materials - Property of IBM */ /* */ /* COPYRIGHT International Business Machines Corp. 1988,2019 */ /* All Rights Reserved */ /* */ /* US Government Users Restricted Rights - Use, duplication or */ /* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ /* */ /* IBM_PROLOG_END_TAG */ /* @(#)02 1.110.2.3 src/bos/kernel/sys/dump.h, sysdump, bos72Q, q2019_13A4 2/6/19 00:42:22 */ /* * FUNCTIONS: header file for system dumpfile formats */ #ifndef _H_DUMP #define _H_DUMP #include #include #include /* Defined to eliminate forward references. */ struct xmem; struct mbuf; /* For 64-bit, we need two general "cookies" to use as segment values - one * to indicate that this is part of the general kernel segment mapping, and * another to indicate that this is actually a real address. For 32-bit, we * already have a flag to indicate real addresses (D_REAL), but we need to * identify a dump area as being part of the general kernel segment mapping, * since the kernel heap now spans segments, etc. For binary compatibility, * the 32-bit "general" segment value will be 0. */ #define DUMP_GEN_SEGVAL32 ((uint)0) #define DUMP_GEN_SEGVAL64 ((u_longlong_t)-1L) #define DUMP_REAL_SEGVAL32 (uint)0x007fffff #define DUMP_REAL_SEGVAL64 ((u_longlong_t)-2L) #define DUMP_DUPMEM_SEGVAL ((u_longlong_t)-3L) #define DUMP_NONMEM_SEGVAL ((u_longlong_t)-4L) #ifdef _KERNEL #ifdef __64BIT__ #define DUMP_GEN_SEGVAL ((vmhandle_t)DUMP_GEN_SEGVAL64) #define DUMP_REAL_SEGVAL ((vmhandle_t)DUMP_REAL_SEGVAL64) #else /* !__64BIT__ */ #define DUMP_GEN_SEGVAL ((vmhandle_t)DUMP_GEN_SEGVAL32) #define DUMP_REAL_SEGVAL ((vmhandle_t)DUMP_REAL_SEGVAL32) #endif #else /* !_KERNEL */ #define DUMP_GEN_SEGVAL DUMP_GEN_SEGVAL32 /* DUMP_REAL_SEGVAL is DUMP_REAL_SEGVAL64 for backward compatibility. */ #define DUMP_REAL_SEGVAL DUMP_REAL_SEGVAL64 #endif /* _KERNEL */ /* * See if this is a DUMP_GEN_SEGVAL. * For 64-bit dumps, the only ones in 5.4 and beyond, the segval may be 0 * or DUMP_GEN_SEGVAL. */ #define DUMP_GEN_SEG(s) (!(s) || ((s) == DUMP_GEN_SEGVAL)) /* * XMEM NOTE: * The xmem pointer is only used in the unlimited dump table. * Thus you must use the unlimited dump table to dump a discontiguous * multi-segment area. * You may dump a contiguous, multi-segment, area in the 64-bit environment * by simply specifying the length, d_len, accordingly. */ /* * Except for the 32-bit dump, taken only by kernels prior to 5.4, this is * the data entry name length. */ #define CDT_ENTRY_NAMLEN 16 /* not valid for cdt_entry32 */ /* * The following structures are invariant dump entry definitions. */ struct cdt_entry64 { /* component dump table entry */ char d_name[CDT_ENTRY_NAMLEN];/* name of data area */ unsigned long long d_len; /* length of data area to be dumped */ __ptr64 d_ptr; /* offset of data area to be dumped */ unsigned long long __d_segval; /* segment value for d_ptr */ #ifdef __64BIT__ struct xmem * d_xmemp; /* see "XMEM NOTE" above. */ #else /* !__64BIT__ */ unsigned long long d_xmemp; /* see "XMEM NOTE" above. */ #endif }; struct cdt_entry32 { /* 32-bit component dump table entry */ char d_name[8]; /* name of data area to be dumped */ __ulong32_t d_len; /* length of data area to be dumped */ __cptr32 d_ptr; /* offset of data area to be dumped */ union { #ifdef __64BIT__ vmhandle32_t _d_segval; /* segment value for xmem operations */ __ptr32 d_xmemp; /* see "XMEM NOTE" above. */ #else /* !__64BIT__ */ vmhandle_t _d_segval; /* segment value for xmem operations */ struct xmem *d_xmemp; /* see "XMEM NOTE" above. */ #endif /* __64BIT__ */ } _d; }; /* * cdt_entry_vr is for dumping real memory by virtual or real address. * It is only valid for dump tables with the DMP_MAGIC_VR magic number. * It is also only valid in a 32-bit dump. */ struct cdt_entry_vr { /* dump table entry for v/r addresses*/ char d_name[CDT_ENTRY_NAMLEN]; /* name of data area */ uint d_len; /* length of data area to be dumped */ int d_addrflags; /* Address flags. */ union { struct { __cptr32 _d_ptr; /* data pointer */ #ifdef __64BIT__ union { vmhandle32_t _d_segval; /* segment id */ vmid32_t _d_vmid; /* segment id. */ } _ud; #else /* !__64BIT__ */ union { vmhandle_t _d_segval; /* segment id */ vmid_t _d_vmid; /* segment id. */ } _ud; #endif /* __64BIT__ */ } _d; unsigned long long _d_realaddr; /* real address */ } _u; }; #define d_realaddr _u._d_realaddr #define d_segval_v _u._d._ud._d_segval #define d_vmid_v _u._d._ud._d_vmid #define d_ptr_v _u._d._d_ptr /* * Flag definitions for d_addrflags. * All unused flag bits must be zero. */ #define D_REAL 0x1 /* The address is a real address. * if off, the address is virtual. */ #define D_VMID 0x2 /* The vmid is passed rather than the vmhandle. */ #ifdef __64BIT__ #define cdt_entry cdt_entry64 #define d_segval __d_segval #else /* !__64BIT__ */ #define cdt_entry cdt_entry32 /* Base dump table entry. */ #define d_segval _d._d_segval #define d_xmemdp d_segval #endif /* __64BIT__ */ struct cdt_head { int _cdt_magic; char _cdt_name[16]; /* component dump name */ int _cdt_len; /* length of component dump table */ }; /* * We use a different magic number for each dump table. * Note that cdt_entry_vr and associated structures is not * valid in 64-bit mode. * Note also that all magic numbers are available in either * mode so a dump reader can at least tell if it's a valid * dump. */ #define DMP_MAGIC_32 0xEEEEEEEE #define DMP_MAGIC_VR 0xEEEEEEEF #define DMP_MAGIC_64 0xEEEEEEED #define DMP_MAGIC_U32 0xEEEEEEEC #define DMP_MAGIC_U64 0xEEEEEEEB #define DMP_MAGIC_UD32 0xEEEEEEEA #define DMP_MAGIC_UD64 0xEEEEEEE9 #define DMP_MAGIC_RAS 0xEEEEEEE8 /* cdt_head_ras, in dump only */ #define DMP_MAGIC_RAS_U 0xEEEEEEE7 /* cdt_head_ras_u, in dump only */ #define DMP_MAGIC_UL 0xEEEEEEE6 #define DMP_MAGIC_UA 0xEEEEEEE5 #define DMP_MAGIC_N 0xEEEEEEE4 #define DMP_MAGIC_NU 0xEEEEEEE3 #define DMP_MAGIC_END 0xEEEEEEE0 /* Magic no. at the end of the dump. */ #ifdef __64BIT__ #define DMP_MAGIC DMP_MAGIC_64 #define DMP_MAGIC_U DMP_MAGIC_U64 #define DMP_MAGIC_UD DMP_MAGIC_UD64 #else /* !__64BIT__ */ #define DMP_MAGIC DMP_MAGIC_32 #define DMP_MAGIC_U DMP_MAGIC_U32 #define DMP_MAGIC_UD DMP_MAGIC_UD32 #endif /* __64BIT__ */ struct cdt0 { /* component dump table */ struct cdt_head _cdt_head; /* minus the variable length table */ }; struct cdt { /* component dump table */ struct cdt_head _cdt_head; struct cdt_entry cdt_entry[1]; /* component dump table entries */ }; /* * Component dump table which may contain real or virtual addresses. * This is only valid in 32-bit dumps. */ struct cdt_vr { struct cdt_head _cdt_head; struct cdt_entry_vr cdt_entry[1]; /* component dump table entries */ }; #define cdt_magic _cdt_head._cdt_magic #define cdt_name _cdt_head._cdt_name #define cdt_len _cdt_head._cdt_len /* * Header for an unlimited size dump table. * cdtu_magic must be DMP_MAGIC_U. * cdtu_nentries must be at least 1 when passed to dump. * It will be 0 in the dump, indicating an unlimited number of entries. * This header is the same size as cdt_head. * Note there are separate magic numbers for 32 or 64 bit dumps. */ struct cdt_head_u { int cdtu_magic; /* Set to DMP_MAGIC_U */ char cdtu_name[16]; /* component dump name */ int cdtu_nentries; /* Number of entries. */ }; /* Unlimited dump table data entry. */ struct cdt_entry_u { int du_magic; /* Set to DMP_MAGIC_UD */ char du_name[CDT_ENTRY_NAMLEN]; /* name of data area to be dumped */ unsigned long long du_len; /* length of data area to be dumped */ __ptr64 du_ptr; /* offset of data area to be dumped */ #ifdef _KERNEL #ifdef __64BIT__ vmhandle_t du_segval; /* segment value for d_ptr */ struct xmem * du_xmemp; /* Must be null if not used. */ #else /* !__64BIT__ (32-bit kernel) */ uint du_fill1; /* filler */ vmhandle_t du_segval; /* segment value for d_ptr */ uint du_fill2; /* filler */ struct xmem * du_xmemp; /* Must be null if not used. */ #endif #else /* !_KERNEL */ unsigned long long du_segval; /* 32/64 segment value for d_ptr */ unsigned long long du_xmemp; /* 32/64 xmem ptr. */ #endif }; /* Unlimited aliased dump table data entry. * Note that this will never be in a dump - * it will be converted to a cdt_entry_u * during live dump or system dump buffering. */ struct cdt_entry_ua { int dua_magic; /* Set to DMP_MAGIC_UA */ char dua_name[CDT_ENTRY_NAMLEN]; /* name of data area to be dumped */ ulong dua_len; /* length of data area to be dumped */ __ptr64 dua_ptr; /* actual location of data to dump */ __ptr64 dua_alias_ptr; /* location dua_ptr will represent in dump */ vmhandle_t dua_segval; /* segment value for dua_ptr */ vmhandle_t dua_alias_segval; /* seg val for dua_alias_ptr */ struct xmem *dua_xmemp; /* Must be null if not used */ }; #define ISDMPUA(cp)(((struct cdt_entry_ua *)(cp))->dua_magic == DMP_MAGIC_UA) /* Test for a real address in this unlimited table. */ #define ISADDRREALU32(ceu) ((ceu)->du_segval == DUMP_REAL_SEGVAL32) #define ISADDRREALU64(ceu) (CDT_U_SEGVAL(ceu)== DUMP_REAL_SEGVAL64) #ifdef __64BIT__ #define ISADDRREALU(ceu) ISADDRREALU64(ceu) #else /* !__64BIT__ */ #define ISADDRREALU(ceu) ISADDRREALU32(ceu) #endif /* __64BIT__ */ /* A cdt_u dump table must have at least one entry. */ struct cdt_u { struct cdt_head_u cdtu_head; struct cdt_entry_u cdtu_entry[1]; }; /* See if this is an unlimited dump table. */ #define ISDMPU32(cp) (((struct cdt_head_u *)(cp))->cdtu_magic == DMP_MAGIC_U32) #define ISDMPU64(cp) \ ((((struct cdt_head_u *)(cp))->cdtu_magic == DMP_MAGIC_U64) || \ (((struct cdt_head_ras_u *)(cp))->cdtru_magic == DMP_MAGIC_RAS_U) || \ (((struct cdt_nn_head_u *)(cp))->cdtnu_magic == DMP_MAGIC_NU)) #define ISDMPU3264(cp) (ISDMPU32(cp) || ISDMPU64(cp)) /* See if this component data entry is from an unlimited table. */ #define ISCEU32(cep) (((struct cdt_entry_u *)(cep))->du_magic == DMP_MAGIC_UD32) #define ISCEU64(cep) (((struct cdt_entry_u *)(cep))->du_magic == DMP_MAGIC_UD64) #define ISCEU3264(cep) (ISCEU32(cep) || ISCEU64(cep)) #ifdef __64BIT__ #define ISDMPU(cp) ISDMPU64(cp) #define ISCEU(cep) ISCEU64(cep) #else #define ISDMPU(cp) ISDMPU32(cp) #define ISCEU(cep) ISCEU32(cep) #endif #define ISDMPNN(cp) ((((struct cdt_nn_head *)(cp))->cdtn_magic == DMP_MAGIC_N) ||\ (((struct cdt_nn_head_u *)(cp))->cdtnu_magic == DMP_MAGIC_NU)) /* Validate the magic number, dump file only. */ #define VALID_DMP_MAGIC_32_64(n) (((n) == DMP_MAGIC_32) ||\ ((n) == DMP_MAGIC_64) ||\ ((n) == DMP_MAGIC_VR) ||\ ((n) == DMP_MAGIC_U32) ||\ ((n) == DMP_MAGIC_U64) ||\ ((n) == DMP_MAGIC_RAS) ||\ ((n) == DMP_MAGIC_RAS_U)) /* Only valid for use on a dump file. */ #define CDT_ENTRY_SIZE_32_64(comp_head) \ ( (((comp_head)->cdt_magic==DMP_MAGIC_64) || \ ((comp_head)->cdt_magic==DMP_MAGIC_RAS)) ? \ sizeof(struct cdt_entry64): \ ( (((comp_head)->cdt_magic==DMP_MAGIC_U32) || \ ((comp_head)->cdt_magic==DMP_MAGIC_U64)|| \ ((comp_head)->cdt_magic==DMP_MAGIC_RAS_U)) ? \ sizeof(struct cdt_entry_u): \ ( ((ISDMPVR(comp_head)) ? \ sizeof(struct cdt_entry_vr) :\ sizeof(struct cdt_entry32))) ) ) /* This doesn't include the unlimited dump table. */ #define NUM_ENTRIES_32_64(cp) \ (((cp)->cdt_len - sizeof(struct cdt_head)) /\ CDT_ENTRY_SIZE_32_64(cp) ) /* Address macros */ /* ISADDRREAL32, ADDR_VR32, and ISVMID must be used with a cdt_entry_vr. */ #define ISADDRREAL32(cde) ((cde)->d_addrflags & D_REAL) #define ADDR_VR32(cde) (ISADDRREAL32(cde)) ? (cde)->d_realaddr :\ (unsigned long long)(cde)->d_ptr_v #define ISVMID(cde) ((cde)->d_addrflags & D_VMID) #define ISADDRREAL64(cde) ((cde)->__d_segval == DUMP_REAL_SEGVAL64) #define ADDR_VR64(cde) (cde)->d_ptr #ifdef __64BIT__ #define ADDR_VR ADDR_VR64 #else #define ADDR_VR ADDR_VR32 #endif /* ISADDRREAL works for unlimited dump tables also. */ #ifdef __64BIT__ #define ISADDRREAL(cde) \ (ISCEU(cde)? ISADDRREALU((struct cdt_entry_u *)cde): ISADDRREAL64((struct cdt_entry *)cde)) #else #define ISADDRREAL(cde) \ (ISCEU(cde)? ISADDRREALU((struct cdt_entry_u *)cde): ISADDRREAL32((struct cdt_entry_vr *)cde)) #endif #ifdef __64BIT__ #define VALID_DMP_MAGIC(n) (((n) == DMP_MAGIC) || \ ((n) == DMP_MAGIC_U) ||\ ((n) == DMP_MAGIC_RAS) ||\ ((n) == DMP_MAGIC_RAS_U) ||\ ((n) == DMP_MAGIC_N) ||\ ((n) == DMP_MAGIC_NU)) #else /* !__64BIT__ */ #define VALID_DMP_MAGIC(n) (((n) == DMP_MAGIC) ||\ ((n) == DMP_MAGIC_U) ||\ ((n) == DMP_MAGIC_VR)) #endif /* __64BIT__ */ #define VALID_CDT_MAGIC(cp) VALID_DMP_MAGIC((cp)->cdt_magic) #define VALID_CDT_MAGIC_32_64(cp) VALID_DMP_MAGIC_32_64((cp)->cdt_magic) #define ISDMPVR(cp) ((cp)->cdt_magic == DMP_MAGIC_VR) /* See if it's a 32 or 64 bit dump. */ #define ISDMP32(cp) (ISDMPU32(cp) || ISDMPVR(cp) || \ ((cp)->cdt_magic == DMP_MAGIC_32)) #define ISDMP64(cp) (ISDMPU64(cp) || ISDMPRAS(cp) || \ ((cp)->cdt_magic == DMP_MAGIC_64)) #define ISDMPRASR(cp) \ (((struct cdt_head_ras *)(cp))->cdtr_magic == DMP_MAGIC_RAS) #define ISDMPRASU(cp) \ (((struct cdt_head_ras_u *)(cp))->cdtru_magic == DMP_MAGIC_RAS_U) #define ISDMPRAS(cp) (ISDMPRASR((struct cdt_head_ras *)(cp)) || \ ISDMPRASU((struct cdt_head_ras_u *)(cp))) /* cdt_entry size for this table */ #define CDT_ENTRY_SIZE(cp) (ISDMPVR(cp) ? sizeof(struct cdt_entry_vr) :\ (ISDMPU(cp)? sizeof(struct cdt_entry_u): \ sizeof(struct cdt_entry))) #define NUM_ENTRIES_OLD(cp) \ (((cp)->cdt_len - sizeof(struct cdt_head)) /\ CDT_ENTRY_SIZE(cp) ) #define CDTR_ENTRIES_LEN(cp) \ ((cp)->cdtr_len- \ offsetof(struct cdt_head_ras, cdtr_pathname)- \ (cp)->cdtr_pathlen) #define NUM_ENTRIES_RAS(cp) \ ISDMPRASU(cp) ? \ ((struct cdt_head_ras_u *)(cp))->cdtru_nentries: \ CDTR_ENTRIES_LEN((struct cdt_head_ras *)(cp))/ \ sizeof(struct cdt_entry64) /* * Get the number of entries regardless of the table type. * Note that for the unlimited dump table this value will not be valid * if the data has just been read, since the cdtu_nentries is 0 in the dump. */ #define NUM_ENTRIES(cp) \ ((ISDMPRAS(cp))? NUM_ENTRIES_RAS(cp) : \ (ISDMPNN(cp))? NUM_ENTRIES_NN(cp) : \ (ISDMPU(cp)? ((struct cdt_head_u *)(cp))->cdtu_nentries: \ NUM_ENTRIES_OLD((struct cdt *)(cp)))) /* This is not for an unlimited dump table. */ #define CDT_ENTRY_PTR(p, i) \ (ISDMPNN(p) ? (&((struct cdt_nn*)(p))->cdtn_entry[i]) : \ (&((struct cdt *)(p))->cdt_entry[i])) #define CDT_U_XMEM(p) \ ((ISDMPUA(p)) ? ((struct cdt_entry_ua*)(p))->dua_xmemp : \ (ISCEUL(p)) ? NULL : \ ((struct cdt_entry_u*) (p))->du_xmemp) #define CDT_U_NAME(p) \ ((ISDMPUA(p)) ? ((struct cdt_entry_ua*)(p))->dua_name : \ (ISCEUL(p)) ? ((struct cdt_entry_ul*)(p))->dul_name : \ ((struct cdt_entry_u*) (p))->du_name) #define CDT_U_LEN(p) \ ((ISDMPUA(p)) ? ((struct cdt_entry_ua*)(p))->dua_len : \ (ISCEUL(p)) ? ((struct cdt_entry_ul*)(p))->dul_len : \ ((struct cdt_entry_u*) (p))->du_len) #define CDT_U_PTR(p) \ (ISDMPUA(p) ? ((struct cdt_entry_ua*)(p))->dua_ptr : \ ((struct cdt_entry_u*) (p))->du_ptr) #define CDT_U_SEGVAL(p) \ (ISDMPUA(p) ? ((struct cdt_entry_ua*)(p))->dua_segval : \ ((struct cdt_entry_u*) (p))->du_segval) /* * Copy data from an old format, cdt_entry, to the new cdt_entry_vr * structure. Since there's not much data to move, we use this * method rather than using bcopy(). * * This is only valid for a cdt_entry32. * * Input: * oldp = pointer to a struct cdt_entry32. * newp = pointer to a struct cdt_entry_vr. */ #define CDT_OLD2NEW(oldp, newp) {\ int *iold = (int *)(oldp), *inew = (int *)(newp);\ /* d_name[0-3] */ *inew++ = *iold++; \ /* d_name[4-7] */ *inew++ = *iold++; \ /* d_name[8-11] */ *inew++ = 0; \ /* d_name[12-15] */ *inew++ = 0; \ /* d_len */ *inew++ = *iold++; \ /* set d_addrflags off */ *inew++ = 0; \ /* d_ptr */ *inew++ = *iold++; \ /* d_segval */ *inew = *iold;\ } /* * these definitions are mainly for formatting the raw dump data */ #ifndef _UW7_ typedef unsigned char bitmap_t; #endif #define DMP_MAXSEGS32 1 #define DMP_MAXSEGS64 4*1024*1024 /* Allow for 10**15 bytes. */ #define DMP_MAXPAGES32 ((size_t)((ulong)((ulong)DMP_MAXSEGS32 * 256 * 1024 * 1024) / PAGESIZE)) #define DMP_MAXPAGES64 ((size_t)((u_longlong_t)DMP_MAXSEGS64 * (256*1024*1024/PAGESIZE))) #ifdef __64BIT__ #define DMP_MAXSEGS DMP_MAXSEGS64 #define DMP_MAXPAGES DMP_MAXPAGES64 #else #define DMP_MAXSEGS DMP_MAXSEGS32 #define DMP_MAXPAGES DMP_MAXPAGES32 #endif /* BITS_BM is the number of bits per bitmap. DMP_BMBITS is the max number of * bits that can be written to a dump file per write operation (i.e. the * chunksize" of the bitmap). DMP_BMMASK is used on loop indices to change the * index to identify the bit within the current chunk, rather than the bit * within the whole bitmap. */ #define BITS_BM (8 * sizeof(bitmap_t)) /* must be a power of 2 */ #define DMP_BMBITS (512 * BITS_BM) /* must be a power of 2 */ #define DMP_BMMASK (512 * BITS_BM - 1) /* so that this works */ #define ISBITMAP(bm,bit) \ ( bm[(bit)/BITS_BM] & (1 << ((bit) % BITS_BM)) ) #define SETBITMAP(bm,bit) \ ( bm[(bit)/BITS_BM] |= (1 << ((bit) % BITS_BM)) ) #define BTOP32(addr) (((uint)(addr) & 0x0FFFFFFF) / PAGESIZE) #define BTOPR(addr) ((u_longlong_t)(addr) / PAGESIZE) #define BTOP_VR(f,addr) ((f) ? BTOPR(addr) : BTOP32(addr)) #define BTOP64(addr) (((u_longlong_t)(addr) & (SEGSIZE-1)) / PAGESIZE) #ifdef __64BIT__ #define BTOP(addr) BTOP64(addr) #else #define BTOP(addr) BTOP32(addr) #endif /* __64BIT__ */ #define DMPSEG32(x) ((uint)(x) & 0xF0000000) #define DMPSEG64(x) ((u_longlong_t)(x) & 0xFFFFFFFFF0000000LL) #define DMPLIM32(ptr,len) \ (uint)( DMPSEG32((ptr)+(len)-1) == DMPSEG32(ptr) ? \ ((uint)(ptr)+(len)-1) : 0x0FFFFFFF ) #define DMPLIMR(ptr,len) (u_longlong_t)((u_longlong_t)(ptr)+(len)-1) #define DMPLIM_VR(f,addr,len) \ ((f) ? (u_longlong_t)DMPLIMR(addr,len) : \ (u_longlong_t)DMPLIM32(addr,len)) #define DMPLIM64(ptr,len) (u_longlong_t)((u_longlong_t)(ptr)+(len)-1) #ifdef __64BIT__ #define DMPSEG(x) DMPSEG64(x) #define DMPLIM(ptr,len) DMPLIM64(ptr,len) #else /* !__64BIT__ */ #define DMPSEG(x) DMPSEG32(x) #define DMPLIM(ptr,len) DMPLIM32(ptr,len) #endif /* __64BIT__ */ #define NPAGES32(ptr,len) \ ( (len) == 0 ? 0 : BTOP32(DMPLIM32(ptr,len)) - BTOP32(ptr) + 1 ) #define NPAGES_VR(f,ptr,len) \ ( (len) == 0 ? 0 : \ (uint)(BTOP_VR(f,DMPLIM_VR(f,ptr,len)) - \ BTOP_VR(f,ptr) + 1) ) /* NPAGES_CDE32 must be used with a cdt_entry_vr structure * which can represent both real and virtual addresses */ #define NPAGES_CDE32(cep) \ NPAGES_VR(ISADDRREAL(cep), \ ADDR_VR32(cep), (cep)->d_len) /* A 64-bit dump data area can span segments. */ #define NPAGES64(ptr,len) \ ((len) == 0 ? 0 : \ ((u_longlong_t)(((uint)(ptr) & (PAGESIZE-1)) + (len) + PAGESIZE - 1) / PAGESIZE)) #define NPAGES_CDE64(cep) \ NPAGES64((cep)->d_ptr, (cep)->d_len) #define NPAGES_U(cep) \ NPAGES64((cep)->du_ptr, (cep)->du_len) #ifdef __64BIT__ #define NPAGES(ptr,len) NPAGES64(ptr,len) #define NPAGES_CDE(cep) (ISCEU(cep)? NPAGES_U((struct cdt_entry_u *)cep): \ NPAGES_CDE64((struct cdt_entry *)cep)) #else /* !__64BIT__ */ #define NPAGES(ptr,len) NPAGES32(ptr,len) /* NPAGES_CDE (32-bit) must be used with either a cdt_entry_vr or cdt_entry_u. */ #define NPAGES_CDE(cep) (ISCEU(cep)? NPAGES_U((struct cdt_entry_u *)cep): \ NPAGES_CDE32((struct cdt_entry_vr *)cep)) #endif /* __64BIT__ */ /* * # of pages: # of bitmap_t elements (bytes) * 0 0 * 1 1 * 8 1 * 9 2 * 16 2 * 17 3 */ #define BITMAPSIZE64(ptr,len) \ ( (NPAGES64(ptr,len) + BITS_BM - 1) / BITS_BM ) #define BITMAPSIZE_CDE64(cep) \ BITMAPSIZE64((cep)->d_ptr, (cep)->d_len) #define BITMAPSIZE_U(cep) \ BITMAPSIZE64((cep)->du_ptr, (cep)->du_len) #define BITMAPSIZE32(ptr,len) \ ( (NPAGES32(ptr,len) + BITS_BM - 1) / BITS_BM ) #define BITMAPSIZE_VR(f,ptr,len) \ ( (NPAGES_VR(f,ptr,len) + BITS_BM - 1) / BITS_BM ) /* BITMAPSIZE_CDE32 must be used with a cdt_entry_vr */ #define BITMAPSIZE_CDE32(cep) \ BITMAPSIZE_VR(ISADDRREAL(cep), \ ADDR_VR32(cep), (cep)->d_len) #ifdef __64BIT__ #define BITMAPSIZE(ptr,len) BITMAPSIZE64(ptr,len) #define BITMAPSIZE_CDE(cep) (ISCEU(cep)? BITMAPSIZE_U((struct cdt_entry_u *)cep): \ BITMAPSIZE_CDE64((struct cdt_entry *)cep)) #else /* !__64BIT__ */ #define BITMAPSIZE(ptr,len) BITMAPSIZE32(ptr,len) /* BITMAPSIZE_CDE (32-bit) must be used with either a cdt_entry_vr or cdt_entry_u. */ #define BITMAPSIZE_CDE(cep) (ISCEU(cep)? BITMAPSIZE_U((struct cdt_entry_u *)cep): \ BITMAPSIZE_CDE32((struct cdt_entry_vr *)cep)) #endif /* __64BIT__ */ #define DMPD_PRIM 1 /* must be 1 */ #define DMPD_SEC 2 /* must be 2 */ #define DMPD_AUTO 3 #define DMPD_PRIM_HALT 4 #define DMPD_SEC_HALT 5 /* * Return codes from the system dump. */ #define DMPDO_SUCCESS 0 #define DMPDO_DISABLED -1 #define DMPDO_PART -2 #define DMPDO_FAIL -3 #define DMPDO_IOERROR -4 /* * Thin server dump */ struct dump_control_block { unsigned int eyec; /* "DPCB" */ int version; /* 1 */ unsigned long long block_start; unsigned long long size; /* in 512 bytes block */ char pad[512 - 3 * sizeof (unsigned long long)]; }; #define DMPCB_EYEC 0x44504342 /* "DPCB" */ struct dumpdd { unsigned long long comp_size; /* compressed dump size */ unsigned long long real_size; time32_t timestamp; int status; int legacy; }; #ifdef _KERNEL #include #ifdef __cplusplus extern "C" { #endif /* * These defines stand for the reason that the system * is dumping. It was automatic, a key sequence was * entered, or the reset button was hit. */ #define AUTO_DUMP 0 #define KEYSEQ_DUMP 1 #define RESET_DUMP 2 struct dump_read { struct mbuf *dump_bufread; int wait_time; }; /* * Used by dump I/O routines to report status. */ struct dumpio_stat { unsigned int version; /* Version of this structure */ unsigned int status; /* returned status value */ }; #define DUMPIO_STAT_V1 1 /* dmp_add and dmp_ dmp_del take a function pointer. */ #ifdef __64BIT_KERNEL typedef struct cdt *((*__CDTFUNC)(int, void *)); #else typedef struct cdt *((*__CDTFUNC)()); #endif /* Note: the dmp_add_buffer service allows dump routines to share * a temporary buffer for staging large quantities of data that are * not directly "dumpable". They must specify the size of buffer * they need via the bufsize parameter. These routines will be * invoked with a pointer to the buffer that they can use. Note that * these routines must be capable of being called twice with the "1" * parameter, and must be able to copy the data twice, so that they can * be invoked a second time in case of a dump device failure and a * failover to the secondary device. * * It is now recommended that dmp_ctl() be used instead of dmp_add(), * dmp_add_buffer() and dmp_del(). */ #if defined(__64BIT_KERNEL) || defined(__FULL_PROTO) extern void dmp_prinit(int dmp_proto, void *proto_info); extern int dmp_add_buffer(__CDTFUNC func, size_t bufsize); extern int dmp_add(__CDTFUNC func); extern int dmp_del(__CDTFUNC func); extern void dmp_errlog(kerrno_t kerrno, dev_t dev, long dword); extern void dmp_trchk0(ulong_t); extern void dmp_trchk1(ulong_t, ulong_t); extern void dmp_trchk2(ulong_t, ulong_t, ulong_t); extern void dmp_trchk3(ulong_t, ulong_t, ulong_t, ulong_t); extern void dmp_trchk4(ulong_t, ulong_t, ulong_t, ulong_t, ulong_t); extern void dmp_trchk5(ulong_t, ulong_t, ulong_t, ulong_t, ulong_t, ulong_t); #define DMP_TRCHK0(hkwd) #define DMP_TRCHK1(hkwd, d1) #define DMP_TRCHK2(hkwd, d1, d2) #define DMP_TRCHK3(hkwd, d1, d2, d3) #define DMP_TRCHK4(hkwd, d1, d2, d3, d4) #define DMP_TRCHK5(hkwd,d1, d2, d3, d4, d5) #endif /* Dump Routine failures data. */ struct __rtnf { ulong rv; /* error code. */ ulong vaddr; /* address. */ vmhandle_t handle; /* handle */ }; /* dmp_ctl invocation. */ typedef void *((*__CDTFUNCENH)(int op, void *buf)); #define EXNAMESIZE 128 /* Record dump routine failures here. */ #define DMPF_MAX 4 #define MSTPRESENT -2 #define NOMST -3 struct dmpf { uint id; /* Number of entries */ struct dfail { __CDTFUNCENH f; struct __rtnf rtnf; ulong mst_flag; struct kmstsave mst; char ldname[EXNAMESIZE]; } dfail[DMPF_MAX]; }; #define dmpfd_rv rtnf.rv #define dmpfd_vaddr rtnf.vaddr #define dmpfd_handle rtnf.handle struct dmpctl_data { int dmpc_magic; /* magic number */ int dmpc_flags; /* dump routine flags. */ __CDTFUNCENH dmpc_func; union { u_longlong_t bsize; /* Global buffer size requested. */ struct __rtnf rtnf; } dmpc_u; }; #define DMPC_MAGIC1 0xdcdcdc01 #define DMPC_MAGIC DMPC_MAGIC1 #define dmpc_bsize dmpc_u.bsize #define dmpcf_rv dmpc_u.rtnf.rv #define dmpcf_vaddr dmpc_u.rtnf.vaddr #define dmpcf_handle dmpc_u.rtnf.handle #ifdef _NO_PROTO extern int dmp_ctl(); #else extern int dmp_ctl(int op, struct dmpctl_data *parmp); #endif /* dmp_ctl operations. */ #define DMPCTL_ADD 1 #define DMPCTL_DEL 2 #define DMPCTL_RTNFAILURE 3 /* dump routine failure */ /* * dmpc_flag values. * The CALL_ON_RESTART value is set if the routine should be called each time * the dump is restarted. It must be set if the GLOBAL_BUFFER flag is set. * It must also be set if the routine returns an unlimited dump table. * The GLOBAL_BUFFER flag is set if the routine uses global buffer space. * The dmpc_bsize value must also be set to the number of bytes being * requested. This value may not exceed DMPBUF_MAX. */ #define DMPFUNC_CALL_ON_RESTART 0x1 #define DMPFUNC_GLOBAL_BUFFER 0x2 #define DMPFUNC_LEGACY_CRITICAL 0x4 #define DMPFUNC_RETRY 0x8 #define DMPFUNC_SERIALIO 0x10 #define DMPFUNC_CDT_SKIP 0X20 /* Operations passed to dump routines. */ #define DMPRTN_START 1 #define DMPRTN_DONE 2 #define DMPRTN_AGAIN 3 #define DMPRTN_ESTIMATE 4 #define DMPRTN_RETRY 5 /* Max retries for callback retry on error. */ /* ie, original failure + two retries per callback. */ #define MAX_CBR 3 /* * Dump size estimate type. * A dump routine, added with dmp_ctl(), must return a pointer to * dmp_sizeest_t when requested to provide an estimate. */ typedef unsigned long long dmp_sizeest_t; /* Dump device buffer size query structure. */ struct dmp_query { size_t min_tsize; size_t max_tsize; }; /* minidump error log entry types */ struct minidump_log { struct err_rec0 erec; char minidump_buf[ERR_REC_MAX]; }; struct minidump_err_log { struct err_rec0 erec; int error_code; }; struct minidump_info_log { struct err_rec0 erec; int op_code; }; #ifdef _KERNSYS extern int dmp_do(int dmptype, int reason); extern int dmp_do_excp(int dmptype, int reason, int excp_code); #endif /* _KERNSYS */ #ifdef __cplusplus } #endif #endif /* _KERNEL */ #ifdef __cplusplus extern "C" { #endif /* Dump levels for system and live dump */ enum { CD_LEVEL_0, CD_LEVEL_1, CD_LEVEL_2, CD_LEVEL_3, CD_LEVEL_4, CD_LEVEL_5, CD_LEVEL_6, CD_LEVEL_7, CD_LEVEL_8, CD_LEVEL_9 }; #define CD_LVL_MINIMAL CD_LEVEL_1 #define CD_LVL_NORMAL CD_LEVEL_3 #define CD_LVL_DETAIL CD_LEVEL_7 #define CD_LVL_DEFAULT CD_LVL_NORMAL #define CDTR_VERS 0 #define CDTRU_VERS 0 /* * Component dump table headers containing the component full path name. * Note that these headers can be processed by 32 and 64-bit applications. */ struct cdt_head_ras_h { int cdtrh_magic; /* set to DMP_MAGIC_RAS */ int cdtrh_vers; /* set to CDTR_VERS */ int cdtrh_len; /* length of component dump table */ int cdtrh_pathlen; /* path name length */ }; /* flexible declaration */ struct cdt_head_ras { struct cdt_head_ras_h cdtr_h; char cdtr_pathname[];/* variable length path name */ }; #define cdtr_magic cdtr_h.cdtrh_magic #define cdtr_vers cdtr_h.cdtrh_vers #define cdtr_len cdtr_h.cdtrh_len #define cdtr_pathlen cdtr_h.cdtrh_pathlen /* Unlimited table */ struct cdt_head_ras_uh { int cdtruh_magic; /* set to DMP_MAGIC_RAS_U */ int cdtruh_vers; /* set to CDTRU_VERS */ int cdtruh_nentries; /* Number of entries. */ int cdtruh_pathlen; /* path name length */ }; struct cdt_head_ras_u { struct cdt_head_ras_uh cdtru_h; char cdtru_pathname[]; /* variable length path name */ }; #define cdtru_magic cdtru_h.cdtruh_magic #define cdtru_vers cdtru_h.cdtruh_vers #define cdtru_nentries cdtru_h.cdtruh_nentries #define cdtru_pathlen cdtru_h.cdtruh_pathlen #define CDTR_VERS1 0x0 #define XMEMP_REAL -1 #ifdef __64BIT_KERNEL /* * This is used for the system dump estimate. * It applies to components registered via the component infrastructure. */ typedef struct sysdump_estimate { short se_eyec; short se_vers; dmp_lvl_t se_lvl; /* The level at which to estimate */ dmp_sizeest_t se_value; /* estimate set by callback */ } sysdump_estimate_t; #define EYEC_SE __EYEC4('s','e','s','t') /* sest */ #define SE_VERS1 0 /* version */ #define DMP_WKSZ 256 /* dump work area size */ /* * This structure is passed to a callback when it is to dump its data for a * live dump, RASCD_SDMP_START. */ typedef struct sdmp_start { eye_catch4b_t sdmpst_eyec; int sdmpst_vers; /* version */ int sdmpst_flags; /* type flags */ dmp_lvl_t sdmpst_lvl; /* level at which to dump */ size_t sdmpst_plen; /* parameters length */ char *sdmpst_parms; /* passed parameters */ void *sdmpst_buffer; /* staging buffer if requested */ size_t sdmpst_bufsz; /* size of staging buffer */ void *sdmpst_table; /* dump table ptr set by callback */ char sdmpst_wk[DMP_WKSZ]; /* Work area */ eye_catch4b_t sdmpst_eyec2; /* for integrity check */ } sdmp_start_t; #define EYEC_SDMPST __EYEC4('s','d','s','t') /* sdst */ #define SDMPST_VERS1 0 /* version */ #define INVALID_SDMPST_PTR INVALID_PTR((int)EYEC_SDMPST) #endif /* * cdt headers for use by components registered in the component * infrastructure. */ struct cdt_nn_head { int cdtn_magic; int cdtn_len; /* length of component dump table */ }; struct cdt_nn { struct cdt_nn_head _cdt_nn_head; struct cdt_entry cdtn_entry[1]; }; /* Unlimited dump table header. */ struct cdt_nn_head_u { int cdtnu_magic; /* Set to DMP_MAGIC_NU */ int cdtnu_nentries; /* Number of entries. */ }; struct cdt_nn_u { struct cdt_nn_head_u _cdt_nn_head_u; struct cdt_entry_u cdtnu_entry[1]; }; #define ISDMPNNU(cp)(((struct cdt_nn_head_u *)(cp))->cdtnu_magic == DMP_MAGIC_NU) #define NUM_ENTRIES_NN(cp) \ (ISDMPNNU(cp) ? \ ((struct cdt_nn_u*)(cp))->_cdt_nn_head_u.cdtnu_nentries: \ (((struct cdt_nn*)(cp))->_cdt_nn_head.cdtn_len - \ sizeof(struct cdt_nn_head)) / sizeof(struct cdt_entry)) /* * Unlimited dump table entry to dump a discontiguous list of elements. * This may be used in both the system and live dump. * dul_entry is used to specify the elements' addresses. */ struct dul_entry { #ifdef __64BIT__ vmhandle_t dle_vmhandle; /* vmid */ #else u_longlong_t dle_vmhandle; /* vmid */ #endif __ptr64 dle_ptr; /* offset/address */ }; /* Return TRUE if dul_entry is the end indicator. */ #define DMP_DULENTRY_KEY 0x444d50554cULL #define DMP_DULENTRY_FINAL(_d) \ ((((_d)->dle_vmhandle == INVALID_PTR64(DMP_DULENTRY_KEY)) && \ (((unsigned long long)(_d)->dle_ptr) == INVALID_PTR64(DMP_DULENTRY_KEY)))?1 :0) struct cdt_entry_ul { int dul_magic; /* eyecatcher */ char dul_name[CDT_ENTRY_NAMLEN]; /* name applied to all entries */ int dul_nentries; /* # entries */ unsigned long long dul_len; /* length of all entries */ struct dul_entry dul_entry[1]; /* element addresses */ /* element addresses */ }; #define ISCEUL(cp) (((struct cdt_entry_ul *)(cp))->dul_magic == DMP_MAGIC_UL) #define ISADDRREALUL(cep,i) \ (((struct cdt_entry_ul*)cep)->dul_entry[i].dle_vmhandle == \ DUMP_REAL_SEGVAL64) #define DMP_DUL_SIZE(n) (offsetof(struct cdt_entry_ul, dul_entry) + \ (n)*sizeof(struct dul_entry)) #if (defined _RAS_INTERNAL) || (defined _KERNEL) /* providing Components and parameters */ /* * dmp_compspec flags * If changing or adding any of these flags, update DCF_MASK and __dcf_descr. */ #define DCF_MASK 0xFC00000001F1F3FFLL /* If none of these are set, the component is dumped at its current level. */ #define DCF_LEVEL_MASK 0x3ffLL #define DCF_LEVEL_SHIFT 0 #define DCF_LEVEL0 0x1LL #define DCF_LEVEL1 0x2LL #define DCF_LEVEL2 0x4LL #define DCF_LEVEL3 0x8LL #define DCF_LEVEL4 0x10LL #define DCF_LEVEL5 0x20LL #define DCF_LEVEL6 0x40LL #define DCF_LEVEL7 0x80LL #define DCF_LEVEL8 0x100LL #define DCF_LEVEL9 0x200LL #define DCF_MINIMAL DCF_LEVEL1 #define DCF_NORMAL DCF_LEVEL3 #define DCF_DETAIL DCF_LEVEL7 /* Component type flags */ #define DCF_COMPTYPE_MASK 0x1f000LL #define DCF_PSEUDO 0x1000LL /* pseudo-component */ #define DCF_BYPNAME 0x2000LL /* spec by name */ #define DCF_BYLNAME 0x4000LL /* spec by logical alias */ #define DCF_BYTYPE 0x8000LL /* spec by type/subtype */ #define DCF_BYCB 0x10000LL /* spec by ras_block_t */ /* misc. flags */ #define DCF_FAILING 0x100000LL /* failing component */ #define DCF_FIRST 0x200000LL /* dump first */ #define DCF_KEYWORD 0x400000LL /* keyword parameters given */ #define DCF_LONG 0x800000LL /* Pseudo-comp parms, 2 longs */ #define DCF_UNIQUE 0x1000000LL /* pseudo-comp must be unique */ /* These flags are for internal use only. */ #define DCF_MOREDATA 0x0400000000000000LL /* Component set LDPF_MOREDATA */ #define DCF_NEEDSPUT 0x0800000000000000LL /* Component needs rasp_put */ #define DCF_PREPARED 0x1000000000000000LL /* Component got a prepare cmd */ #define DCF_START_BAD 0x2000000000000000LL /* Component wrecked start struct*/ #define DCF_PREPARE_BAD 0x4000000000000000LL /* Component wrecked prep struct */ #define DCF_FINISH 0x8000000000000000LL /* RASCD_LDMP_FINISH needed */ /* * dmp_extid_t is returned by dmp_compspec to be used with dmp_compext when * providing additional component parameters. */ typedef long dmp_extid_t; extern kerrno_t dmp_compspec(long flags, long comp, void *anchor, dmp_extid_t *extid, ...); extern kerrno_t dmp_compext(dmp_extid_t extid, ...); /* dmp_context: function to dump system context */ extern kerrno_t dmp_context( long flags, /* See the DCF_ flags in dump.h */ void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ char *name, /* unused here */ long ctx_type, /* See the DMP_CTX_* flags in dump.h */ long p2); /* Parameter dependent on ctx_type */ /* dmp_context flags */ #define DMP_CTX_MASK 0x7F /* Change this if adding a new DMP_CTX_* */ #define DMP_CTX_CUR 0x1 /* Dump the current context */ #define DMP_CTX_PREV 0x2 /* Dump the previous context */ #define DMP_CTX_SPEC 0x4 /* Dump the specified context */ #define DMP_CTX_RWA 0x8 /* Dump the context for a recovery work area */ #define DMP_CTX_BID 0x10 /* Dump the context for a CPU bind ID */ #define DMP_CTX_LCPUID 0x20 /* Dump the context for a CPU logical ID */ #define DMP_CTX_TID 0x40 /* Dump the context for a thread */ /* Flag that indicates to the dump the MST chain. * Valid only with DMP_CTX_CUR/PREV/SPEC/RWA/BID/LCPUID. * For instance, if DMP_CTX_CUR|DMP_CTX_CHAIN is specified, detailed information * on the current context will be dumped along with minimal (register state, * stack trace) of all other MSTs. */ #define DMP_CTX_CHAIN 0x8000000000000000ll #define DMP_CTX_CHAIN_MASK (DMP_CTX_CHAIN | DMP_CTX_CUR |\ DMP_CTX_PREV | DMP_CTX_SPEC | DMP_CTX_RWA |\ DMP_CTX_BID | DMP_CTX_LCPUID) /* Dump minimal context info (register state, stack trace). * NOTE: Without another full fledged context dump, any * contexts dumped with the following flag will result in * dumps that are not fully usable with KDB. */ #define DMP_CTX_LITE 0x4000000000000000ll /* dmp_mtrc: function to dump a system's memory trace (LMT) buffers */ extern kerrno_t dmp_mtrc( long flags, /* See the DCF_ flags in dump.h */ void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ char *name, /* unneeded here */ size_t com_sz, /* amount of the LMT common buffer to dump */ size_t rar_sz); /* amount of the LMT rare buffer to dump */ /* dmp_ct: function to dump a RAS component's CT buffer */ kerrno_t extern dmp_ct( long flags, /* See the DCF_ flags in dump.h */ void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ char *name, /* unneeded here */ ras_block_t rasb, /* Component's ras_block_t */ size_t sz); /* Amount of CT buffer to dump */ /* dmp_pid: function to dump a PID's information */ extern kerrno_t dmp_pid( long flags, /* See the DCF_ flags in dump.h */ void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ char *name, pid_t pid, /* pid to dump */ void *unused); /* dmp_tid: function to dump a TID's information */ extern kerrno_t dmp_tid( long flags, /* See the DCF_ flags in dump.h */ void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ char *name, tid_t tid, /* tid to dump */ void *unused); /* dmp_errbuf: function to dump error logging data */ extern kerrno_t dmp_errbuf( long flags, /* See the DCF_ flags in dump.h */ void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ char *name, ulong erridx, /* NULL for global errlg, or wpar number */ long p2); /* Unused */ /* dmp_eaddr: function to dump a region of memory */ extern kerrno_t dmp_eaddr( long flags, /* See the DCF_ flags in dump.h */ void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ char *name, long p1, /* Start address */ long p2); /* Size in bytes */ /* dmp_systrace: function to dump system trace data */ extern kerrno_t dmp_systrace( long flags, /* See the DCF_ flags in dump.h */ void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ char *name, /* unused here */ long sz, /* amount of trace data to dump */ long p2); /* unused */ /* dmp_kernext: function to allow symbol resolution for a kernel extension */ extern kerrno_t dmp_kernext( void *anchor, /* associated data (ldmp_prepare_t* or ldmp_parms_t*) */ void *ptr); /* ptr to txt or data addr in the kernel extension */ /* Given the head of an unlimited dump table, return the ith entry in the table. * This abstracts the different types of unlimited entries * (regular, alias, list). */ extern void * dmp_cdt_entry_u_ptr(void *p, int i, int ck); /* * dump kerrnos */ #define LDMP_SUBBLK 0x800 /* sub-block for livedump.h */ #define DMP_SUBBLK_I 0xc00 /* sub-block for dump internal */ /* 0x96220001/0xEEEE000096220000 */ #define EINVAL_RAS_DMP_COMPSPEC_ANCHOR KERROR(EINVAL, sysdump_BLOCK_00, 0) #define EFAULT_RAS_DMP_COMPSPEC_ANCHOR KERROR(EFAULT, sysdump_BLOCK_00, 1) #define EINVAL_RAS_DMP_COMPSPEC_NOADD KERROR(EINVAL, sysdump_BLOCK_00, 2) #define EINVAL_RAS_DMP_COMPSPEC_FLAGS KERROR(EINVAL, sysdump_BLOCK_00, 3) #define EINVAL_RAS_DMP_COMPSPEC_FAILING KERROR(EINVAL, sysdump_BLOCK_00, 4) #define EINVAL_RAS_DMP_COMPSPEC_COMP KERROR(EINVAL, sysdump_BLOCK_00, 5) #define EFAULT_RAS_DMP_COMPSPEC_EXTID KERROR(EFAULT, sysdump_BLOCK_00, 6) #define EINVAL_RAS_DMP_COMPSPEC_NOTAWARE KERROR(EINVAL, sysdump_BLOCK_00, 7) #define ENOMEM_RAS_DMP_COMPSPEC KERROR(ENOMEM, sysdump_BLOCK_00, 8) #define EFAULT_RAS_DMP_COMPSPEC_PARMS KERROR(EFAULT, sysdump_BLOCK_00, 9) #define EINVAL_RAS_DMP_COMPEXT_EXTID KERROR(EINVAL, sysdump_BLOCK_00, 10) #define EFAULT_RAS_DMP_COMPEXT_EXTID KERROR(EFAULT, sysdump_BLOCK_00, 11) #define EFAULT_RAS_DMP_COMPEXT_PARMS KERROR(EFAULT, sysdump_BLOCK_00, 12) #define ENOMEM_RAS_DMP_COMPEXT KERROR(ENOMEM, sysdump_BLOCK_00, 13) #define EFAULT_RAS_DMP_CONTEXT KERROR(EFAULT, sysdump_BLOCK_00, 14) #define EINVAL_RAS_DMP_CONTEXT KERROR(EINVAL, sysdump_BLOCK_00, 15) #define ENOENT_RAS_DMP_CONTEXT KERROR(ENOENT, sysdump_BLOCK_00, 16) #define EINVAL_RAS_DMP_MTRC KERROR(EINVAL, sysdump_BLOCK_00, 17) #define ENOENT_RAS_DMP_MTRC KERROR(ENOENT, sysdump_BLOCK_00, 18) #define EINVAL_RAS_DMP_CONTEXT_CTX_PREV KERROR(EINVAL, sysdump_BLOCK_00, 19) #define EINVAL_RAS_DMP_EADDR KERROR(EINVAL, sysdump_BLOCK_00, 20) #define EFAULT_RAS_DMP_EADDR KERROR(EFAULT, sysdump_BLOCK_00, 21) #define EINVAL_RAS_DMP_EADDR_CB KERROR(EINVAL, sysdump_BLOCK_00, 22) #define EBUSY_RAS_DMP_COMPEXT KERROR(EBUSY, sysdump_BLOCK_00, 23) #define EINVAL_RAS_DMP_MTRC_CB KERROR(EINVAL, sysdump_BLOCK_00, 24) #define EINVAL_RAS_DMP_CONTEXT_CB_PARM KERROR(EINVAL, sysdump_BLOCK_00, 25) #define EINVAL_RAS_DMP_CONTEXT_CB_BADCMD KERROR(EINVAL, sysdump_BLOCK_00, 26) #define EINVAL_RAS_DMP_TID KERROR(EINVAL, sysdump_BLOCK_00, 27) #define EINVAL_RAS_DMP_PID KERROR(EINVAL, sysdump_BLOCK_00, 28) #define EINVAL_RAS_DMP_TID_CB KERROR(EINVAL, sysdump_BLOCK_00, 29) #define ENOENT_RAS_DMP_TID_CB KERROR(ENOENT, sysdump_BLOCK_00, 30) #define EINVAL_RAS_DMP_PID_CB KERROR(EINVAL, sysdump_BLOCK_00, 31) #define ENOENT_RAS_DMP_PID_CB KERROR(ENOENT, sysdump_BLOCK_00, 32) #define EINVAL_RAS_DMP_CONTEXT_BAD_PVT KERROR(EINVAL, sysdump_BLOCK_00, 33) #define ENOENT_RAS_DMP_CONTEXT_CTX_NOTFOUND KERROR(ENOENT, sysdump_BLOCK_00, 34) #define EINVAL_RAS_DMP_CONTEXT_UNSER_TID KERROR(EINVAL, sysdump_BLOCK_00, 35) #define EINVAL_RAS_DMP_CONTEXT_XMEM_CTX KERROR(EINVAL, sysdump_BLOCK_00, 36) #define ENOENT_RAS_DMP_CONTEXT_CPU_GONE KERROR(ENOENT, sysdump_BLOCK_00, 37) #define EINVAL_RAS_DMP_CT KERROR(EINVAL, sysdump_BLOCK_00, 38) #define ENOMEM_RAS_DMP_CT KERROR(ENOMEM, sysdump_BLOCK_00, 39) #define EINVAL_RAS_DMP_CT_GETPATH KERROR(EINVAL, sysdump_BLOCK_00, 40) #define EINVAL_RAS_DMP_CT_LOOKUP KERROR(EINVAL, sysdump_BLOCK_00, 41) #define ENOTSUP_RAS_DMP_CT KERROR(ENOTSUP, sysdump_BLOCK_00, 42) #define EINVAL_RAS_DMP_CT_CB KERROR(EINVAL, sysdump_BLOCK_00, 43) #define EINVAL_RAS_DMP_ERRBUF KERROR(EINVAL, sysdump_BLOCK_00, 44) #define EINVAL_RAS_DMP_ERRBUF_CB KERROR(EINVAL, sysdump_BLOCK_00, 45) #define ECHRNG_RAS_DMP_ERRBUF KERROR(ECHRNG, sysdump_BLOCK_00, 46) #define EINVAL_RAS_DMP_SYSTRACE KERROR(EINVAL, sysdump_BLOCK_00, 47) #define ENOENT_RAS_DMP_SYSTRACE KERROR(ENOENT, sysdump_BLOCK_00, 48) #define EINVAL_RAS_DMP_SYSTRACE_CB KERROR(EINVAL, sysdump_BLOCK_00, 48) #define ENOENT_RAS_DMP_SYSTRACE_CB_PREP KERROR(ENOENT, sysdump_BLOCK_00, 49) #define ENOENT_RAS_DMP_SYSTRACE_CB_START KERROR(ENOENT, sysdump_BLOCK_00, 50) #define EFAULT_RAS_DMP_SYSTRACE_CB_PREP KERROR(EFAULT, sysdump_BLOCK_00, 51) #define EINVAL_RAS_DMP_KERNEXT KERROR(EINVAL, sysdump_BLOCK_00, 52) #define EINVAL_RAS_DMP_KERNEXT_CB KERROR(EINVAL, sysdump_BLOCK_00, 53) #define EBUSY_RAS_DMP_KERNEXT_LA KERROR(EBUSY, sysdump_BLOCK_00, 54) #define ENOMEM_RAS_DMP_KERNEXT_LA KERROR(ENOMEM, sysdump_BLOCK_00, 55) #define EINVAL_RAS_DMP_KERNEXT_LA KERROR(EINVAL, sysdump_BLOCK_00, 56) #define EINVAL_RAS_DMP_CTX_CHAIN_FLAGS KERROR(EINVAL, sysdump_BLOCK_00, 57) #define EINVAL_RAS_DMP_CTX_CHAIN_TYPE KERROR(EINVAL, sysdump_BLOCK_00, 58) #define EINVAL_RAS_DMP_CTX_CHAIN_BADCPU KERROR(EINVAL, sysdump_BLOCK_00, 59) #define EFAULT_RAS_DMP_CT KERROR(EFAULT, sysdump_BLOCK_00, 60) #define ENOSPC_RAS_DMP_EADDR KERROR(ENOSPC, sysdump_BLOCK_00, 61) #define EFAULT_RAS_DMP_SYSTRACE_CB_START KERROR(EFAULT, sysdump_BLOCK_00, 62) #define ENOMEM_RAS_DMP_DMPCTLADD KERROR(ENOMEM, sysdump_BLOCK_00, 63) #define EEXIST_RAS_DMP_DMPCTLADD KERROR(EEXIST, sysdump_BLOCK_00, 64) #define EINVAL_RAS_DMP_DMPCTLADD_PARMS KERROR(EINVAL, sysdump_BLOCK_00, 65) #define EINVAL_RAS_DMP_DMPCTLADD_BUFSIZE KERROR(EINVAL, sysdump_BLOCK_00, 66) #define EINVAL_RAS_DMP_DMPCTLADD_NOPARMS KERROR(EINVAL, sysdump_BLOCK_00, 67) #define ENOSPC_XDMP_ERROR KERROR(ENOSPC, sysdump_BLOCK_00, 68) #define DISABLED_XDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 69) #define FAIL_XDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 70) #define UNKN_XDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 71) #define ENOMEM_RAS_DMP_CONTEXT_CSA KERROR(ENOMEM, sysdump_BLOCK_00, 72) #define DUMPQUERY_SDMP_DEVERROR KERROR(ENODEV, sysdump_BLOCK_00, 74) #define DUMPSTART_SDMP_DEVERROR KERROR(EINVAL, sysdump_BLOCK_00, 76) #define DUMPTERM_SDMP_DEVERROR KERROR(EIO, sysdump_BLOCK_00, 82) #define DUMPSTARTBUF_SDMP_DEVERROR KERROR(ENOMEM, sysdump_BLOCK_00, 83) #define DUMPSTART_FDMP_DEVERROR KERROR(EIO, sysdump_BLOCK_00, 85) #define WRCDTCDP_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 88) #define WRCDTDATA_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 89) #define WRCDTU_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 90) #define WRCDTURAS_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 91) #define WRCDTUENTRY1_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 92) #define WRCDTRAS_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 93) #define WRCDTUDATA_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 94) #define DUMPRESET_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 95) #define DDCOMP1_SDMP_ERROR KERROR(ENOMEM, sysdump_BLOCK_00, 96) #define DDCOMP2_SDMP_ERROR KERROR(ENOMEM, sysdump_BLOCK_00, 97) #define DDCOMPIO_SDMP_ERROR KERROR(ENOMEM, sysdump_BLOCK_00, 98) #define PUSHDUMP1_SDMP_ERROR KERROR(ENOMEM, sysdump_BLOCK_00, 99) #define PUSHDUMP2_SDMP_ERROR KERROR(ENOMEM, sysdump_BLOCK_00, 100) #define PULLDUMP_SDMP_ERROR KERROR(ENOMEM, sysdump_BLOCK_00, 101) #define JWRITEBUF_SDMP_ERROR KERROR(ENOMEM, sysdump_BLOCK_00, 104) #define EINVAL_JFLUSH_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 105) #define ENOSPC_JWRITEIO1_SDMP_ERROR KERROR(ENOSPC, sysdump_BLOCK_00, 106) #define EFAULT_DMP_IOWORKER KERROR(EFAULT, sysdump_BLOCK_00, 109) #define EFAULT_DMP_COMPRESSWORKER KERROR(EFAULT, sysdump_BLOCK_00, 110) #define QUIT_SDMP_ON_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 111) #define ENVAL_SDMP_NOHARD_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 112) #define EINVAL_CDT_HEADER_MAGIC KERROR(EINVAL, sysdump_BLOCK_00, 113) #define EINVAL_RAS_CALLBACK_KERR KERROR(EINVAL, sysdump_BLOCK_00, 114) #define EFAULT_CDT_DATA_AREA KERROR(EFAULT, sysdump_BLOCK_00, 115) #define EINVAL_WRCDTUENTRY2_SDMP_ERROR KERROR(EINVAL, sysdump_BLOCK_00, 116) #define EIO_SDMP_DUMPSTART KERROR(EIO, sysdump_BLOCK_00, 117) #define ENODEV_IDMP_DO_NODEVICE KERROR(ENODEV, sysdump_BLOCK_00, 119) #define EINAVL_IDMP_DO_RMDEVICE KERROR(EINVAL, sysdump_BLOCK_00, 120) #define EBUSY_SDMP_LOG_HANG_ERROR KERROR(EBUSY, sysdump_BLOCK_00, 121) #define EIO_SDMP_DEVERROR KERROR(EIO, sysdump_BLOCK_00, 123) #define EFAULT_SDMP_MINIDUMP KERROR(EFAULT, sysdump_BLOCK_00, 124) #define EFAULT_DMP_MASTER KERROR(EFAULT, sysdump_BLOCK_00, 125) #endif /* _RAS_INTERNAL || _KERNEL */ /* * ras_stat structure for the dump domain. * This structure size must not exceed 128 bytes. */ typedef struct rstat_dump { dmp_lvl_t rst_sdmp_lvl; dmp_lvl_t rst_ldmp_lvl; int rst_dmp_flags; /* see rdb_flags */ int rst_dump_reserved[30]; } rstat_dump_t; /* * Dump-domain-specific information for persistent customizations. */ typedef struct rasp_pdump_stat { char rst_flags; signed rst_sdmp_on_off :2; signed rst_ldmp_on_off :2; short rst_length; /* Length of structure for extensibility */ dmp_lvl_t rst_sdmp_lvl; dmp_lvl_t rst_ldmp_lvl; } rpstat_dump_t; #ifdef __KDB_LDMP_COMPFLAGS /* This is used to display the flags in kdb. */ static char *__dcf_descr[] = { "LVL0", "LVL1", "LVL2", "LVL3", "LVL4", "LVL5", "LVL6", "LVL7", "LVL8", "LVL9", "PSDO", "PNAM", "LNAM", "TYPE", "BYCB", "FAIL", "FRST", "KYWD", "LONG", "UNIQ", "MOREDATA", "NEEDSPUT", "PREPD", "ST_BAD", "PR_BAD", "FINISH"}; #endif /* __KDB_LDMP_COMPFLAGS */ #ifdef __cplusplus } #endif #endif /* _H_DUMP */