636 lines
16 KiB
C
636 lines
16 KiB
C
/*-
|
|
* 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.
|
|
*
|
|
* @(#) src/sys/coda/coda_subr.c,v 1.1.1.1 1998/08/29 21:14:52 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 filesystem at Carnegie Mellon
|
|
* University. Contributers include David Steere, James Kistler, and
|
|
* M. Satyanarayanan.
|
|
*/
|
|
|
|
/*-
|
|
* NOTES: rvb
|
|
* 1. Added coda_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 coda_unmounted might try to
|
|
* force flushes to venus. The vnode pager does this.
|
|
* 2. coda_unmounting marks all cnodes scanning coda_cache.
|
|
* 3. cfs_checkunmounting (under DEBUG) checks all cnodes by chasing the
|
|
* vnodes under the /coda mount point.
|
|
* 4. coda_cacheprint (under DEBUG) prints names with vnode/cnode address.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/mount.h>
|
|
|
|
#include <fs/coda/coda.h>
|
|
#include <fs/coda/cnode.h>
|
|
#include <fs/coda/coda_subr.h>
|
|
|
|
static int coda_active = 0;
|
|
static int coda_reuse = 0;
|
|
static int coda_new = 0;
|
|
|
|
static struct cnode *coda_freelist = NULL;
|
|
static struct cnode *coda_cache[CODA_CACHESIZE];
|
|
|
|
#define CNODE_NEXT(cp) ((cp)->c_next)
|
|
|
|
#ifdef CODA_COMPAT_5
|
|
#define coda_hash(fid) (((fid)->Volume + (fid)->Vnode) & (CODA_CACHESIZE-1))
|
|
#define IS_DIR(cnode) (cnode.Vnode & 0x1)
|
|
#else
|
|
#define coda_hash(fid) (coda_f2i(fid) & (CODA_CACHESIZE-1))
|
|
#define IS_DIR(cnode) (cnode.opaque[2] & 0x1)
|
|
#endif
|
|
|
|
/*
|
|
* Allocate a cnode.
|
|
*/
|
|
struct cnode *
|
|
coda_alloc(void)
|
|
{
|
|
struct cnode *cp;
|
|
|
|
if (coda_freelist != NULL) {
|
|
cp = coda_freelist;
|
|
coda_freelist = CNODE_NEXT(cp);
|
|
coda_reuse++;
|
|
} else {
|
|
CODA_ALLOC(cp, struct cnode *, sizeof(struct cnode));
|
|
|
|
/*
|
|
* FreeBSD 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));
|
|
coda_new++;
|
|
}
|
|
bzero(cp, sizeof (struct cnode));
|
|
return (cp);
|
|
}
|
|
|
|
/*
|
|
* Deallocate a cnode.
|
|
*/
|
|
void
|
|
coda_free(struct cnode *cp)
|
|
{
|
|
|
|
CNODE_NEXT(cp) = coda_freelist;
|
|
coda_freelist = cp;
|
|
}
|
|
|
|
/*
|
|
* Put a cnode in the hash table.
|
|
*/
|
|
void
|
|
coda_save(struct cnode *cp)
|
|
{
|
|
|
|
CNODE_NEXT(cp) = coda_cache[coda_hash(&cp->c_fid)];
|
|
coda_cache[coda_hash(&cp->c_fid)] = cp;
|
|
}
|
|
|
|
/*
|
|
* Remove a cnode from the hash table.
|
|
*/
|
|
void
|
|
coda_unsave(struct cnode *cp)
|
|
{
|
|
struct cnode *ptr;
|
|
struct cnode *ptrprev = NULL;
|
|
|
|
ptr = coda_cache[coda_hash(&cp->c_fid)];
|
|
while (ptr != NULL) {
|
|
if (ptr == cp) {
|
|
if (ptrprev == NULL)
|
|
coda_cache[coda_hash(&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 *
|
|
coda_find(CodaFid *fid)
|
|
{
|
|
struct cnode *cp;
|
|
|
|
cp = coda_cache[coda_hash(fid)];
|
|
while (cp) {
|
|
if (coda_fid_eq(&(cp->c_fid), fid) && (!IS_UNMOUNTING(cp))) {
|
|
coda_active++;
|
|
return (cp);
|
|
}
|
|
cp = CNODE_NEXT(cp);
|
|
}
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Clear all cached access control decisions from Coda.
|
|
*/
|
|
static void
|
|
coda_acccache_purge(struct mount *mnt)
|
|
{
|
|
struct cnode *cp;
|
|
int hash;
|
|
|
|
for (hash = 0; hash < CODA_CACHESIZE; hash++) {
|
|
for (cp = coda_cache[hash]; cp != NULL;
|
|
cp = CNODE_NEXT(cp)) {
|
|
if (CTOV(cp)->v_mount == mnt && VALID_ACCCACHE(cp)) {
|
|
CODADEBUG(CODA_FLUSH, myprintf(("acccache "
|
|
"purge fid %s uid %d mode 0x%x\n",
|
|
coda_f2s(&cp->c_fid), cp->c_cached_uid,
|
|
(int)cp->c_cached_mode)););
|
|
cp->c_flags &= ~C_ACCCACHE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* When a user loses their tokens (or other related events), we invalidate
|
|
* any cached access rights in the access cache. In the Linux version of
|
|
* Coda, we maintain a global epoch and simply bump it to invalidate all
|
|
* cached results generated in the epoch. For now, we walk all cnodes and
|
|
* manually invalidate just that uid in FreeBSD.
|
|
*/
|
|
static void
|
|
coda_acccache_purgeuser(struct mount *mnt, uid_t uid)
|
|
{
|
|
struct cnode *cp;
|
|
int hash;
|
|
|
|
for (hash = 0; hash < CODA_CACHESIZE; hash++) {
|
|
for (cp = coda_cache[hash]; cp != NULL;
|
|
cp = CNODE_NEXT(cp)) {
|
|
if (CTOV(cp)->v_mount == mnt &&
|
|
VALID_ACCCACHE(cp) && (cp->c_cached_uid == uid)) {
|
|
CODADEBUG(CODA_PURGEUSER, myprintf((
|
|
"acccache purgeuser fid %s uid %d mode "
|
|
"0x%x\n", coda_f2s(&cp->c_fid),
|
|
cp->c_cached_uid, (int)cp->c_cached_mode)););
|
|
cp->c_flags &= ~C_ACCCACHE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* coda_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 coda_inactive of
|
|
* course!). Since multiple venii/wardens can be running, only kill the
|
|
* cnodes for a particular entry in the coda_mnttbl. -- DCS 12/1/94
|
|
*
|
|
* XXX: I don't believe any special behavior is required with respect to the
|
|
* global namecache here, as /coda will have unmounted and hence cache_flush
|
|
* will have run...?
|
|
*/
|
|
int
|
|
coda_kill(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.
|
|
*
|
|
* XXXRW: Perhaps we no longer need to purge the name cache when
|
|
* using the VFS name cache, as unmount will do that.
|
|
*/
|
|
cache_purgevfs(whoIam);
|
|
for (hash = 0; hash < CODA_CACHESIZE; hash++) {
|
|
for (cp = coda_cache[hash];cp != NULL;
|
|
cp = CNODE_NEXT(cp)) {
|
|
if (CTOV(cp)->v_mount == whoIam) {
|
|
#ifdef DEBUG
|
|
printf("coda_kill: vp %p, cp %p\n", CTOV(cp),
|
|
cp);
|
|
#endif
|
|
count++;
|
|
CODADEBUG(CODA_FLUSH, myprintf(("Live cnode "
|
|
"fid %s flags %d count %d\n",
|
|
coda_f2s(&cp->c_fid), cp->c_flags,
|
|
vrefcnt(CTOV(cp)))););
|
|
}
|
|
}
|
|
}
|
|
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
|
|
coda_flush(struct coda_mntinfo *mnt, enum dc_status dcstat)
|
|
{
|
|
int hash;
|
|
struct cnode *cp;
|
|
|
|
coda_clstat.ncalls++;
|
|
coda_clstat.reqs[CODA_FLUSH]++;
|
|
|
|
coda_acccache_purge(mnt->mi_vfsp);
|
|
cache_purgevfs(mnt->mi_vfsp);
|
|
for (hash = 0; hash < CODA_CACHESIZE; hash++) {
|
|
for (cp = coda_cache[hash]; cp != NULL;
|
|
cp = CNODE_NEXT(cp)) {
|
|
/*
|
|
* Only files that can be executed need to be flushed
|
|
* from the VM.
|
|
*
|
|
* NOTE: Currently this doesn't do anything, but
|
|
* perhaps it should?
|
|
*/
|
|
if (!IS_DIR(cp->c_fid))
|
|
coda_vmflush(cp);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* As a debugging measure, print out any cnodes that lived through a name
|
|
* cache flush.
|
|
*/
|
|
void
|
|
coda_testflush(void)
|
|
{
|
|
int hash;
|
|
struct cnode *cp;
|
|
|
|
for (hash = 0; hash < CODA_CACHESIZE; hash++) {
|
|
for (cp = coda_cache[hash]; cp != NULL;
|
|
cp = CNODE_NEXT(cp))
|
|
myprintf(("Live cnode fid %s count %d\n",
|
|
coda_f2s(&cp->c_fid), CTOV(cp)->v_usecount));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* First, step through all cnodes and mark them unmounting. FreeBSD kernels
|
|
* may try to fsync them now that venus is dead, which would be a bad thing.
|
|
*/
|
|
void
|
|
coda_unmounting(struct mount *whoIam)
|
|
{
|
|
int hash;
|
|
struct cnode *cp;
|
|
|
|
for (hash = 0; hash < CODA_CACHESIZE; hash++) {
|
|
for (cp = coda_cache[hash]; cp != NULL;
|
|
cp = CNODE_NEXT(cp)) {
|
|
if (CTOV(cp)->v_mount == whoIam) {
|
|
if (cp->c_flags & (C_LOCKED|C_WANTED)) {
|
|
printf("coda_unmounting: Unlocking "
|
|
"%p\n", cp);
|
|
cp->c_flags &= ~(C_LOCKED|C_WANTED);
|
|
wakeup((caddr_t) cp);
|
|
}
|
|
cp->c_flags |= C_UNMOUNTING;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
coda_checkunmounting(struct mount *mp)
|
|
{
|
|
struct vnode *vp, *nvp;
|
|
struct cnode *cp;
|
|
int count = 0, bad = 0;
|
|
|
|
MNT_ILOCK(mp);
|
|
MNT_VNODE_FOREACH(vp, mp, nvp) {
|
|
VI_LOCK(vp);
|
|
if (vp->v_iflag & VI_DOOMED) {
|
|
VI_UNLOCK(vp);
|
|
continue;
|
|
}
|
|
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;
|
|
}
|
|
VI_UNLOCK(vp);
|
|
}
|
|
MNT_IUNLOCK(mp);
|
|
}
|
|
|
|
void
|
|
coda_cacheprint(struct mount *whoIam)
|
|
{
|
|
int hash;
|
|
struct cnode *cp;
|
|
int count = 0;
|
|
|
|
printf("coda_cacheprint: coda_ctlvp %p, cp %p", coda_ctlvp,
|
|
VTOC(coda_ctlvp));
|
|
|
|
#if 0
|
|
coda_nc_name(VTOC(coda_ctlvp));
|
|
#endif
|
|
printf("\n");
|
|
for (hash = 0; hash < CODA_CACHESIZE; hash++) {
|
|
for (cp = coda_cache[hash]; cp != NULL;
|
|
cp = CNODE_NEXT(cp)) {
|
|
if (CTOV(cp)->v_mount == whoIam) {
|
|
printf("coda_cacheprint: vp %p, cp %p",
|
|
CTOV(cp), cp);
|
|
#if 0
|
|
coda_nc_name(cp);
|
|
#endif
|
|
printf("\n");
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
printf("coda_cacheprint: count %d\n", count);
|
|
}
|
|
#endif
|
|
|
|
/*-
|
|
* There are 6 cases where invalidations occur. The semantics of each is
|
|
* listed here:
|
|
*
|
|
* CODA_FLUSH -- Flush all entries from the name cache and the cnode
|
|
* cache.
|
|
*
|
|
* CODA_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:
|
|
*
|
|
* CODA_ZAPDIR -- Flush the attributes for the dir from its cnode. Zap
|
|
* all children of this directory from the namecache.
|
|
*
|
|
* CODA_ZAPFILE -- Flush the attributes for a file.
|
|
*
|
|
* The fifth is a result of Venus detecting an inconsistent file:
|
|
*
|
|
* CODA_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.
|
|
*
|
|
* CODA_REPLACE -- Replace one CodaFid with another throughout the name
|
|
* cache.
|
|
*/
|
|
int
|
|
handleDownCall(struct coda_mntinfo *mnt, int opcode, union outputArgs *out)
|
|
{
|
|
int error;
|
|
|
|
/*
|
|
* Handle invalidate requests.
|
|
*/
|
|
switch (opcode) {
|
|
case CODA_FLUSH: {
|
|
coda_flush(mnt, IS_DOWNCALL);
|
|
|
|
/* Print any remaining cnodes. */
|
|
CODADEBUG(CODA_FLUSH, coda_testflush(););
|
|
return (0);
|
|
}
|
|
|
|
case CODA_PURGEUSER: {
|
|
coda_clstat.ncalls++;
|
|
coda_clstat.reqs[CODA_PURGEUSER]++;
|
|
|
|
/* XXX - need to prevent fsync's. */
|
|
|
|
/*
|
|
* Purge any access cache entries for the uid.
|
|
*/
|
|
#ifdef CODA_COMPAT_5
|
|
coda_acccache_purgeuser(mnt->mi_vfsp,
|
|
out->coda_purgeuser.cred.cr_uid);
|
|
#else
|
|
coda_acccache_purgeuser(mnt->mi_vfsp,
|
|
out->coda_purgeuser.uid);
|
|
#endif
|
|
return (0);
|
|
}
|
|
|
|
case CODA_ZAPFILE: {
|
|
struct cnode *cp;
|
|
|
|
error = 0;
|
|
coda_clstat.ncalls++;
|
|
coda_clstat.reqs[CODA_ZAPFILE]++;
|
|
cp = coda_find(&out->coda_zapfile.Fid);
|
|
if (cp != NULL) {
|
|
vref(CTOV(cp));
|
|
cache_purge(CTOV(cp));
|
|
cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
|
|
ASSERT_VOP_LOCKED(CTOV(cp), "coda HandleDownCall");
|
|
if (CTOV(cp)->v_vflag & VV_TEXT)
|
|
error = coda_vmflush(cp);
|
|
CODADEBUG(CODA_ZAPFILE,
|
|
myprintf(("zapfile: fid = %s, refcnt = %d, error = "
|
|
"%d\n", coda_f2s(&cp->c_fid),
|
|
CTOV(cp)->v_usecount - 1, error)););
|
|
if (vrefcnt(CTOV(cp)) == 1)
|
|
cp->c_flags |= C_PURGING;
|
|
vrele(CTOV(cp));
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
case CODA_ZAPDIR: {
|
|
struct cnode *cp;
|
|
|
|
coda_clstat.ncalls++;
|
|
coda_clstat.reqs[CODA_ZAPDIR]++;
|
|
cp = coda_find(&out->coda_zapdir.Fid);
|
|
if (cp != NULL) {
|
|
vref(CTOV(cp));
|
|
cache_purge(CTOV(cp));
|
|
cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
|
|
CODADEBUG(CODA_ZAPDIR, myprintf(("zapdir: fid = %s, "
|
|
"refcnt = %d\n", coda_f2s(&cp->c_fid),
|
|
CTOV(cp)->v_usecount - 1)););
|
|
if (vrefcnt(CTOV(cp)) == 1)
|
|
cp->c_flags |= C_PURGING;
|
|
vrele(CTOV(cp));
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
case CODA_PURGEFID: {
|
|
struct cnode *cp;
|
|
|
|
error = 0;
|
|
coda_clstat.ncalls++;
|
|
coda_clstat.reqs[CODA_PURGEFID]++;
|
|
cp = coda_find(&out->coda_purgefid.Fid);
|
|
if (cp != NULL) {
|
|
vref(CTOV(cp));
|
|
cache_purge(CTOV(cp));
|
|
cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
|
|
ASSERT_VOP_LOCKED(CTOV(cp), "coda HandleDownCall");
|
|
if (!(IS_DIR(out->coda_purgefid.Fid))
|
|
&& (CTOV(cp)->v_vflag & VV_TEXT))
|
|
error = coda_vmflush(cp);
|
|
CODADEBUG(CODA_PURGEFID, myprintf(("purgefid: fid "
|
|
"= %s, refcnt = %d, error = %d\n",
|
|
coda_f2s(&cp->c_fid),
|
|
CTOV(cp)->v_usecount - 1, error)););
|
|
if (vrefcnt(CTOV(cp)) == 1)
|
|
cp->c_flags |= C_PURGING;
|
|
vrele(CTOV(cp));
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
case CODA_REPLACE: {
|
|
struct cnode *cp = NULL;
|
|
|
|
coda_clstat.ncalls++;
|
|
coda_clstat.reqs[CODA_REPLACE]++;
|
|
cp = coda_find(&out->coda_replace.OldFid);
|
|
if (cp != NULL) {
|
|
/*
|
|
* Remove the cnode from the hash table, replace the
|
|
* fid, and reinsert. Clear the attribute cache as
|
|
* the "inode number" may have changed (it's just a
|
|
* hash of the fid, and the fid is changing).
|
|
*/
|
|
vref(CTOV(cp));
|
|
coda_unsave(cp);
|
|
cp->c_fid = out->coda_replace.NewFid;
|
|
cp->c_flags &= ~C_VATTR;
|
|
coda_save(cp);
|
|
CODADEBUG(CODA_REPLACE, myprintf(("replace: oldfid "
|
|
"= %s, newfid = %s, cp = %p\n",
|
|
coda_f2s(&out->coda_replace.OldFid),
|
|
coda_f2s(&cp->c_fid), cp)););
|
|
vrele(CTOV(cp));
|
|
}
|
|
return (0);
|
|
}
|
|
default:
|
|
myprintf(("handleDownCall: unknown opcode %d\n", opcode));
|
|
return (EINVAL);
|
|
}
|
|
}
|
|
|
|
int
|
|
coda_vmflush(struct cnode *cp)
|
|
{
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Kernel-internal debugging switches.
|
|
*/
|
|
void
|
|
coda_debugon(void)
|
|
{
|
|
|
|
codadebug = -1;
|
|
coda_vnop_print_entry = 1;
|
|
coda_psdev_print_entry = 1;
|
|
coda_vfsop_print_entry = 1;
|
|
}
|
|
|
|
void
|
|
coda_debugoff(void)
|
|
{
|
|
|
|
codadebug = 0;
|
|
coda_vnop_print_entry = 0;
|
|
coda_psdev_print_entry = 0;
|
|
coda_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
|
|
* ...
|
|
*/
|