/* $NetBSD: coda_subr.c,v 1.31 2015/01/06 11:24:46 hannken Exp $ */ /* * * 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. * * @(#) coda/coda_subr.c,v 1.1.1.1 1998/08/29 21:26:45 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. */ /* 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 __KERNEL_RCSID(0, "$NetBSD: coda_subr.c,v 1.31 2015/01/06 11:24:46 hannken Exp $"); #include #include #include #include #include #include #include #include #include #include #include int codadebug = 0; int coda_printf_delay = 0; /* in microseconds */ int coda_vnop_print_entry = 0; int coda_vfsop_print_entry = 0; #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 struct vnode *coda_ctlvp; /* * Lookup a cnode by fid. If the cnode is dying, it is bogus so skip it. * The cnode is returned locked with the vnode referenced. */ struct cnode * coda_find(CodaFid *fid) { int i; struct vnode *vp; struct cnode *cp; for (i = 0; i < NVCODA; i++) { if (!coda_mnttbl[i].mi_started) continue; if (vcache_get(coda_mnttbl[i].mi_vfsp, fid, sizeof(CodaFid), &vp) != 0) continue; mutex_enter(vp->v_interlock); cp = VTOC(vp); if (vp->v_type == VNON || cp == NULL || IS_UNMOUNTING(cp)) { mutex_exit(vp->v_interlock); vrele(vp); continue; } mutex_enter(&cp->c_lock); mutex_exit(vp->v_interlock); return cp; } return NULL; } /* * Iterate over all nodes attached to coda mounts. */ static void coda_iterate(bool (*f)(void *, struct vnode *), void *cl) { int i; struct vnode_iterator *marker; struct vnode *vp; for (i = 0; i < NVCODA; i++) { if (coda_mnttbl[i].mi_vfsp == NULL) continue; vfs_vnode_iterator_init(coda_mnttbl[i].mi_vfsp, &marker); while ((vp = vfs_vnode_iterator_next(marker, f, cl)) != NULL) vrele(vp); vfs_vnode_iterator_destroy(marker); } } /* * 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 */ static bool coda_kill_selector(void *cl, struct vnode *vp) { int *count = cl; (*count)++; return false; } int coda_kill(struct mount *whoIam, enum dc_status dcstat) { int count = 0; struct vnode_iterator *marker; /* * Algorithm is as follows: * Second, flush whatever vnodes we can from the name cache. */ /* 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. */ coda_nc_flush(dcstat); vfs_vnode_iterator_init(whoIam, &marker); vfs_vnode_iterator_next(marker, coda_kill_selector, &count); vfs_vnode_iterator_destroy(marker); 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. */ static bool coda_flush_selector(void *cl, struct vnode *vp) { struct cnode *cp = VTOC(vp); if (cp != NULL && !IS_DIR(cp->c_fid)) /* only files can be executed */ coda_vmflush(cp); return false; } void coda_flush(enum dc_status dcstat) { coda_clstat.ncalls++; coda_clstat.reqs[CODA_FLUSH]++; coda_nc_flush(dcstat); /* flush files from the name cache */ coda_iterate(coda_flush_selector, NULL); } /* * As a debugging measure, print out any cnodes that lived through a * name cache flush. */ static bool coda_testflush_selector(void *cl, struct vnode *vp) { struct cnode *cp = VTOC(vp); if (cp != NULL) myprintf(("Live cnode fid %s count %d\n", coda_f2s(&cp->c_fid), CTOV(cp)->v_usecount)); return false; } void coda_testflush(void) { coda_iterate(coda_testflush_selector, NULL); } /* * 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. * */ static bool coda_unmounting_selector(void *cl, struct vnode *vp) { struct cnode *cp = VTOC(vp); if (cp) cp->c_flags |= C_UNMOUNTING; return false; } void coda_unmounting(struct mount *whoIam) { struct vnode_iterator *marker; vfs_vnode_iterator_init(whoIam, &marker); vfs_vnode_iterator_next(marker, coda_unmounting_selector, NULL); vfs_vnode_iterator_destroy(marker); } #ifdef DEBUG static bool coda_checkunmounting_selector(void *cl, struct vnode *vp) { struct cnode *cp = VTOC(vp); if (cp && !(cp->c_flags & C_UNMOUNTING)) { printf("vp %p, cp %p missed\n", vp, cp); cp->c_flags |= C_UNMOUNTING; } return false; } void coda_checkunmounting(struct mount *mp) { struct vnode_iterator *marker; vfs_vnode_iterator_init(mp, &marker); vfs_vnode_iterator_next(marker, coda_checkunmounting_selector, NULL); vfs_vnode_iterator_destroy(marker); } void coda_cacheprint(struct mount *whoIam) { struct vnode *vp; struct vnode_iterator *marker; int count = 0; printf("coda_cacheprint: coda_ctlvp %p, cp %p", coda_ctlvp, VTOC(coda_ctlvp)); coda_nc_name(VTOC(coda_ctlvp)); printf("\n"); vfs_vnode_iterator_init(whoIam, &marker); while ((vp = vfs_vnode_iterator_next(marker, NULL, NULL)) != NULL) { printf("coda_cacheprint: vp %p, cp %p", vp, VTOC(vp)); coda_nc_name(VTOC(vp)); printf("\n"); count++; vrele(vp); } printf("coda_cacheprint: count %d\n", count); vfs_vnode_iterator_destroy(marker); } #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(int opcode, union outputArgs *out) { int error; /* Handle invalidate requests. */ switch (opcode) { case CODA_FLUSH : { coda_flush(IS_DOWNCALL); CODADEBUG(CODA_FLUSH,coda_testflush();) /* print remaining cnodes */ return(0); } case CODA_PURGEUSER : { coda_clstat.ncalls++; coda_clstat.reqs[CODA_PURGEUSER]++; /* XXX - need to prevent fsync's */ #ifdef CODA_COMPAT_5 coda_nc_purge_user(out->coda_purgeuser.cred.cr_uid, IS_DOWNCALL); #else coda_nc_purge_user(out->coda_purgeuser.uid, IS_DOWNCALL); #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) { cp->c_flags &= ~C_VATTR; if (CTOV(cp)->v_iflag & VI_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 (CTOV(cp)->v_usecount == 1) { cp->c_flags |= C_PURGING; } mutex_exit(&cp->c_lock); 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) { cp->c_flags &= ~C_VATTR; coda_nc_zapParentfid(&out->coda_zapdir.Fid, IS_DOWNCALL); CODADEBUG(CODA_ZAPDIR, myprintf(( "zapdir: fid = %s, refcnt = %d\n", coda_f2s(&cp->c_fid), CTOV(cp)->v_usecount - 1));); if (CTOV(cp)->v_usecount == 1) { cp->c_flags |= C_PURGING; } mutex_exit(&cp->c_lock); 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) { if (IS_DIR(out->coda_purgefid.Fid)) { /* Vnode is a directory */ coda_nc_zapParentfid(&out->coda_purgefid.Fid, IS_DOWNCALL); } cp->c_flags &= ~C_VATTR; coda_nc_zapfid(&out->coda_purgefid.Fid, IS_DOWNCALL); if (!(IS_DIR(out->coda_purgefid.Fid)) && (CTOV(cp)->v_iflag & VI_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 (CTOV(cp)->v_usecount == 1) { cp->c_flags |= C_PURGING; } mutex_exit(&cp->c_lock); 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) { error = vcache_rekey_enter(CTOV(cp)->v_mount, CTOV(cp), &out->coda_replace.OldFid, sizeof(CodaFid), &out->coda_replace.NewFid, sizeof(CodaFid)); if (error) { mutex_exit(&cp->c_lock); vrele(CTOV(cp)); return error; } cp->c_fid = out->coda_replace.NewFid; vcache_rekey_exit(CTOV(cp)->v_mount, CTOV(cp), &out->coda_replace.OldFid, sizeof(CodaFid), &cp->c_fid, sizeof(CodaFid)); CODADEBUG(CODA_REPLACE, myprintf(( "replace: oldfid = %s, newfid = %s, cp = %p\n", coda_f2s(&out->coda_replace.OldFid), coda_f2s(&cp->c_fid), cp));) mutex_exit(&cp->c_lock); vrele(CTOV(cp)); } return (0); } default: myprintf(("handleDownCall: unknown opcode %d\n", opcode)); return (EINVAL); } } /* coda_grab_vnode: lives in either cfs_mach.c or cfs_nbsd.c */ int coda_vmflush(struct cnode *cp) { return 0; } /* * kernel-internal debugging switches */ void coda_debugon(void) { codadebug = -1; coda_nc_debug = -1; coda_vnop_print_entry = 1; coda_psdev_print_entry = 1; coda_vfsop_print_entry = 1; } void coda_debugoff(void) { codadebug = 0; coda_nc_debug = 0; coda_vnop_print_entry = 0; coda_psdev_print_entry = 0; coda_vfsop_print_entry = 0; } /* How to print a ucred */ void coda_print_cred(kauth_cred_t cred) { uint16_t ngroups; int i; myprintf(("ref %d\tuid %d\n", kauth_cred_getrefcnt(cred), kauth_cred_geteuid(cred))); ngroups = kauth_cred_ngroups(cred); for (i=0; i < ngroups; i++) myprintf(("\tgroup %d: (%d)\n", i, kauth_cred_group(cred, i))); myprintf(("\n")); } /* * 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 * ... */