diff options
author | rvb <rvb@FreeBSD.org> | 1998-08-29 21:14:52 +0000 |
---|---|---|
committer | rvb <rvb@FreeBSD.org> | 1998-08-29 21:14:52 +0000 |
commit | a085510ad54971419be613ad0bec378edbc05bf0 (patch) | |
tree | b196ef5f26c445243a683c5cf84149ae0ca41389 /sys/fs/coda/coda_subr.c | |
parent | 9e7958ad430216a2c5a56c6821c3b05f70c91e16 (diff) | |
download | FreeBSD-src-a085510ad54971419be613ad0bec378edbc05bf0.zip FreeBSD-src-a085510ad54971419be613ad0bec378edbc05bf0.tar.gz |
Very Preliminary Coda
Diffstat (limited to 'sys/fs/coda/coda_subr.c')
-rw-r--r-- | sys/fs/coda/coda_subr.c | 750 |
1 files changed, 750 insertions, 0 deletions
diff --git a/sys/fs/coda/coda_subr.c b/sys/fs/coda/coda_subr.c new file mode 100644 index 0000000..3d20e57 --- /dev/null +++ b/sys/fs/coda/coda_subr.c @@ -0,0 +1,750 @@ +/* + + Coda: an Experimental Distributed File System + Release 3.1 + + Copyright (c) 1987-1998 Carnegie Mellon University + All Rights Reserved + +Permission to use, copy, modify and distribute this software and its +documentation is hereby granted, provided that both the copyright +notice and this permission notice appear in all copies of the +software, derivative works or modified versions, and any portions +thereof, and that both notices appear in supporting documentation, and +that credit is given to Carnegie Mellon University in all documents +and publicity pertaining to direct or indirect use of this code or its +derivatives. + +CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS KNOWN TO HAVE BUGS, +SOME OF WHICH MAY HAVE SERIOUS CONSEQUENCES. CARNEGIE MELLON ALLOWS +FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION. CARNEGIE MELLON +DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER +RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE OR OF +ANY DERIVATIVE WORK. + +Carnegie Mellon encourages users of this software to return any +improvements or extensions that they make, and to grant Carnegie +Mellon the rights to redistribute these changes without encumbrance. +*/ + +/* $Header: /afs/cs/project/coda-src/cvs/coda/kernel-src/vfs/freebsd/cfs/cfs_subr.c,v 1.11 1998/08/28 18:12:18 rvb Exp $ */ + +/* + * Mach Operating System + * Copyright (c) 1989 Carnegie-Mellon University + * All rights reserved. The CMU software License Agreement specifies + * the terms and conditions for use and redistribution. + */ + +/* + * This code was written for the Coda file system at Carnegie Mellon + * University. Contributers include David Steere, James Kistler, and + * M. Satyanarayanan. */ + +/* + * HISTORY + * $Log: cfs_subr.c,v $ + * Revision 1.11 1998/08/28 18:12:18 rvb + * Now it also works on FreeBSD -current. This code will be + * committed to the FreeBSD -current and NetBSD -current + * trees. It will then be tailored to the particular platform + * by flushing conditional code. + * + * Revision 1.10 1998/08/18 17:05:16 rvb + * Don't use __RCSID now + * + * Revision 1.9 1998/08/18 16:31:41 rvb + * Sync the code for NetBSD -current; test on 1.3 later + * + * Revision 1.8 98/01/31 20:53:12 rvb + * First version that works on FreeBSD 2.2.5 + * + * Revision 1.7 98/01/23 11:53:42 rvb + * Bring RVB_CFS1_1 to HEAD + * + * Revision 1.6.2.3 98/01/23 11:21:05 rvb + * Sync with 2.2.5 + * + * Revision 1.6.2.2 97/12/16 12:40:06 rvb + * Sync with 1.3 + * + * Revision 1.6.2.1 97/12/06 17:41:21 rvb + * Sync with peters coda.h + * + * Revision 1.6 97/12/05 10:39:17 rvb + * Read CHANGES + * + * Revision 1.5.4.8 97/11/26 15:28:58 rvb + * Cant make downcall pbuf == union cfs_downcalls yet + * + * Revision 1.5.4.7 97/11/20 11:46:42 rvb + * Capture current cfs_venus + * + * Revision 1.5.4.6 97/11/18 10:27:16 rvb + * cfs_nbsd.c is DEAD!!!; integrated into cfs_vf/vnops.c + * cfs_nb_foo and cfs_foo are joined + * + * Revision 1.5.4.5 97/11/13 22:03:00 rvb + * pass2 cfs_NetBSD.h mt + * + * Revision 1.5.4.4 97/11/12 12:09:39 rvb + * reorg pass1 + * + * Revision 1.5.4.3 97/11/06 21:02:38 rvb + * first pass at ^c ^z + * + * Revision 1.5.4.2 97/10/29 16:06:27 rvb + * Kill DYING + * + * Revision 1.5.4.1 97/10/28 23:10:16 rvb + * >64Meg; venus can be killed! + * + * Revision 1.5 97/08/05 11:08:17 lily + * Removed cfsnc_replace, replaced it with a cfs_find, unhash, and + * rehash. This fixes a cnode leak and a bug in which the fid is + * not actually replaced. (cfs_namecache.c, cfsnc.h, cfs_subr.c) + * + * Revision 1.4 96/12/12 22:10:59 bnoble + * Fixed the "downcall invokes venus operation" deadlock in all known cases. + * There may be more + * + * Revision 1.3 1996/12/05 16:20:15 bnoble + * Minor debugging aids + * + * Revision 1.2 1996/01/02 16:57:01 bnoble + * Added support for Coda MiniCache and raw inode calls (final commit) + * + * Revision 1.1.2.1 1995/12/20 01:57:27 bnoble + * Added CFS-specific files + * + * Revision 3.1.1.1 1995/03/04 19:07:59 bnoble + * Branch for NetBSD port revisions + * + * Revision 3.1 1995/03/04 19:07:58 bnoble + * Bump to major revision 3 to prepare for NetBSD port + * + * Revision 2.8 1995/03/03 17:00:04 dcs + * Fixed kernel bug involving sleep and upcalls. Basically if you killed + * a job waiting on venus, the venus upcall queues got trashed. Depending + * on luck, you could kill the kernel or not. + * (mods to cfs_subr.c and cfs_mach.d) + * + * Revision 2.7 95/03/02 22:45:21 dcs + * Sun4 compatibility + * + * Revision 2.6 95/02/17 16:25:17 dcs + * These versions represent several changes: + * 1. Allow venus to restart even if outstanding references exist. + * 2. Have only one ctlvp per client, as opposed to one per mounted cfs device.d + * 3. Allow ody_expand to return many members, not just one. + * + * Revision 2.5 94/11/09 15:56:26 dcs + * Had the thread sleeping on the wrong thing! + * + * Revision 2.4 94/10/14 09:57:57 dcs + * Made changes 'cause sun4s have braindead compilers + * + * Revision 2.3 94/10/12 16:46:26 dcs + * Cleaned kernel/venus interface by removing XDR junk, plus + * so cleanup to allow this code to be more easily ported. + * + * Revision 1.2 92/10/27 17:58:22 lily + * merge kernel/latest and alpha/src/cfs + * + * Revision 2.4 92/09/30 14:16:26 mja + * Incorporated Dave Steere's fix for the GNU-Emacs bug. + * Also, included his cfs_flush routine in place of the former cfsnc_flush. + * [91/02/07 jjk] + * + * Added contributors blurb. + * [90/12/13 jjk] + * + * Hack to allow users to keep coda venus calls uninterruptible. THis + * basically prevents the Gnu-emacs bug from appearing, in which a call + * was being interrupted, and return EINTR, but gnu didn't check for the + * error and figured the file was buggered. + * [90/12/09 dcs] + * + * Revision 2.3 90/08/10 10:23:20 mrt + * Removed include of vm/vm_page.h as it no longer exists. + * [90/08/10 mrt] + * + * Revision 2.2 90/07/05 11:26:35 mrt + * Initialize name cache on first call to vcopen. + * [90/05/23 dcs] + * + * Created for the Coda File System. + * [90/05/23 dcs] + * + * Revision 1.5 90/05/31 17:01:35 dcs + * Prepare for merge with facilities kernel. + * + * Revision 1.2 90/03/19 15:56:25 dcs + * Initialize name cache on first call to vcopen. + * + * Revision 1.1 90/03/15 10:43:26 jjk + * Initial revision + * + */ + +/* NOTES: rvb + * 1. Added cfs_unmounting to mark all cnodes as being UNMOUNTING. This has to + * be done before dounmount is called. Because some of the routines that + * dounmount calls before cfs_unmounted might try to force flushes to venus. + * The vnode pager does this. + * 2. cfs_unmounting marks all cnodes scanning cfs_cache. + * 3. cfs_checkunmounting (under DEBUG) checks all cnodes by chasing the vnodes + * under the /coda mount point. + * 4. cfs_cacheprint (under DEBUG) prints names with vnode/cnode address + */ + +#include <vcfs.h> + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/malloc.h> +#include <sys/proc.h> +#include <sys/select.h> +#include <sys/mount.h> + +#include <cfs/coda.h> +#include <cfs/cnode.h> +#include <cfs/cfs_subr.h> +#include <cfs/cfsnc.h> + +#if NVCFS + +int cfs_active = 0; +int cfs_reuse = 0; +int cfs_new = 0; + +struct cnode *cfs_freelist = NULL; +struct cnode *cfs_cache[CFS_CACHESIZE]; + +#define cfshash(fid) \ + (((fid)->Volume + (fid)->Vnode) & (CFS_CACHESIZE-1)) + +#define CNODE_NEXT(cp) ((cp)->c_next) + +#define ODD(vnode) ((vnode) & 0x1) + +/* + * Allocate a cnode. + */ +struct cnode * +cfs_alloc(void) +{ + struct cnode *cp; + + if (cfs_freelist) { + cp = cfs_freelist; + cfs_freelist = CNODE_NEXT(cp); + cfs_reuse++; + } + else { + CFS_ALLOC(cp, struct cnode *, sizeof(struct cnode)); + /* NetBSD vnodes don't have any Pager info in them ('cause there are + no external pagers, duh!) */ +#define VNODE_VM_INFO_INIT(vp) /* MT */ + VNODE_VM_INFO_INIT(CTOV(cp)); + cfs_new++; + } + bzero(cp, sizeof (struct cnode)); + + return(cp); +} + +/* + * Deallocate a cnode. + */ +void +cfs_free(cp) + register struct cnode *cp; +{ + + CNODE_NEXT(cp) = cfs_freelist; + cfs_freelist = cp; +} + +/* + * Put a cnode in the hash table + */ +void +cfs_save(cp) + struct cnode *cp; +{ + CNODE_NEXT(cp) = cfs_cache[cfshash(&cp->c_fid)]; + cfs_cache[cfshash(&cp->c_fid)] = cp; +} + +/* + * Remove a cnode from the hash table + */ +void +cfs_unsave(cp) + struct cnode *cp; +{ + struct cnode *ptr; + struct cnode *ptrprev = NULL; + + ptr = cfs_cache[cfshash(&cp->c_fid)]; + while (ptr != NULL) { + if (ptr == cp) { + if (ptrprev == NULL) { + cfs_cache[cfshash(&cp->c_fid)] + = CNODE_NEXT(ptr); + } else { + CNODE_NEXT(ptrprev) = CNODE_NEXT(ptr); + } + CNODE_NEXT(cp) = (struct cnode *)NULL; + + return; + } + ptrprev = ptr; + ptr = CNODE_NEXT(ptr); + } +} + +/* + * Lookup a cnode by fid. If the cnode is dying, it is bogus so skip it. + * NOTE: this allows multiple cnodes with same fid -- dcs 1/25/95 + */ +struct cnode * +cfs_find(fid) + ViceFid *fid; +{ + struct cnode *cp; + + cp = cfs_cache[cfshash(fid)]; + while (cp) { + if ((cp->c_fid.Vnode == fid->Vnode) && + (cp->c_fid.Volume == fid->Volume) && + (cp->c_fid.Unique == fid->Unique) && + (!IS_UNMOUNTING(cp))) + { + cfs_active++; + return(cp); + } + cp = CNODE_NEXT(cp); + } + return(NULL); +} + +/* + * cfs_kill is called as a side effect to vcopen. To prevent any + * cnodes left around from an earlier run of a venus or warden from + * causing problems with the new instance, mark any outstanding cnodes + * as dying. Future operations on these cnodes should fail (excepting + * cfs_inactive of course!). Since multiple venii/wardens can be + * running, only kill the cnodes for a particular entry in the + * cfs_mnttbl. -- DCS 12/1/94 */ + +int +cfs_kill(whoIam, dcstat) + struct mount *whoIam; + enum dc_status dcstat; +{ + int hash, count = 0; + struct cnode *cp; + + /* + * Algorithm is as follows: + * Second, flush whatever vnodes we can from the name cache. + * + * Finally, step through whatever is left and mark them dying. + * This prevents any operation at all. + */ + + /* This is slightly overkill, but should work. Eventually it'd be + * nice to only flush those entries from the namecache that + * reference a vnode in this vfs. */ + cfsnc_flush(dcstat); + + for (hash = 0; hash < CFS_CACHESIZE; hash++) { + for (cp = cfs_cache[hash]; cp != NULL; cp = CNODE_NEXT(cp)) { + if (CTOV(cp)->v_mount == whoIam) { +#ifdef DEBUG + printf("cfs_kill: vp %p, cp %p\n", CTOV(cp), cp); +#endif + count++; + CFSDEBUG(CFS_FLUSH, + myprintf(("Live cnode fid %lx.%lx.%lx flags %d count %d\n", + (cp->c_fid).Volume, + (cp->c_fid).Vnode, + (cp->c_fid).Unique, + cp->c_flags, + CTOV(cp)->v_usecount)); ); + } + } + } + return count; +} + +/* + * There are two reasons why a cnode may be in use, it may be in the + * name cache or it may be executing. + */ +void +cfs_flush(dcstat) + enum dc_status dcstat; +{ + int hash; + struct cnode *cp; + + cfs_clstat.ncalls++; + cfs_clstat.reqs[CFS_FLUSH]++; + + cfsnc_flush(dcstat); /* flush files from the name cache */ + + for (hash = 0; hash < CFS_CACHESIZE; hash++) { + for (cp = cfs_cache[hash]; cp != NULL; cp = CNODE_NEXT(cp)) { + if (!ODD(cp->c_fid.Vnode)) /* only files can be executed */ + cfs_vmflush(cp); + } + } +} + +/* + * As a debugging measure, print out any cnodes that lived through a + * name cache flush. + */ +void +cfs_testflush(void) +{ + int hash; + struct cnode *cp; + + for (hash = 0; hash < CFS_CACHESIZE; hash++) { + for (cp = cfs_cache[hash]; + cp != NULL; + cp = CNODE_NEXT(cp)) { + myprintf(("Live cnode fid %lx.%lx.%lx count %d\n", + (cp->c_fid).Volume,(cp->c_fid).Vnode, + (cp->c_fid).Unique, CTOV(cp)->v_usecount)); + } + } +} + +/* + * First, step through all cnodes and mark them unmounting. + * NetBSD kernels may try to fsync them now that venus + * is dead, which would be a bad thing. + * + */ +void +cfs_unmounting(whoIam) + struct mount *whoIam; +{ + int hash; + struct cnode *cp; + + for (hash = 0; hash < CFS_CACHESIZE; hash++) { + for (cp = cfs_cache[hash]; cp != NULL; cp = CNODE_NEXT(cp)) { + if (CTOV(cp)->v_mount == whoIam) { + if (cp->c_flags & (C_LOCKED|C_WANTED)) { + printf("cfs_unmounting: Unlocking %p\n", cp); + cp->c_flags &= ~(C_LOCKED|C_WANTED); + wakeup((caddr_t) cp); + } + cp->c_flags |= C_UNMOUNTING; + } + } + } +} + +#ifdef DEBUG +cfs_checkunmounting(mp) + struct mount *mp; +{ + register struct vnode *vp, *nvp; + struct cnode *cp; + int count = 0, bad = 0; +loop: + for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) { + if (vp->v_mount != mp) + goto loop; + nvp = vp->v_mntvnodes.le_next; + cp = VTOC(vp); + count++; + if (!(cp->c_flags & C_UNMOUNTING)) { + bad++; + printf("vp %p, cp %p missed\n", vp, cp); + cp->c_flags |= C_UNMOUNTING; + } + } +} + +int +cfs_cacheprint(whoIam) + struct mount *whoIam; +{ + int hash; + struct cnode *cp; + int count = 0; + + printf("cfs_cacheprint: cfs_ctlvp %p, cp %p", cfs_ctlvp, VTOC(cfs_ctlvp)); + cfsnc_name(cfs_ctlvp); + printf("\n"); + + for (hash = 0; hash < CFS_CACHESIZE; hash++) { + for (cp = cfs_cache[hash]; cp != NULL; cp = CNODE_NEXT(cp)) { + if (CTOV(cp)->v_mount == whoIam) { + printf("cfs_cacheprint: vp %p, cp %p", CTOV(cp), cp); + cfsnc_name(cp); + printf("\n"); + count++; + } + } + } + printf("cfs_cacheprint: count %d\n", count); +} +#endif + +/* + * There are 6 cases where invalidations occur. The semantics of each + * is listed here. + * + * CFS_FLUSH -- flush all entries from the name cache and the cnode cache. + * CFS_PURGEUSER -- flush all entries from the name cache for a specific user + * This call is a result of token expiration. + * + * The next two are the result of callbacks on a file or directory. + * CFS_ZAPDIR -- flush the attributes for the dir from its cnode. + * Zap all children of this directory from the namecache. + * CFS_ZAPFILE -- flush the attributes for a file. + * + * The fifth is a result of Venus detecting an inconsistent file. + * CFS_PURGEFID -- flush the attribute for the file + * If it is a dir (odd vnode), purge its + * children from the namecache + * remove the file from the namecache. + * + * The sixth allows Venus to replace local fids with global ones + * during reintegration. + * + * CFS_REPLACE -- replace one ViceFid with another throughout the name cache + */ + +int handleDownCall(opcode, out) + int opcode; union outputArgs *out; +{ + int error; + + /* Handle invalidate requests. */ + switch (opcode) { + case CFS_FLUSH : { + + cfs_flush(IS_DOWNCALL); + + CFSDEBUG(CFS_FLUSH,cfs_testflush();) /* print remaining cnodes */ + return(0); + } + + case CFS_PURGEUSER : { + cfs_clstat.ncalls++; + cfs_clstat.reqs[CFS_PURGEUSER]++; + + /* XXX - need to prevent fsync's */ + cfsnc_purge_user(out->cfs_purgeuser.cred.cr_uid, IS_DOWNCALL); + return(0); + } + + case CFS_ZAPFILE : { + struct cnode *cp; + + error = 0; + cfs_clstat.ncalls++; + cfs_clstat.reqs[CFS_ZAPFILE]++; + + cp = cfs_find(&out->cfs_zapfile.CodaFid); + if (cp != NULL) { + vref(CTOV(cp)); + + cp->c_flags &= ~C_VATTR; + if (CTOV(cp)->v_flag & VTEXT) + error = cfs_vmflush(cp); + CFSDEBUG(CFS_ZAPFILE, myprintf(("zapfile: fid = (%lx.%lx.%lx), + refcnt = %d, error = %d\n", + cp->c_fid.Volume, + cp->c_fid.Vnode, + cp->c_fid.Unique, + CTOV(cp)->v_usecount - 1, error));); + if (CTOV(cp)->v_usecount == 1) { + cp->c_flags |= C_PURGING; + } + vrele(CTOV(cp)); + } + + return(error); + } + + case CFS_ZAPDIR : { + struct cnode *cp; + + cfs_clstat.ncalls++; + cfs_clstat.reqs[CFS_ZAPDIR]++; + + cp = cfs_find(&out->cfs_zapdir.CodaFid); + if (cp != NULL) { + vref(CTOV(cp)); + + cp->c_flags &= ~C_VATTR; + cfsnc_zapParentfid(&out->cfs_zapdir.CodaFid, IS_DOWNCALL); + + CFSDEBUG(CFS_ZAPDIR, myprintf(("zapdir: fid = (%lx.%lx.%lx), + refcnt = %d\n",cp->c_fid.Volume, + cp->c_fid.Vnode, + cp->c_fid.Unique, + CTOV(cp)->v_usecount - 1));); + if (CTOV(cp)->v_usecount == 1) { + cp->c_flags |= C_PURGING; + } + vrele(CTOV(cp)); + } + + return(0); + } + + case CFS_ZAPVNODE : { + cfs_clstat.ncalls++; + cfs_clstat.reqs[CFS_ZAPVNODE]++; + + myprintf(("CFS_ZAPVNODE: Called, but uniplemented\n")); + /* + * Not that below we must really translate the returned coda_cred to + * a netbsd cred. This is a bit muddled at present and the cfsnc_zapnode + * is further unimplemented, so punt! + * I suppose we could use just the uid. + */ + /* cfsnc_zapvnode(&out->cfs_zapvnode.VFid, &out->cfs_zapvnode.cred, + IS_DOWNCALL); */ + return(0); + } + + case CFS_PURGEFID : { + struct cnode *cp; + + error = 0; + cfs_clstat.ncalls++; + cfs_clstat.reqs[CFS_PURGEFID]++; + + cp = cfs_find(&out->cfs_purgefid.CodaFid); + if (cp != NULL) { + vref(CTOV(cp)); + if (ODD(out->cfs_purgefid.CodaFid.Vnode)) { /* Vnode is a directory */ + cfsnc_zapParentfid(&out->cfs_purgefid.CodaFid, + IS_DOWNCALL); + } + cp->c_flags &= ~C_VATTR; + cfsnc_zapfid(&out->cfs_purgefid.CodaFid, IS_DOWNCALL); + if (!(ODD(out->cfs_purgefid.CodaFid.Vnode)) + && (CTOV(cp)->v_flag & VTEXT)) { + + error = cfs_vmflush(cp); + } + CFSDEBUG(CFS_PURGEFID, myprintf(("purgefid: fid = (%lx.%lx.%lx), refcnt = %d, error = %d\n", + cp->c_fid.Volume, cp->c_fid.Vnode, + cp->c_fid.Unique, + CTOV(cp)->v_usecount - 1, error));); + if (CTOV(cp)->v_usecount == 1) { + cp->c_flags |= C_PURGING; + } + vrele(CTOV(cp)); + } + return(error); + } + + case CFS_REPLACE : { + struct cnode *cp = NULL; + + cfs_clstat.ncalls++; + cfs_clstat.reqs[CFS_REPLACE]++; + + cp = cfs_find(&out->cfs_replace.OldFid); + if (cp != NULL) { + /* remove the cnode from the hash table, replace the fid, and reinsert */ + vref(CTOV(cp)); + cfs_unsave(cp); + cp->c_fid = out->cfs_replace.NewFid; + cfs_save(cp); + + CFSDEBUG(CFS_REPLACE, myprintf(("replace: oldfid = (%lx.%lx.%lx), newfid = (%lx.%lx.%lx), cp = %p\n", + out->cfs_replace.OldFid.Volume, + out->cfs_replace.OldFid.Vnode, + out->cfs_replace.OldFid.Unique, + cp->c_fid.Volume, cp->c_fid.Vnode, + cp->c_fid.Unique, cp));) + vrele(CTOV(cp)); + } + return (0); + } + default: + myprintf(("handleDownCall: unknown opcode %d\n", opcode)); + return (EINVAL); + } +} + +/* cfs_grab_vnode: lives in either cfs_mach.c or cfs_nbsd.c */ + +int +cfs_vmflush(cp) + struct cnode *cp; +{ +#if 0 + /* old code */ + /* Unset <device, inode> so that page_read doesn't try to use + (possibly) invalid cache file. */ + cp->c_device = 0; + cp->c_inode = 0; + + return(inode_uncache_try(VTOI(CTOV(cp))) ? 0 : ETXTBSY); +#else /* __NetBSD__ || __FreeBSD__ */ + return 0; +#endif /* __NetBSD__ || __FreeBSD__ */ +} + + +/* + * kernel-internal debugging switches + */ + +void cfs_debugon(void) +{ + cfsdebug = -1; + cfsnc_debug = -1; + cfs_vnop_print_entry = 1; + cfs_psdev_print_entry = 1; + cfs_vfsop_print_entry = 1; +} + +void cfs_debugoff(void) +{ + cfsdebug = 0; + cfsnc_debug = 0; + cfs_vnop_print_entry = 0; + cfs_psdev_print_entry = 0; + cfs_vfsop_print_entry = 0; +} + +/* + * Utilities used by both client and server + * Standard levels: + * 0) no debugging + * 1) hard failures + * 2) soft failures + * 3) current test software + * 4) main procedure entry points + * 5) main procedure exit points + * 6) utility procedure entry points + * 7) utility procedure exit points + * 8) obscure procedure entry points + * 9) obscure procedure exit points + * 10) random stuff + * 11) all <= 1 + * 12) all <= 2 + * 13) all <= 3 + * ... + */ + + +#endif /* NVCFS */ |