Return to volfs.h CVS log

Up to [Apple XNU] / XNU / bsd / miscfs / volfs

Annotation of XNU/bsd/miscfs/volfs/volfs.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * The contents of this file constitute Original Code as defined in and
        !             7:  * are subject to the Apple Public Source License Version 1.1 (the
        !             8:  * "License").  You may not use this file except in compliance with the
        !             9:  * License.  Please obtain a copy of the License at
        !            10:  * http://www.apple.com/publicsource and read it before using this file.
        !            11:  * 
        !            12:  * This Original Code and all software distributed under the License are
        !            13:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            14:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            15:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            16:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            17:  * License for the specific language governing rights and limitations
        !            18:  * under the License.
        !            19:  * 
        !            20:  * @APPLE_LICENSE_HEADER_END@
        !            21:  */
        !            22: /* Copyright (c) 1998, Apple Computer, Inc. All rights reserved. */
        !            23: /*
        !            24:  * Header file for volfs
        !            25:  */
        !            26: 
        !            27: struct volfs_mntdata
        !            28: {
        !            29:        struct vnode *volfs_rootvp;
        !            30:        LIST_HEAD(volfs_fsvnodelist, vnode) volfs_fsvnodes;
        !            31: };
        !            32: 
        !            33: /*
        !            34:  * Volfs vnodes exist only for the root, which allows for the enumeration
        !            35:  * of all volfs accessible filesystems, and for the filesystems which
        !            36:  * volfs handles.
        !            37:  */
        !            38: #define VOLFS_ROOT     1       /* This volfs vnode represents root of volfs */
        !            39: #define        VOLFS_FSNODE    2       /* This volfs vnode represents a file system */
        !            40: 
        !            41: struct volfs_vndata
        !            42: {
        !            43:        int             vnode_type;
        !            44:        struct lock__bsd__      lock;
        !            45:        unsigned int    nodeID; /* the dev entry of a file system */
        !            46:        struct mount *  fs_mount;
        !            47: };
        !            48: 
        !            49: /* Flag set for HFS volumes to indicate roman-only encoding: */
        !            50: #define VOLFS_ROMANONLY  0x40000000
        !            51: 
        !            52: /* Summary of all flags in volume id's exported to outside view: */
        !            53: #define VOLFS_VOLIDFLAGS (VOLFS_ROMANONLY)
        !            54: 
        !            55: #define MAXVLFSNAMLEN  24      /* max length is really 10, pad to 24 since
        !            56:                                 * some of the math depends on VLFSDIRENTLEN
        !            57:                                 * being a power of 2 */
        !            58: #define VLFSDIRENTLEN  (MAXVLFSNAMLEN + sizeof(u_int32_t) + sizeof(u_int16_t) + sizeof(u_int8_t) + sizeof(u_int8_t))
        !            59: 
        !            60: #define ROOT_DIRID     2
        !            61: 
        !            62: extern int (**volfs_vnodeop_p)();
        !            63: __BEGIN_DECLS
        !            64: 
        !            65: int    volfs_mount __P((struct mount *, char *, caddr_t, struct nameidata *,
        !            66:        struct proc *));
        !            67: int    volfs_start __P((struct mount *, int, struct proc *));
        !            68: int    volfs_unmount __P((struct mount *, int, struct proc *));
        !            69: int    volfs_root __P((struct mount *, struct vnode **));
        !            70: int    volfs_quotactl __P((struct mount *, int, uid_t, caddr_t, 
        !            71:        struct proc *));
        !            72: int    volfs_statfs __P((struct mount *, struct statfs *, struct proc *));
        !            73: int    volfs_sync __P((struct mount *, int, struct ucred *, struct proc *));
        !            74: int    volfs_vget __P((struct mount *, void *ino_t, struct vnode **));
        !            75: int    volfs_fhtovp __P((struct mount *, struct fid *, struct mbuf *,
        !            76:        struct vnode **, int *, struct ucred **));
        !            77: int    volfs_vptofh __P((struct vnode *, struct fid *));
        !            78: int    volfs_init __P((struct vfsconf *));
        !            79: int    volfs_sysctl __P((int *, u_int, void *, size_t *, void *, size_t,
        !            80:                struct proc *));
        !            81: 
        !            82: int    volfs_reclaim __P((struct vop_reclaim_args*));
        !            83: int    volfs_access __P((struct vop_access_args *));
        !            84: int    volfs_getattr __P((struct vop_getattr_args *));
        !            85: int    volfs_select __P((struct vop_select_args *));
        !            86: int    volfs_rmdir __P((struct vop_rmdir_args *));
        !            87: int    volfs_readdir __P((struct vop_readdir_args *));
        !            88: int    volfs_lock __P((struct vop_lock_args *));
        !            89: int    volfs_unlock __P((struct vop_unlock_args *));
        !            90: int    volfs_islocked __P((struct vop_islocked_args *));
        !            91: int    volfs_pathconf __P((struct vop_pathconf_args *));
        !            92: int    volfs_lookup __P((struct vop_lookup_args *));
        !            93: __END_DECLS
        !            94: 
        !            95: #define VTOVL(VP) ((struct volfs_vndata *)((VP)->v_data))
        !            96: 
        !            97: #define PRINTIT kprintf
        !            98: 
        !            99: #if VOLFS_DEBUG
        !           100:     #define    DBG_VOP_TEST_LOCKS                      1
        !           101:     #define DBG_FUNC_NAME(FSTR)                static char *funcname = FSTR
        !           102:     #define DBG_PRINT_FUNC_NAME()              PRINTIT("%s\n", funcname);
        !           103:     #define DBG_VOP_PRINT_FUNCNAME()   PRINTIT("%s: ", funcname);
        !           104:        #define DBG_VOP_PRINT_CPN_INFO(CN)      PRINTIT("name: %s",(CN)->cn_nameptr);
        !           105:        #define DBG_VOP(STR)                            PRINTIT STR;
        !           106:     #define DBG_VOP_PRINT_VNODE_INFO(VP)       {  if ((VP)) \
        !           107:       { if ((VP)->v_tag == VT_NON) \
        !           108:       PRINTIT("\tfs:%s id: %d v: 0x%x ", VTOVL(VP)->fs_mount->mnt_stat.f_fstypename, VTOVL(VP)->nodeID, (u_int)(VP)); \
        !           109:       else  PRINTIT("\t%s v: 0x%x ", (VP)->v_mount->mnt_stat.f_fstypename, (u_int)(VP)); \
        !           110:       } else { PRINTIT("*** NULL NODE ***"); } }
        !           111: 
        !           112: #else /* VOLFS_DEBUG */
        !           113:     #define DBG_VOP_TEST_LOCKS 0
        !           114:     #define DBG_FUNC_NAME(FSTR)
        !           115:     #define DBG_PRINT_FUNC_NAME()
        !           116:     #define DBG_VOP_PRINT_FUNCNAME()
        !           117:     #define DBG_VOP_PRINT_CPN_INFO(CN)
        !           118:        #define DBG_VOP(A)
        !           119:        #define DBG_VOP_PRINT_VNODE_INFO(VP)
        !           120: #endif /* VOLFS_DEBUG */
        !           121: 
        !           122: 
        !           123: #if DBG_VOP_TEST_LOCKS
        !           124: 
        !           125: #define        VOPDBG_IGNORE                   0
        !           126: #define        VOPDBG_LOCKED                   1
        !           127: #define        VOPDBG_UNLOCKED                 -1
        !           128: #define        VOPDBG_LOCKNOTNIL               2
        !           129: #define        VOPDBG_SAME                             3
        !           130: 
        !           131: #define        VOPDBG_ZERO     0
        !           132: #define        VOPDBG_POS      1
        !           133: 
        !           134: 
        !           135: #define        MAXDBGLOCKS             15
        !           136: 
        !           137: typedef struct VopDbgStoreRec {
        !           138:     short      id;
        !           139:     struct vnode       *vp;
        !           140:     short      inState;
        !           141:     short      outState;
        !           142:     short      errState;
        !           143:     int                inValue;
        !           144:     int                outValue;
        !           145:     } VopDbgStoreRec;
        !           146: 
        !           147: 
        !           148: /*             This sets up the test for the lock state of vnodes. The entry paramaters are:
        !           149:  *                     I = index of paramater
        !           150:  *                     VP = pointer to a vnode
        !           151:  *                     ENTRYSTATE = the inState of the lock
        !           152:  *                     EXITSTATE = the outState of the lock
        !           153:  *                     ERRORSTATE = the error state of the lock
        !           154:  *             It initializes the structure, does some preliminary validity checks, but does nothing
        !           155:  *             if the instate is set to be ignored.
        !           156:  */
        !           157: 
        !           158: #define  DBG_VOP_LOCKS_DECL(I) VopDbgStoreRec  VopDbgStore[I];short numOfLockSlots=I
        !           159: #define  DBG_VOP_LOCKS_INIT(I,VP,ENTRYSTATE,EXITSTATE,ERRORSTATE,CHECKFLAG)            \
        !           160:                if (I >= numOfLockSlots) { \
        !           161:                 PRINTIT("%s: DBG_VOP_LOCKS_INIT: Entry #%d greater than allocated slots!\n", funcname, I); \
        !           162:                }; \
        !           163:             VopDbgStore[I].id                  = I; \
        !           164:             VopDbgStore[I].vp                  = (VP); \
        !           165:             VopDbgStore[I].inState             = ENTRYSTATE; \
        !           166:             VopDbgStore[I].outState    = EXITSTATE; \
        !           167:             VopDbgStore[I].errState    = ERRORSTATE; \
        !           168:             VopDbgStore[I].inValue             = 0; \
        !           169:             VopDbgStore[I].outValue    = 0; \
        !           170:             if ((VopDbgStore[I].inState != VOPDBG_IGNORE)) {           \
        !           171:                 if ((VP) == NULL)                                                                                                              \
        !           172:                     PRINTIT ("%s: DBG_VOP_LOCK on start: Null vnode ptr\n", funcname);         \
        !           173:                 else                                                                                                                                   \
        !           174:                 VopDbgStore[I].inValue = lockstatus (&((struct volfs_vndata *)((VP)->v_data))->lock);                  \
        !           175:                 }                                                                                                                                              \
        !           176:             if ((VP) != NULL)                                                                                                                  \
        !           177:                 {                                                                                                                                              \
        !           178:                 if (CHECKFLAG==VOPDBG_POS && (VP)->v_usecount <= 0)                                    \
        !           179:                     PRINTIT("%s: BAD USECOUNT OF %d !!!!\n", funcname, (VP)->v_usecount);      \
        !           180:                 else if ((VP)->v_usecount < 0)                                                                                                         \
        !           181:                     PRINTIT("%s: BAD USECOUNT OF %d !!!!\n", funcname, (VP)->v_usecount);      \
        !           182:                 }
        !           183: #define DBG_VOP_UPDATE_VP(I, VP) \
        !           184:     VopDbgStore[I].vp                  = (VP);
        !           185: 
        !           186: 
        !           187: #define  DBG_VOP_LOCKS_TEST(status) DbgVopTest (numOfLockSlots, status, VopDbgStore, funcname);
        !           188: 
        !           189: #else   /*DBG_VOP_TEST_LOCKS */
        !           190: #define  DBG_VOP_LOCKS_DECL(A)
        !           191: #define  DBG_VOP_LOCKS_INIT(A,B,C,D,E,F)
        !           192: #define  DBG_VOP_LOCKS_TEST(a)
        !           193: #define  DBG_VOP_UPDATE_VP(I, VP)
        !           194: 
        !           195: #endif /* DBG_VOP_TEST_LOCKS */

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