![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_dbg.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs|
Return to hfs_dbg.h CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* hfs_dbg.h ! 26: * ! 27: * (c) 1997 Apple Computer, Inc. All Rights Reserved ! 28: * ! 29: * hfs_dbg.h -- debugging macros for HFS file system. ! 30: * ! 31: * HISTORY ! 32: * 10-Nov-1998 Pat Dirks Cleaned up definition of DBG_ASSERT to handle embedded '%' correctly. ! 33: * 28-Apr-1998 Scott Roberts Reorganized and added DEBUG_STAGE ! 34: * 17-Nov-1997 Pat Dirks Pat Dirks at Apple Computer ! 35: * Derived from old hfs version. ! 36: */ ! 37: ! 38: #ifdef KERNEL ! 39: #include <libkern/libkern.h> ! 40: #else /* KERNEL */ ! 41: #include <bsd/stdio.h> ! 42: #endif /* KERNEL */ ! 43: ! 44: extern void call_kdp(void); ! 45: extern int lbolt; ! 46: ! 47: /* Define the debugging stage... ! 48: 4 -> Do all, aggresive, call_kdp ! 49: 3 -> debug asserts and debug err, panic instead of call_kdp ! 50: 2 -> debug error, no kdb ! 51: 1 -> very little, panic only ! 52: */ ! 53: #if DIAGNOSTIC ! 54: /* OK, we're doing a debug build; DIAGNOSTIC=1 */ ! 55: #else ! 56: /* This is a debug build (DIAGNOSTIC is undefined or DIAGNOSTIC=0); make sure DIAGNOSTIC=0 */ ! 57: #ifdef DIAGNOSTIC ! 58: #warning DIAGNOSTIC defined but not set! ! 59: #endif ! 60: /* XXX PPD Is this just totally superfluous, or even dangerous? #if DIAGNOSTIC already fails, and now #ifdef DIAGNOSTIC will fire... */ ! 61: #define DIAGNOSTIC 0 ! 62: #endif ! 63: ! 64: #if DIAGNOSTIC ! 65: #define DEBUG_STAGE 3 ! 66: #else ! 67: #define DEBUG_STAGE 1 ! 68: #endif /* KERNEL */ ! 69: ! 70: #ifdef KERNEL ! 71: #define PRINTIT kprintf ! 72: #else /* KERNEL */ ! 73: #define PRINTIT printf ! 74: #endif /* KERNEL */ ! 75: ! 76: #if (DEBUG_STAGE > 2) ! 77: #define DEBUG_BREAK call_kdp(); ! 78: #else ! 79: #define DEBUG_BREAK ! 80: #endif ! 81: ! 82: #if (DEBUG_STAGE == 4) ! 83: #define DEBUG_BREAK_MSG(PRINTF_ARGS) { PRINTIT PRINTF_ARGS; DEBUG_BREAK }; ! 84: #elif (DEBUG_STAGE == 3) ! 85: #define DEBUG_BREAK_MSG(PRINTF_ARGS) { panic PRINTF_ARGS;}; ! 86: #else ! 87: #define DEBUG_BREAK_MSG(PRINTF_ARGS) { PRINTIT PRINTF_ARGS; }; ! 88: #endif ! 89: ! 90: ! 91: //#define PRINT_DELAY (void) tsleep((caddr_t)&lbolt, PPAUSE, "hfs kprintf", 0) ! 92: #define PRINT_DELAY ! 93: ! 94: /* ! 95: * Debugging macros. ! 96: */ ! 97: #if DIAGNOSTIC ! 98: extern int hfs_dbg_all; ! 99: extern int hfs_dbg_vfs; ! 100: extern int hfs_dbg_vop; ! 101: extern int hfs_dbg_load; ! 102: extern int hfs_dbg_io; ! 103: extern int hfs_dbg_utils; ! 104: extern int hfs_dbg_rw; ! 105: extern int hfs_dbg_DIT; ! 106: extern int hfs_dbg_tree; ! 107: extern int hfs_dbg_err; ! 108: extern int hfs_dbg_test; ! 109: ! 110: #ifdef KERNEL ! 111: #if (DEBUG_STAGE == 4) ! 112: #define DBG_ASSERT(a) { if (!(a)) { PRINTIT("Oops - File "__FILE__", line %d: assertion '%s' failed.\n", __LINE__, #a); DEBUG_BREAK } } ! 113: #else ! 114: #define DBG_ASSERT(a) { if (!(a)) { panic("File "__FILE__", line %d: assertion '%s' failed.\n", __LINE__, #a); } } ! 115: #endif /* DEBUG_STAGE */ ! 116: #else ! 117: #define DBG_ASSERT(a) assert(a) ! 118: #endif /* KERNEL */ ! 119: ! 120: //#define DBG_VFS if (hfs_dbg_all || hfs_dbg_vfs) PRINTIT ! 121: #define DBG_VFS(x) { \ ! 122: if(hfs_dbg_all || hfs_dbg_vfs) { \ ! 123: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 124: PRINTIT x; \ ! 125: PRINT_DELAY; \ ! 126: }; \ ! 127: } ! 128: #define DBG_VFS_CONT(x) { \ ! 129: if(hfs_dbg_all || hfs_dbg_vfs) { \ ! 130: PRINTIT x; \ ! 131: PRINT_DELAY; \ ! 132: }; \ ! 133: } ! 134: #define DBG_VOP(x) { \ ! 135: if(hfs_dbg_all || hfs_dbg_vop) { \ ! 136: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 137: PRINTIT x; \ ! 138: PRINT_DELAY; \ ! 139: }; \ ! 140: } ! 141: #define DBG_VOP_CONT(x) { \ ! 142: if(hfs_dbg_all || hfs_dbg_vop) { \ ! 143: PRINTIT x; \ ! 144: PRINT_DELAY; \ ! 145: }; \ ! 146: } ! 147: #define DBG_LOAD(x) { \ ! 148: if(hfs_dbg_all || hfs_dbg_load) { \ ! 149: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 150: PRINTIT x; \ ! 151: PRINT_DELAY; \ ! 152: }; \ ! 153: } ! 154: #define DBG_IO(x) { \ ! 155: if(hfs_dbg_all || hfs_dbg_io) { \ ! 156: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 157: PRINTIT x; \ ! 158: PRINT_DELAY; \ ! 159: }; \ ! 160: } ! 161: #define DBG_UTILS(x) { \ ! 162: if(hfs_dbg_all || hfs_dbg_utils) { \ ! 163: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 164: PRINTIT x; \ ! 165: PRINT_DELAY; \ ! 166: }; \ ! 167: } ! 168: #define DBG_RW(x) { \ ! 169: if(hfs_dbg_all || hfs_dbg_rw) { \ ! 170: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 171: PRINTIT x; \ ! 172: PRINT_DELAY; \ ! 173: }; \ ! 174: } ! 175: #define DBG_DIT(x) { \ ! 176: if(hfs_dbg_all || hfs_dbg_DIT) { \ ! 177: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 178: PRINTIT x; \ ! 179: PRINT_DELAY; \ ! 180: }; \ ! 181: } ! 182: #define DBG_TREE(x) { \ ! 183: if(hfs_dbg_all || hfs_dbg_tree) { \ ! 184: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 185: PRINTIT x; \ ! 186: PRINT_DELAY; \ ! 187: }; \ ! 188: } ! 189: #define DBG_ERR(x) { \ ! 190: if(hfs_dbg_all || hfs_dbg_err) { \ ! 191: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 192: PRINTIT("HFS ERROR: "); \ ! 193: PRINTIT x; \ ! 194: PRINT_DELAY; \ ! 195: }; \ ! 196: } ! 197: #define DBG_TEST(x) { \ ! 198: if(hfs_dbg_all || hfs_dbg_test) { \ ! 199: PRINTIT("%X: ", CURRENT_PROC->p_pid); \ ! 200: PRINTIT x; \ ! 201: PRINT_DELAY; \ ! 202: }; \ ! 203: } ! 204: #else // DIAGNOSTIC ! 205: #define DBG_ASSERT(a) ! 206: #define DBG_VFS(x) ! 207: #define DBG_VFS_CONT(x) ! 208: #define DBG_VOP(x) ! 209: #define DBG_VOP_CONT(x) ! 210: #define DBG_LOAD(x) ! 211: #define DBG_IO(x) ! 212: #define DBG_UTILS(x) ! 213: #define DBG_RW(x) ! 214: #define DBG_DIT(x) ! 215: #define DBG_TREE(x) ! 216: #define DBG_ERR(x) ! 217: #define DBG_TEST(x) ! 218: #endif // DIAGNOSTIC ! 219: ! 220: ! 221: /* Used to help print commone values in the vnode ops */ ! 222: #if DIAGNOSTIC ! 223: extern void debug_vn_status (char* introStr, struct vnode *vn); ! 224: extern void debug_vn_print (char* introStr, struct vnode *vn); ! 225: ! 226: #define DBG_VN_STATUS (introStr, vn) debug_vn_status (introStr, vn) ! 227: #define DBG_VN_PRINT (introStr, vn) debug_vn_print (introStr, vn) ! 228: #define DBG_FUNC_NAME(FSTR) static char *funcname = FSTR ! 229: #define DBG_PRINT_FUNC_NAME() PRINTIT("%X: %s\n", CURRENT_PROC->p_pid, funcname) ! 230: #define DBG_VOP_PRINT_FUNCNAME() DBG_VOP(("%s: ", funcname)); ! 231: ! 232: ! 233: /* This checks to make sure the passed in node is valid and HFS */ ! 234: #define DBG_HFS_NODE_CHECK(VP) { \ ! 235: if ((VP) == NULL || VTOH((VP))->h_valid != HFS_VNODE_MAGIC) { \ ! 236: DBG_VOP_CONT(("%s: INVALID VNODE: ", funcname)); \ ! 237: DBG_VOP_PRINT_VNODE_INFO(VP); \ ! 238: DBG_VOP_CONT(("\n")); \ ! 239: return (EINVAL); \ ! 240: } \ ! 241: } ! 242: ! 243: #define DBG_VOP_PRINT_VNODE_INFO(VP) { if (VP && VTOH((VP))->h_valid == HFS_VNODE_MAGIC) { \ ! 244: DBG_VOP_CONT(("\tn: %s, p: %ld, id: %ld, f: %d, u: %d, v: 0x%x ",H_NAME(VTOH(VP)), \ ! 245: H_DIRID(VTOH(VP)), H_FILEID(VTOH(VP)), H_FORKTYPE(VTOH(VP)), (VP)->v_usecount, (u_int)(VP))); \ ! 246: } else { \ ! 247: DBG_VOP_CONT(("\tBAD MACNODE"));}} ! 248: ! 249: #define DBG_VOP_PRINT_CPN_INFO(CN) DBG_VOP_CONT(("name: %s",(CN)->cn_nameptr)); ! 250: ! 251: #else /* DIAGNOSTIC */ ! 252: ! 253: #define DBG_VN_PRINT(introStr,vn) ! 254: #define DBG_VN_STATUS(introStr,vn) ! 255: #define DBG_FUNC_NAME(FSTR) ! 256: #define DBG_PRINT_FUNC_NAME() ! 257: #define DBG_HFS_NODE_CHECK(VP) ! 258: #define DBG_VOP_PRINT_FUNCNAME() ! 259: #define DBG_VOP_PRINT_VNODE_INFO(VP) ! 260: #define DBG_VOP_PRINT_CPN_INFO(CN) ! 261: ! 262: #endif /* DIAGNOSTIC */ ! 263: ! 264: ! 265: #if DIAGNOSTIC ! 266: #define DBG_VOP_TEST_LOCKS 1 ! 267: #else /* DIAGNOSTIC */ ! 268: #undef DBG_VOP_TEST_LOCKS ! 269: #endif /* DIAGNOSTIC */ ! 270: ! 271: ! 272: ! 273: #if DBG_VOP_TEST_LOCKS ! 274: ! 275: typedef struct VopDbgStoreRec { ! 276: short id; ! 277: struct vnode *vp; ! 278: short inState; ! 279: short outState; ! 280: short errState; ! 281: int inValue; ! 282: int outValue; ! 283: } VopDbgStoreRec; ! 284: ! 285: ! 286: void DbgVopTest (int max, int error, VopDbgStoreRec *VopDbgStore, char *funcname); ! 287: void DbgLookupTest(char *funcname, struct componentname *cnp, struct vnode *dvp, struct vnode *vp); ! 288: ! 289: #define VOPDBG_IGNORE 0 ! 290: #define VOPDBG_LOCKED 1 ! 291: #define VOPDBG_UNLOCKED -1 ! 292: #define VOPDBG_LOCKNOTNIL 2 ! 293: #define VOPDBG_SAME 3 ! 294: ! 295: #define VOPDBG_ZERO 0 ! 296: #define VOPDBG_POS 1 ! 297: ! 298: /* This sets up the test for the lock state of vnodes. The entry paramaters are: ! 299: * I = index of paramater ! 300: * VP = pointer to a vnode ! 301: * ENTRYSTATE = the inState of the lock ! 302: * EXITSTATE = the outState of the lock ! 303: * ERRORSTATE = the error state of the lock ! 304: * It initializes the structure, does some preliminary validity checks, but does nothing ! 305: * if the instate is set to be ignored. ! 306: */ ! 307: ! 308: ! 309: #define DBG_VOP_LOCKS_DECL(I) VopDbgStoreRec VopDbgStore[I];short numOfLockSlots=I ! 310: #define DBG_VOP_LOCKS_INIT(I,VP,ENTRYSTATE,EXITSTATE,ERRORSTATE,CHECKFLAG) \ ! 311: if (I >= numOfLockSlots) { \ ! 312: DEBUG_BREAK_MSG(("%s: DBG_VOP_LOCKS_INIT: Entry #%d greater than allocated slots!\n", funcname, I)); \ ! 313: }; \ ! 314: VopDbgStore[I].id = I; \ ! 315: VopDbgStore[I].vp = VP; \ ! 316: VopDbgStore[I].inState = ENTRYSTATE; \ ! 317: VopDbgStore[I].outState = EXITSTATE; \ ! 318: VopDbgStore[I].errState = ERRORSTATE; \ ! 319: VopDbgStore[I].inValue = 0; \ ! 320: VopDbgStore[I].outValue = 0; \ ! 321: if ((VopDbgStore[I].inState != VOPDBG_IGNORE)) { \ ! 322: if ((VP) == NULL) \ ! 323: PRINTIT ("%X: %s: DBG_VOP_LOCK on start: Null vnode ptr\n", CURRENT_PROC->p_pid, funcname); \ ! 324: else \ ! 325: VopDbgStore[I].inValue = lockstatus (&(VTOH(VP))->h_lock); \ ! 326: } \ ! 327: if ((VP) != NULL) \ ! 328: { \ ! 329: if (CHECKFLAG==VOPDBG_POS && (VP)->v_usecount <= 0) \ ! 330: PRINTIT("%X: %s: BAD USECOUNT OF %d !!!!\n", CURRENT_PROC->p_pid, funcname, (VP)->v_usecount); \ ! 331: else if ((VP)->v_usecount < 0) \ ! 332: PRINTIT("%X: %s: BAD USECOUNT OF %d !!!!\n", CURRENT_PROC->p_pid, funcname, (VP)->v_usecount); \ ! 333: } ! 334: ! 335: #define DBG_VOP_UPDATE_VP(I, VP) \ ! 336: VopDbgStore[I].vp = VP; ! 337: ! 338: #define DBG_VOP_LOCKS_TEST(status) DbgVopTest (numOfLockSlots, status, VopDbgStore, funcname); ! 339: #define DBG_VOP_LOOKUP_TEST(funcname, cnp, dvp, vp) DbgLookupTest (funcname, cnp, dvp, vp); ! 340: ! 341: #else /* DBG_VOP_TEST_LOCKS */ ! 342: ! 343: #define DBG_VOP_LOCKS_DECL(A) ! 344: #define DBG_VOP_LOCKS_INIT(A,B,C,D,E,F) ! 345: #define DBG_VOP_LOCKS_TEST(a) ! 346: #define DBG_VOP_LOOKUP_TEST(funcname, cnp, dvp, vp) ! 347: #define DBG_VOP_UPDATE_VP(I, VP) ! 348: #endif /* DBG_VOP_TEST_LOCKS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.