File:  [DragonFly] / src / sys / vfs / nwfs / nwfs_node.c
Revision 1.10: download - view: text, annotated - select for diffs
Mon Mar 1 06:33:22 2004 UTC (10 years, 6 months ago) by dillon
Branches: MAIN
CVS tags: HEAD
Newtoken commit.  Change the token implementation as follows:  (1) Obtaining
a token no longer enters a critical section.  (2) tokens can be held through
schedular switches and blocking conditions and are effectively released and
reacquired on resume.  Thus tokens serialize access only while the thread
is actually running.  Serialization is not broken by preemptive interrupts.
That is, interrupt threads which preempt do no release the preempted thread's
tokens.  (3) Unlike spl's, tokens will interlock w/ interrupt threads on
the same or on a different cpu.

The vnode interlock code has been rewritten and the API has changed.  The
mountlist vnode scanning code has been consolidated and all known races have
been fixed.  The vnode interlock is now a pool token.

The code that frees unreferenced vnodes whos last VM page has been freed has
been moved out of the low level vm_page_free() code and moved to the
periodic filesystem sycer code in vfs_msycn().

The SMP startup code and the IPI code has been cleaned up considerably.
Certain early token interactions on AP cpus have been moved to the BSP.

The LWKT rwlock API has been cleaned up and turned on.

Major testing by: David Rhodus

    1: /*
    2:  * Copyright (c) 1999, 2000 Boris Popov
    3:  * All rights reserved.
    4:  *
    5:  * Redistribution and use in source and binary forms, with or without
    6:  * modification, are permitted provided that the following conditions
    7:  * are met:
    8:  * 1. Redistributions of source code must retain the above copyright
    9:  *    notice, this list of conditions and the following disclaimer.
   10:  * 2. Redistributions in binary form must reproduce the above copyright
   11:  *    notice, this list of conditions and the following disclaimer in the
   12:  *    documentation and/or other materials provided with the distribution.
   13:  * 3. All advertising materials mentioning features or use of this software
   14:  *    must display the following acknowledgement:
   15:  *    This product includes software developed by Boris Popov.
   16:  * 4. Neither the name of the author nor the names of any co-contributors
   17:  *    may be used to endorse or promote products derived from this software
   18:  *    without specific prior written permission.
   19:  *
   20:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   21:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   24:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30:  * SUCH DAMAGE.
   31:  *
   32:  * $FreeBSD: src/sys/nwfs/nwfs_node.c,v 1.3.2.8 2001/12/25 01:44:45 dillon Exp $
   33:  * $DragonFly: src/sys/vfs/nwfs/nwfs_node.c,v 1.10 2004/03/01 06:33:22 dillon Exp $
   34:  */
   35: #include <sys/param.h>
   36: #include <sys/systm.h>
   37: #include <sys/kernel.h>
   38: #include <sys/time.h>
   39: #include <sys/proc.h>
   40: #include <sys/mount.h>
   41: #include <sys/vnode.h>
   42: #include <sys/malloc.h>
   43: #include <sys/sysctl.h>
   44: #include <vm/vm.h>
   45: #include <vm/vm_extern.h>
   46: #include <vm/vm_page.h>
   47: #include <vm/vm_object.h>
   48: #include <sys/queue.h>
   49: 
   50: #include <netproto/ncp/ncp.h>
   51: #include <netproto/ncp/ncp_conn.h>
   52: #include <netproto/ncp/ncp_subr.h>
   53: 
   54: #include "nwfs.h"
   55: #include "nwfs_mount.h"
   56: #include "nwfs_node.h"
   57: #include "nwfs_subr.h"
   58: 
   59: #define	NWNOHASH(fhsum) (&nwhashtbl[(fhsum.f_id) & nwnodehash])
   60: 
   61: extern vop_t **nwfs_vnodeop_p;
   62: 
   63: static LIST_HEAD(nwnode_hash_head,nwnode) *nwhashtbl;
   64: static u_long nwnodehash;
   65: static struct lock nwhashlock;
   66: 
   67: MALLOC_DEFINE(M_NWNODE, "NWFS node", "NWFS vnode private part");
   68: MALLOC_DEFINE(M_NWFSHASH, "NWFS hash", "NWFS has table");
   69: 
   70: static int nwfs_sysctl_vnprint(SYSCTL_HANDLER_ARGS);
   71: 
   72: SYSCTL_DECL(_vfs_nwfs);
   73: 
   74: SYSCTL_PROC(_vfs_nwfs, OID_AUTO, vnprint, CTLFLAG_WR|CTLTYPE_OPAQUE,
   75: 	    NULL, 0, nwfs_sysctl_vnprint, "S,vnlist", "vnode hash");
   76: 
   77: void
   78: nwfs_hash_init(void) {
   79: 	nwhashtbl = hashinit(desiredvnodes, M_NWFSHASH, &nwnodehash);
   80: 	lockinit(&nwhashlock, 0, "nwfshl", 0, 0);
   81: }
   82: 
   83: void
   84: nwfs_hash_free(void) {
   85: 	free(nwhashtbl, M_NWFSHASH);
   86: }
   87: 
   88: int
   89: nwfs_sysctl_vnprint(SYSCTL_HANDLER_ARGS) {
   90: 	struct nwnode *np;
   91: 	struct nwnode_hash_head *nhpp;
   92: 	struct vnode *vp;
   93: 	int i;
   94: 
   95: 	if (nwfs_debuglevel == 0)
   96: 		return 0;
   97: 	printf("Name:uc:hc:fid:pfid\n");
   98: 	for(i = 0; i <= nwnodehash; i++) {
   99: 		nhpp = &nwhashtbl[i];
  100: 		LIST_FOREACH(np, nhpp, n_hash) {
  101: 			vp = NWTOV(np);
  102: 			vprint(NULL, vp);
  103: 			printf("%s:%d:%d:%d:%d\n",np->n_name,vp->v_usecount,vp->v_holdcnt,
  104: 			    np->n_fid.f_id, np->n_fid.f_parent);
  105: 		}
  106: 	}
  107: 	return 0;
  108: }
  109: 
  110: /*
  111:  * Search nwnode with given fid.
  112:  * Hash list should be locked by caller.
  113:  */
  114: static int
  115: nwfs_hashlookup(struct nwmount *nmp, ncpfid fid, struct nwnode **npp)
  116: {
  117: 	struct nwnode *np;
  118: 	struct nwnode_hash_head *nhpp;
  119: 
  120: 	nhpp = NWNOHASH(fid);
  121: 	LIST_FOREACH(np, nhpp, n_hash) {
  122: 		if (nmp != np->n_mount || !NWCMPF(&fid, &np->n_fid))
  123: 			continue;
  124: 		if (npp)
  125: 			*npp = np;
  126: 		return 0;
  127: 	}
  128: 	return ENOENT;
  129: }
  130: 
  131: /*
  132:  * Allocate new nwfsnode/vnode from given nwnode. 
  133:  * Vnode referenced and not locked.
  134:  */
  135: int
  136: nwfs_allocvp(struct mount *mp, ncpfid fid, struct vnode **vpp)
  137: {
  138: 	struct thread *td = curthread;	/* XXX */
  139: 	struct nwnode *np;
  140: 	struct nwnode_hash_head *nhpp;
  141: 	struct nwmount *nmp = VFSTONWFS(mp);
  142: 	struct vnode *vp;
  143: 	lwkt_tokref vlock;
  144: 	int error;
  145: 
  146: loop:
  147: 	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
  148: rescan:
  149: 	if (nwfs_hashlookup(nmp, fid, &np) == 0) {
  150: 		vp = NWTOV(np);
  151: 		lwkt_gettoken(&vlock, vp->v_interlock);
  152: 		lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
  153: 		if (vget(vp, &vlock, LK_EXCLUSIVE | LK_INTERLOCK, td))
  154: 			goto loop;
  155: 		*vpp = vp;
  156: 		return(0);
  157: 	}
  158: 	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
  159: 
  160: 	/*
  161: 	 * Do the MALLOC before the getnewvnode since doing so afterward
  162: 	 * might cause a bogus v_data pointer to get dereferenced
  163: 	 * elsewhere if MALLOC should block.
  164: 	 */
  165: 	MALLOC(np, struct nwnode *, sizeof *np, M_NWNODE, M_WAITOK | M_ZERO);
  166: 	error = getnewvnode(VT_NWFS, mp, nwfs_vnodeop_p, &vp);
  167: 	if (error) {
  168: 		*vpp = NULL;
  169: 		FREE(np, M_NWNODE);
  170: 		return (error);
  171: 	}
  172: 	vp->v_data = np;
  173: 	np->n_vnode = vp;
  174: 	np->n_mount = nmp;
  175: 	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
  176: 	/*
  177: 	 * Another process can create vnode while we blocked in malloc() or
  178: 	 * getnewvnode(). Rescan list again.
  179: 	 */
  180: 	if (nwfs_hashlookup(nmp, fid, NULL) == 0) {
  181: 		vp->v_data = NULL;
  182: 		np->n_vnode = NULL;
  183: 		vrele(vp);
  184: 		FREE(np, M_NWNODE);
  185: 		goto rescan;
  186: 	}
  187: 	*vpp = vp;
  188: 	np->n_fid = fid;
  189: 	np->n_flag |= NNEW;
  190: 	lockinit(&np->n_lock, 0, "nwnode", VLKTIMEOUT, LK_CANRECURSE);
  191: 	nhpp = NWNOHASH(fid);
  192: 	LIST_INSERT_HEAD(nhpp, np, n_hash);
  193: 	vn_lock(vp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
  194: 	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
  195: 	return 0;
  196: }
  197: 
  198: int
  199: nwfs_lookupnp(struct nwmount *nmp, ncpfid fid, struct thread *td,
  200: 	struct nwnode **npp)
  201: {
  202: 	int error;
  203: 
  204: 	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
  205: 	error = nwfs_hashlookup(nmp, fid, npp);
  206: 	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
  207: 	return error;
  208: }
  209: 
  210: /*
  211:  * Free nwnode, and give vnode back to system
  212:  */
  213: int
  214: nwfs_reclaim(ap)                     
  215:         struct vop_reclaim_args /* {
  216:     		struct vnode *a_vp;
  217: 		struct thread *a_td;
  218:         } */ *ap;
  219: {
  220: 	struct vnode *dvp = NULL, *vp = ap->a_vp;
  221: 	struct nwnode *dnp, *np = VTONW(vp);
  222: 	struct nwmount *nmp = VTONWFS(vp);
  223: 	struct thread *td = ap->a_td;
  224: 	
  225: 	NCPVNDEBUG("%s,%d\n", np->n_name, vp->v_usecount);
  226: 	if (np->n_refparent) {
  227: 		np->n_refparent = 0;
  228: 		if (nwfs_lookupnp(nmp, np->n_parent, td, &dnp) == 0) {
  229: 			dvp = dnp->n_vnode;
  230: 		} else {
  231: 			NCPVNDEBUG("%s: has no parent ?\n",np->n_name);
  232: 		}
  233: 	}
  234: 	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
  235: 	LIST_REMOVE(np, n_hash);
  236: 	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
  237: 	cache_purge(vp);
  238: 	if (nmp->n_root == np) {
  239: 		nmp->n_root = NULL;
  240: 	}
  241: 	vp->v_data = NULL;
  242: 	FREE(np, M_NWNODE);
  243: 	if (dvp) {
  244: 		vrele(dvp);
  245: 	}
  246: 	return (0);
  247: }
  248: 
  249: int
  250: nwfs_inactive(ap)
  251: 	struct vop_inactive_args /* {
  252: 		struct vnode *a_vp;
  253: 		struct thread *a_td;
  254: 	} */ *ap;
  255: {
  256: 	struct thread *td = ap->a_td;
  257: 	struct ucred *cred;
  258: 	struct vnode *vp = ap->a_vp;
  259: 	struct nwnode *np = VTONW(vp);
  260: 	int error;
  261: 
  262: 	KKASSERT(td->td_proc);
  263: 	cred = td->td_proc->p_ucred;
  264: 
  265: 	NCPVNDEBUG("%s: %d\n", VTONW(vp)->n_name, vp->v_usecount);
  266: 	if (np->opened) {
  267: 		error = nwfs_vinvalbuf(vp, V_SAVE, td, 1);
  268: 		error = ncp_close_file(NWFSTOCONN(VTONWFS(vp)), &np->n_fh, td, cred);
  269: 		np->opened = 0;
  270: 	}
  271: 	VOP_UNLOCK(vp, NULL, 0, td);
  272: 	if (np->n_flag & NSHOULDFREE) {
  273: 		cache_purge(vp);
  274: 		vgone(vp);
  275: 	}
  276: 	return (0);
  277: }
  278: /*
  279:  * routines to maintain vnode attributes cache
  280:  * nwfs_attr_cacheenter: unpack np.i to va structure
  281:  */
  282: void
  283: nwfs_attr_cacheenter(struct vnode *vp, struct nw_entry_info *fi)
  284: {
  285: 	struct nwnode *np = VTONW(vp);
  286: 	struct nwmount *nmp = VTONWFS(vp);
  287: 	struct vattr *va = &np->n_vattr;
  288: 
  289: 	va->va_type = vp->v_type;		/* vnode type (for create) */
  290: 	np->n_nmlen = fi->nameLen;
  291: 	bcopy(fi->entryName, np->n_name, np->n_nmlen);
  292: 	np->n_name[fi->nameLen] = 0;
  293: 	if (vp->v_type == VREG) {
  294: 		if (va->va_size != fi->dataStreamSize) {
  295: 			va->va_size = fi->dataStreamSize;
  296: 			vnode_pager_setsize(vp, va->va_size);
  297: 		}
  298: 		va->va_mode = nmp->m.file_mode;	/* files access mode and type */
  299: 	} else if (vp->v_type == VDIR) {
  300: 		va->va_size = 16384; 		/* should be a better way ... */
  301: 		va->va_mode = nmp->m.dir_mode;	/* files access mode and type */
  302: 	} else
  303: 		return;
  304: 	np->n_size = va->va_size;
  305: 	va->va_nlink = 1;		/* number of references to file */
  306: 	va->va_uid = nmp->m.uid;	/* owner user id */
  307: 	va->va_gid = nmp->m.gid;	/* owner group id */
  308: 	va->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
  309: 	va->va_fileid = np->n_fid.f_id;	/* file id */
  310: 	if (va->va_fileid == 0)
  311: 		va->va_fileid = NWFS_ROOT_INO;
  312: 	va->va_blocksize=nmp->connh->nh_conn->buffer_size;/* blocksize preferred for i/o */
  313: 	/* time of last modification */
  314: 	ncp_dos2unixtime(fi->modifyDate, fi->modifyTime, 0, nmp->m.tz, &va->va_mtime);
  315: 	/* time of last access */
  316: 	ncp_dos2unixtime(fi->lastAccessDate, 0, 0, nmp->m.tz, &va->va_atime);
  317: 	va->va_ctime = va->va_mtime;	/* time file changed */
  318: 	va->va_gen = VNOVAL;		/* generation number of file */
  319: 	va->va_flags = 0;		/* flags defined for file */
  320: 	va->va_rdev = VNOVAL;		/* device the special file represents */
  321: 	va->va_bytes = va->va_size;	/* bytes of disk space held by file */
  322: 	va->va_filerev = 0;		/* file modification number */
  323: 	va->va_vaflags = 0;		/* operations flags */
  324: 	np->n_vattr = *va;
  325: 	if (np->n_mtime == 0) {
  326: 		np->n_mtime = va->va_mtime.tv_sec;
  327: 	}
  328: 	np->n_atime = time_second;
  329: 	np->n_dosfid = fi->DosDirNum;
  330: 	return;
  331: }
  332: 
  333: int
  334: nwfs_attr_cachelookup(struct vnode *vp, struct vattr *va)
  335: {
  336: 	struct nwnode *np = VTONW(vp);
  337: 	int diff;
  338: 
  339: 	diff = time_second - np->n_atime;
  340: 	if (diff > 2) {	/* XXX should be configurable */
  341: 		return ENOENT;
  342: 	}
  343: 	*va = np->n_vattr;
  344: 	return 0;
  345: }