自学教程：C++ vrele函数代码示例

//.........这里部分代码省略.........		printf ("null_bypass: %s/n", descp->vdesc_name);#ifdef DIAGNOSTIC	/*	 * We require at least one vp.	 */	if (descp->vdesc_vp_offsets == NULL ||	    descp->vdesc_vp_offsets[0] == VDESC_NO_OFFSET)		panic ("null_bypass: no vp's in map");#endif	/*	 * Map the vnodes going in.	 * Later, we'll invoke the operation based on	 * the first mapped vnode's operation vector.	 */	reles = descp->vdesc_flags;	for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {		if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)			break;   /* bail out at end of list */		vps_p[i] = this_vp_p =			VOPARG_OFFSETTO(struct vnode**,descp->vdesc_vp_offsets[i],ap);		/*		 * We're not guaranteed that any but the first vnode		 * are of our type.  Check for and don't map any		 * that aren't.  (We must always map first vp or vclean fails.)		 */		if (i && (*this_vp_p == NULLVP ||		    (*this_vp_p)->v_op != &null_vnodeops)) {			old_vps[i] = NULLVP;		} else {			old_vps[i] = *this_vp_p;			*(vps_p[i]) = NULLVPTOLOWERVP(*this_vp_p);			/*			 * XXX - Several operations have the side effect			 * of vrele'ing their vp's.  We must account for			 * that.  (This should go away in the future.)			 */			if (reles & VDESC_VP0_WILLRELE)				VREF(*this_vp_p);		}	}	/*	 * Call the operation on the lower layer	 * with the modified argument structure.	 */	if (vps_p[0] && *vps_p[0])		error = VCALL(ap);	else {		printf("null_bypass: no map for %s/n", descp->vdesc_name);		error = EINVAL;	}	/*	 * Maintain the illusion of call-by-value	 * by restoring vnodes in the argument structure	 * to their original value.	 */	reles = descp->vdesc_flags;	for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {		if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)			break;   /* bail out at end of list */		if (old_vps[i]) {			*(vps_p[i]) = old_vps[i];#if 0			if (reles & VDESC_VP0_WILLUNLOCK)				VOP_UNLOCK(*(vps_p[i]), 0);#endif			if (reles & VDESC_VP0_WILLRELE)				vrele(*(vps_p[i]));		}	}	/*	 * Map the possible out-going vpp	 * (Assumes that the lower layer always returns	 * a VREF'ed vpp unless it gets an error.)	 */	if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET &&	    !(descp->vdesc_flags & VDESC_NOMAP_VPP) &&	    !error) {		/*		 * XXX - even though some ops have vpp returned vp's,		 * several ops actually vrele this before returning.		 * We must avoid these ops.		 * (This should go away when these ops are regularized.)		 */		if (descp->vdesc_flags & VDESC_VPP_WILLRELE)			goto out;		vppp = VOPARG_OFFSETTO(struct vnode***,				 descp->vdesc_vpp_offset,ap);		if (*vppp)			error = null_nodeget(old_vps[0]->v_mount, **vppp, *vppp);	} out:	return (error);}

/* ARGSUSED */intmfs_mount(struct mount *mp, const char *path, void *data,    struct nameidata *ndp, struct proc *p){	struct vnode *devvp;	struct mfs_args args;	struct ufsmount *ump;	struct fs *fs;	struct mfsnode *mfsp;	char fspec[MNAMELEN];	int flags, error;	error = copyin(data, &args, sizeof(struct mfs_args));	if (error)		return (error);	/*	 * If updating, check whether changing from read-only to	 * read/write; if there is no device name, that's all we do.	 */	if (mp->mnt_flag & MNT_UPDATE) {		ump = VFSTOUFS(mp);		fs = ump->um_fs;		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {			flags = WRITECLOSE;			if (mp->mnt_flag & MNT_FORCE)				flags |= FORCECLOSE;			error = ffs_flushfiles(mp, flags, p);			if (error)				return (error);		}		if (fs->fs_ronly && (mp->mnt_flag & MNT_WANTRDWR))			fs->fs_ronly = 0;#ifdef EXPORTMFS		if (args.fspec == NULL)			return (vfs_export(mp, &ump->um_export, 			    &args.export_info));#endif		return (0);	}	error = copyinstr(args.fspec, fspec, sizeof(fspec), NULL);	if (error)		return (error);	error = getnewvnode(VT_MFS, NULL, &mfs_vops, &devvp);	if (error)		return (error);	devvp->v_type = VBLK;	if (checkalias(devvp, makedev(255, mfs_minor), NULL))		panic("mfs_mount: dup dev");	mfs_minor++;	mfsp = malloc(sizeof *mfsp, M_MFSNODE, M_WAITOK | M_ZERO);	devvp->v_data = mfsp;	mfsp->mfs_baseoff = args.base;	mfsp->mfs_size = args.size;	mfsp->mfs_vnode = devvp;	mfsp->mfs_pid = p->p_pid;	bufq_init(&mfsp->mfs_bufq, BUFQ_FIFO);	if ((error = ffs_mountfs(devvp, mp, p)) != 0) {		mfsp->mfs_shutdown = 1;		vrele(devvp);		return (error);	}	ump = VFSTOUFS(mp);	fs = ump->um_fs;	memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));	strlcpy(fs->fs_fsmnt, path, sizeof(fs->fs_fsmnt));	memcpy(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN);	memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);	strlcpy(mp->mnt_stat.f_mntfromname, fspec, MNAMELEN);	memset(mp->mnt_stat.f_mntfromspec, 0, MNAMELEN);	strlcpy(mp->mnt_stat.f_mntfromspec, fspec, MNAMELEN);	memcpy(&mp->mnt_stat.mount_info.mfs_args, &args, sizeof(args));	return (0);}

static intcd9660_mount(struct mount *mp){	struct vnode *devvp;	struct thread *td;	char *fspec;	int error;	accmode_t accmode;	struct nameidata ndp;	struct iso_mnt *imp = NULL;	td = curthread;	/*	 * Unconditionally mount as read-only.	 */	MNT_ILOCK(mp);	mp->mnt_flag |= MNT_RDONLY;	MNT_IUNLOCK(mp);	fspec = vfs_getopts(mp->mnt_optnew, "from", &error);	if (error)		return (error);	imp = VFSTOISOFS(mp);	if (mp->mnt_flag & MNT_UPDATE) {		if (vfs_flagopt(mp->mnt_optnew, "export", NULL, 0))			return (0);	}	/*	 * Not an update, or updating the name: look up the name	 * and verify that it refers to a sensible block device.	 */	NDINIT(&ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td);	if ((error = namei(&ndp)))		return (error);	NDFREE(&ndp, NDF_ONLY_PNBUF);	devvp = ndp.ni_vp;	if (!vn_isdisk(devvp, &error)) {		vput(devvp);		return (error);	}	/*	 * Verify that user has necessary permissions on the device,	 * or has superuser abilities	 */	accmode = VREAD;	error = VOP_ACCESS(devvp, accmode, td->td_ucred, td);	if (error)		error = priv_check(td, PRIV_VFS_MOUNT_PERM);	if (error) {		vput(devvp);		return (error);	}	if ((mp->mnt_flag & MNT_UPDATE) == 0) {		error = iso_mountfs(devvp, mp);		if (error)			vrele(devvp);	} else {		if (devvp != imp->im_devvp)			error = EINVAL;	/* needs translation */		vput(devvp);	}	if (error)		return (error);	vfs_mountedfrom(mp, fspec);	return (0);}

/* * Update the disk quota in the quota file. */static intdqsync(struct vnode *vp, struct dquot *dq){    uint8_t buf[sizeof(struct dqblk64)];    off_t base, recsize;    struct vnode *dqvp;    struct iovec aiov;    struct uio auio;    int error;    struct mount *mp;    struct ufsmount *ump;#ifdef DEBUG_VFS_LOCKS    if (vp != NULL)        ASSERT_VOP_ELOCKED(vp, "dqsync");#endif    mp = NULL;    error = 0;    if (dq == NODQUOT)        panic("dqsync: dquot");    if ((ump = dq->dq_ump) == NULL)        return (0);    UFS_LOCK(ump);    if ((dqvp = ump->um_quotas[dq->dq_type]) == NULLVP) {        if (vp == NULL) {            UFS_UNLOCK(ump);            return (0);        } else            panic("dqsync: file");    }    vref(dqvp);    UFS_UNLOCK(ump);    DQI_LOCK(dq);    if ((dq->dq_flags & DQ_MOD) == 0) {        DQI_UNLOCK(dq);        vrele(dqvp);        return (0);    }    DQI_UNLOCK(dq);    (void) vn_start_secondary_write(dqvp, &mp, V_WAIT);    if (vp != dqvp)        vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY);    DQI_LOCK(dq);    DQI_WAIT(dq, PINOD+2, "dqsync");    if ((dq->dq_flags & DQ_MOD) == 0)        goto out;    dq->dq_flags |= DQ_LOCK;    DQI_UNLOCK(dq);    /*     * Write the quota record to the quota file, performing any     * necessary conversions.  See dqget() for additional details.     */    if (ump->um_qflags[dq->dq_type] & QTF_64BIT) {        dq_dqb64(dq, (struct dqblk64 *)buf);        recsize = sizeof(struct dqblk64);        base = sizeof(struct dqhdr64);    } else {        dq_dqb32(dq, (struct dqblk32 *)buf);        recsize = sizeof(struct dqblk32);        base = 0;    }    auio.uio_iov = &aiov;    auio.uio_iovcnt = 1;    aiov.iov_base = buf;    aiov.iov_len = recsize;    auio.uio_resid = recsize;    auio.uio_offset = base + dq->dq_id * recsize;    auio.uio_segflg = UIO_SYSSPACE;    auio.uio_rw = UIO_WRITE;    auio.uio_td = (struct thread *)0;    error = VOP_WRITE(dqvp, &auio, 0, dq->dq_ump->um_cred[dq->dq_type]);    if (auio.uio_resid && error == 0)        error = EIO;    DQI_LOCK(dq);    DQI_WAKEUP(dq);    dq->dq_flags &= ~DQ_MOD;out:    DQI_UNLOCK(dq);    if (vp != dqvp)        vput(dqvp);    else        vrele(dqvp);    vn_finished_secondary_write(mp);    return (error);}

/* * Main code to turn off disk quotas for a filesystem. Does not change * flags. */static intquotaoff1(struct thread *td, struct mount *mp, int type){    struct vnode *vp;    struct vnode *qvp, *mvp;    struct ufsmount *ump;    struct dquot *dq;    struct inode *ip;    struct ucred *cr;    int error;    ump = VFSTOUFS(mp);    UFS_LOCK(ump);    KASSERT((ump->um_qflags[type] & QTF_CLOSING) != 0,            ("quotaoff1: flags are invalid"));    if ((qvp = ump->um_quotas[type]) == NULLVP) {        UFS_UNLOCK(ump);        return (0);    }    cr = ump->um_cred[type];    UFS_UNLOCK(ump);    /*     * Search vnodes associated with this mount point,     * deleting any references to quota file being closed.     */again:    MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {        if (vp->v_type == VNON) {            VI_UNLOCK(vp);            continue;        }        if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {            MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);            goto again;        }        ip = VTOI(vp);        dq = ip->i_dquot[type];        ip->i_dquot[type] = NODQUOT;        dqrele(vp, dq);        VOP_UNLOCK(vp, 0);        vrele(vp);    }    error = dqflush(qvp);    if (error != 0)        return (error);    /*     * Clear um_quotas before closing the quota vnode to prevent     * access to the closed vnode from dqget/dqsync     */    UFS_LOCK(ump);    ump->um_quotas[type] = NULLVP;    ump->um_cred[type] = NOCRED;    UFS_UNLOCK(ump);    vn_lock(qvp, LK_EXCLUSIVE | LK_RETRY);    qvp->v_vflag &= ~VV_SYSTEM;    VOP_UNLOCK(qvp, 0);    error = vn_close(qvp, FREAD|FWRITE, td->td_ucred, td);    crfree(cr);    return (error);}

//.........这里部分代码省略.........	 * We have to acquire the vp from v->a_nch because we will likely	 * unresolve the namecache entry, and a vrele/vput is needed to	 * trigger the tmpfs_inactive/tmpfs_reclaim sequence.	 *	 * We have to use vget to clear any inactive state on the vnode,	 * otherwise the vnode may remain inactive and thus tmpfs_inactive	 * will not get called when we release it.	 */	error = cache_vget(v->a_nch, v->a_cred, LK_SHARED, &vp);	KKASSERT(error == 0);	vn_unlock(vp);	/*	 * Prevalidate so we don't hit an assertion later	 */	if (vp->v_type != VDIR) {		error = ENOTDIR;		goto out;	}	tmp = VFS_TO_TMPFS(dvp->v_mount);	dnode = VP_TO_TMPFS_DIR(dvp);	node = VP_TO_TMPFS_DIR(vp);	/* Directories with more than two entries ('.' and '..') cannot be	 * removed. */	 if (node->tn_size > 0) {		 error = ENOTEMPTY;		 goto out;	 }	if ((dnode->tn_flags & APPEND)	    || (node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))) {		error = EPERM;		goto out;	}	/* This invariant holds only if we are not trying to remove "..".	  * We checked for that above so this is safe now. */	KKASSERT(node->tn_dir.tn_parent == dnode);	/* Get the directory entry associated with node (vp).  This was	 * filled by tmpfs_lookup while looking up the entry. */	de = tmpfs_dir_lookup(dnode, node, ncp);	KKASSERT(TMPFS_DIRENT_MATCHES(de,	    ncp->nc_name,	    ncp->nc_nlen));	/* Check flags to see if we are allowed to remove the directory. */	if ((dnode->tn_flags & APPEND) ||	    node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) {		error = EPERM;		goto out;	}	/* Detach the directory entry from the directory (dnode). */	tmpfs_dir_detach(dnode, de);	/* No vnode should be allocated for this entry from this point */	TMPFS_NODE_LOCK(node);	TMPFS_ASSERT_ELOCKED(node);	TMPFS_NODE_LOCK(dnode);	TMPFS_ASSERT_ELOCKED(dnode);	/*	 * Must set parent linkage to NULL (tested by ncreate to disallow	 * the creation of new files/dirs in a deleted directory)	 */	node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | /	    TMPFS_NODE_MODIFIED;	dnode->tn_status |= TMPFS_NODE_ACCESSED | /	    TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;	TMPFS_NODE_UNLOCK(dnode);	TMPFS_NODE_UNLOCK(node);	/* Free the directory entry we just deleted.  Note that the node	 * referred by it will not be removed until the vnode is really	 * reclaimed. */	tmpfs_free_dirent(tmp, de);	/* Release the deleted vnode (will destroy the node, notify	 * interested parties and clean it from the cache). */	TMPFS_NODE_LOCK(dnode);	dnode->tn_status |= TMPFS_NODE_CHANGED;	TMPFS_NODE_UNLOCK(dnode);	tmpfs_update(dvp);	cache_unlink(v->a_nch);	tmpfs_knote(dvp, NOTE_WRITE | NOTE_LINK);	error = 0;out:	vrele(vp);	return error;}

//.........这里部分代码省略.........	if (fncp->nc_nlen != tncp->nc_nlen ||	    bcmp(fncp->nc_name, tncp->nc_name, fncp->nc_nlen) != 0) {		newname = kmalloc(tncp->nc_nlen + 1, tmp->tm_name_zone, 				  M_WAITOK | M_NULLOK);		if (newname == NULL) {			error = ENOSPC;			goto out_locked;		}		bcopy(tncp->nc_name, newname, tncp->nc_nlen);		newname[tncp->nc_nlen] = '/0';	} else {		newname = NULL;	}	/*	 * Unlink entry from source directory.  Note that the kernel has	 * already checked for illegal recursion cases (renaming a directory	 * into a subdirectory of itself).	 */	if (fdnode != tdnode) {		tmpfs_dir_detach(fdnode, de);	} else {		RB_REMOVE(tmpfs_dirtree, &fdnode->tn_dir.tn_dirtree, de);	}	/*	 * Handle any name change.  Swap with newname, we will	 * deallocate it at the end.	 */	if (newname != NULL) {#if 0		TMPFS_NODE_LOCK(fnode);		fnode->tn_status |= TMPFS_NODE_CHANGED;		TMPFS_NODE_UNLOCK(fnode);#endif		oldname = de->td_name;		de->td_name = newname;		de->td_namelen = (uint16_t)tncp->nc_nlen;		newname = oldname;	}	/*	 * If we are overwriting an entry, we have to remove the old one	 * from the target directory.	 */	if (tvp != NULL) {		/* Remove the old entry from the target directory. */		tde = tmpfs_dir_lookup(tdnode, tnode, tncp);		tmpfs_dir_detach(tdnode, tde);		tmpfs_knote(tdnode->tn_vnode, NOTE_DELETE);		/*		 * Free the directory entry we just deleted.  Note that the		 * node referred by it will not be removed until the vnode is		 * really reclaimed.		 */		tmpfs_free_dirent(VFS_TO_TMPFS(tvp->v_mount), tde);		/*cache_inval_vp(tvp, CINV_DESTROY);*/	}	/*	 * Link entry to target directory.  If the entry	 * represents a directory move the parent linkage	 * as well.	 */	if (fdnode != tdnode) {		if (de->td_node->tn_type == VDIR) {			TMPFS_VALIDATE_DIR(fnode);		}		tmpfs_dir_attach(tdnode, de);	} else {		TMPFS_NODE_LOCK(tdnode);		tdnode->tn_status |= TMPFS_NODE_MODIFIED;		RB_INSERT(tmpfs_dirtree, &tdnode->tn_dir.tn_dirtree, de);		TMPFS_NODE_UNLOCK(tdnode);	}	/*	 * Finish up	 */	if (newname) {		kfree(newname, tmp->tm_name_zone);		newname = NULL;	}	cache_rename(v->a_fnch, v->a_tnch);	tmpfs_knote(v->a_fdvp, NOTE_WRITE);	tmpfs_knote(v->a_tdvp, NOTE_WRITE);	if (fnode->tn_vnode)		tmpfs_knote(fnode->tn_vnode, NOTE_RENAME);	error = 0;out_locked:	;out:	if (tvp)		vrele(tvp);	return error;}

//.........这里部分代码省略.........	sz = MAXPATHLEN - (ptr - buf);	/* 	 * If sgp is not given then the path is already in kernel space	 */	if (sgp == NULL)		error = copystr(path, ptr, sz, &len);	else		error = copyinstr(path, ptr, sz, &len);	if (error)		goto bad;	if (*ptr != '/') {		error = EINVAL;		goto bad;	}	/*	 * We know that there is a / somewhere in this pathname.	 * Search backwards for it, to find the file's parent dir	 * to see if it exists in the alternate tree. If it does,	 * and we want to create a file (cflag is set). We don't	 * need to worry about the root comparison in this case.	 */	if (cflag) {		for (cp = &ptr[len] - 1; *cp != '/'; cp--)			;		*cp = '/0';		NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p);		if ((error = namei(&nd)) != 0)			goto bad;		*cp = '/';	} else {		NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p);		if ((error = namei(&nd)) != 0)			goto bad;		/*		 * We now compare the vnode of the emulation root to the one		 * vnode asked. If they resolve to be the same, then we		 * ignore the match so that the real root gets used.		 * This avoids the problem of traversing "../.." to find the		 * root directory and never finding it, because "/" resolves		 * to the emulation root directory. This is expensive :-(		 */		/* XXX: prototype should have const here for NDINIT */		NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, prefix, p);		if ((error = namei(&ndroot)) != 0)			goto bad2;		if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, p)) != 0)			goto bad3;		if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, p))		    != 0)			goto bad3;		if (vat.va_fsid == vatroot.va_fsid &&		    vat.va_fileid == vatroot.va_fileid) {			error = ENOENT;			goto bad3;		}	}	if (sgp == NULL)		*pbuf = buf;	else {		sz = &ptr[len] - buf;		*pbuf = stackgap_alloc(sgp, sz + 1);		if (*pbuf == NULL) {			error = ENAMETOOLONG;			goto bad;		}		if ((error = copyout(buf, *pbuf, sz)) != 0) {			*pbuf = path;			goto bad;		}		free(buf, M_TEMP, 0);	}	vrele(nd.ni_vp);	if (!cflag)		vrele(ndroot.ni_vp);	return error;bad3:	vrele(ndroot.ni_vp);bad2:	vrele(nd.ni_vp);bad:	free(buf, M_TEMP, 0);	return error;}

intptmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p){	dev_t newdev, error;	struct pt_softc * pti;	struct nameidata cnd, snd;	struct filedesc *fdp = p->p_fd;	struct file *cfp = NULL, *sfp = NULL;	int cindx, sindx;	uid_t uid;	gid_t gid;	struct vattr vattr;	struct ucred *cred;	struct ptmget *ptm = (struct ptmget *)data;	switch (cmd) {	case PTMGET:		fdplock(fdp);		/* Grab two filedescriptors. */		if ((error = falloc(p, &cfp, &cindx)) != 0) {			fdpunlock(fdp);			break;		}		if ((error = falloc(p, &sfp, &sindx)) != 0) {			fdremove(fdp, cindx);			closef(cfp, p);			fdpunlock(fdp);			break;		}retry:		/* Find and open a free master pty. */		newdev = pty_getfree();		if ((error = check_pty(minor(newdev))))			goto bad;		pti = pt_softc[minor(newdev)];		NDINIT(&cnd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,		    pti->pty_pn, p);		if ((error = ptm_vn_open(&cnd)) != 0) {			/*			 * Check if the master open failed because we lost			 * the race to grab it.			 */			if (error == EIO && !pty_isfree(minor(newdev)))				goto retry;			goto bad;		}		cfp->f_flag = FREAD|FWRITE;		cfp->f_type = DTYPE_VNODE;		cfp->f_ops = &vnops;		cfp->f_data = (caddr_t) cnd.ni_vp;		VOP_UNLOCK(cnd.ni_vp, 0);		/*		 * Open the slave.		 * namei -> setattr -> unlock -> revoke -> vrele ->		 * namei -> open -> unlock		 * Three stage rocket:		 * 1. Change the owner and permissions on the slave.		 * 2. Revoke all the users of the slave.		 * 3. open the slave.		 */		NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,		    pti->pty_sn, p);		if ((error = namei(&snd)) != 0)			goto bad;		if ((snd.ni_vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {			gid = tty_gid;			/* get real uid */			uid = p->p_cred->p_ruid;			VATTR_NULL(&vattr);			vattr.va_uid = uid;			vattr.va_gid = gid;			vattr.va_mode = (S_IRUSR|S_IWUSR|S_IWGRP) & ALLPERMS;			/* Get a fake cred to pretend we're root. */			cred = crget();			error = VOP_SETATTR(snd.ni_vp, &vattr, cred);			crfree(cred);			if (error) {				vput(snd.ni_vp);				goto bad;			}		}		VOP_UNLOCK(snd.ni_vp, 0);		if (snd.ni_vp->v_usecount > 1 ||		    (snd.ni_vp->v_flag & (VALIASED)))			VOP_REVOKE(snd.ni_vp, REVOKEALL);		/*		 * The vnode is useless after the revoke, we need to		 * namei again.		 */		vrele(snd.ni_vp);		NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,		    pti->pty_sn, p);		/* now open it */		if ((error = ptm_vn_open(&snd)) != 0)			goto bad;//.........这里部分代码省略.........

//.........这里部分代码省略.........		 * Signal foreground pgrp and revoke access to		 * controlling terminal if it has not been revoked		 * already.		 *		 * Because the TTY may have been revoked in the mean		 * time and could already have a new session associated		 * with it, make sure we don't send a SIGHUP to a		 * foreground process group that does not belong to this		 * session.		 */		if (tp != NULL) {			tty_lock(tp);			if (tp->t_session == sp)				tty_signal_pgrp(tp, SIGHUP);			tty_unlock(tp);		}		if (ttyvp != NULL) {			sx_xunlock(&proctree_lock);			if (vn_lock(ttyvp, LK_EXCLUSIVE) == 0) {				VOP_REVOKE(ttyvp, REVOKEALL);				VOP_UNLOCK(ttyvp, 0);			}			sx_xlock(&proctree_lock);		}	}	fixjobc(p, p->p_pgrp, 0);	sx_xunlock(&proctree_lock);	(void)acct_process(td);	/* Release the TTY now we've unlocked everything. */	if (ttyvp != NULL)		vrele(ttyvp);#ifdef KTRACE	ktrprocexit(td);#endif	/*	 * Release reference to text vnode	 */	if ((vtmp = p->p_textvp) != NULL) {		p->p_textvp = NULL;		vrele(vtmp);	}	/*	 * Release our limits structure.	 */	plim = p->p_limit;	p->p_limit = NULL;	lim_free(plim);	tidhash_remove(td);	/*	 * Remove proc from allproc queue and pidhash chain.	 * Place onto zombproc.  Unlink from parent's child list.	 */	sx_xlock(&allproc_lock);	LIST_REMOVE(p, p_list);	LIST_INSERT_HEAD(&zombproc, p, p_list);	LIST_REMOVE(p, p_hash);	sx_xunlock(&allproc_lock);	/*	 * Call machine-dependent code to release any

/* * smbfs_file rename call */intsmbfs_rename(void *v){	struct vop_rename_args  /* {		struct vnode *a_fdvp;		struct vnode *a_fvp;		struct componentname *a_fcnp;		struct vnode *a_tdvp;		struct vnode *a_tvp;		struct componentname *a_tcnp;	} */ *ap = v;	struct vnode *fvp = ap->a_fvp;	struct vnode *tvp = ap->a_tvp;	struct vnode *fdvp = ap->a_fdvp;	struct vnode *tdvp = ap->a_tdvp;	struct componentname *tcnp = ap->a_tcnp;/*	struct componentname *fcnp = ap->a_fcnp;*/	struct smb_cred scred;#ifdef notyet	u_int16_t flags = 6;#endif	int error=0;	/* Check for cross-device rename */	if ((fvp->v_mount != tdvp->v_mount) ||	    (tvp && (fvp->v_mount != tvp->v_mount))) {		error = EXDEV;		goto out;	}	if (tvp && tvp->v_usecount > 1) {		error = EBUSY;		goto out;	}#ifdef notnow	flags = 0x10;			/* verify all writes */	if (fvp->v_type == VDIR) {		flags |= 2;	} else if (fvp->v_type == VREG) {		flags |= 1;	} else {		error = EINVAL;		goto out;	}#endif	smb_makescred(&scred, curlwp, tcnp->cn_cred);	/*	 * It seems that Samba doesn't implement SMB_COM_MOVE call...	 */#ifdef notnow	if (SMB_DIALECT(SSTOCN(smp->sm_share)) >= SMB_DIALECT_LANMAN1_0) {		error = smbfs_smb_move(VTOSMB(fvp), VTOSMB(tdvp),		    tcnp->cn_nameptr, tcnp->cn_namelen, flags, &scred);	} else#endif	{		/*		 * We have to do the work atomicaly		 */		if (tvp && tvp != fvp) {			error = smbfs_smb_delete(VTOSMB(tvp), &scred);			if (error)				goto out;			VTOSMB(tvp)->n_flag |= NGONE;			VN_KNOTE(tdvp, NOTE_WRITE);			VN_KNOTE(tvp, NOTE_DELETE);			cache_purge(tvp);		}		error = smbfs_smb_rename(VTOSMB(fvp), VTOSMB(tdvp),		    tcnp->cn_nameptr, tcnp->cn_namelen, &scred);		VTOSMB(fvp)->n_flag |= NGONE;		VN_KNOTE(fdvp, NOTE_WRITE);		VN_KNOTE(fvp, NOTE_RENAME);	}	if (fvp->v_type == VDIR) {		if (tvp != NULL && tvp->v_type == VDIR)			cache_purge(tdvp);		cache_purge(fdvp);	}	smbfs_attr_cacheremove(fdvp);	smbfs_attr_cacheremove(tdvp);out:	if (tdvp == tvp)		vrele(tdvp);	else		vput(tdvp);	if (tvp)		vput(tvp);	vrele(fdvp);	vrele(fvp);	return (error);//.........这里部分代码省略.........

static inttmpfs_nremove(struct vop_nremove_args *v){	struct vnode *dvp = v->a_dvp;	struct namecache *ncp = v->a_nch->ncp;	struct vnode *vp;	int error;	struct tmpfs_dirent *de;	struct tmpfs_mount *tmp;	struct tmpfs_node *dnode;	struct tmpfs_node *node;	/*	 * We have to acquire the vp from v->a_nch because we will likely	 * unresolve the namecache entry, and a vrele/vput is needed to	 * trigger the tmpfs_inactive/tmpfs_reclaim sequence.	 *	 * We have to use vget to clear any inactive state on the vnode,	 * otherwise the vnode may remain inactive and thus tmpfs_inactive	 * will not get called when we release it.	 */	error = cache_vget(v->a_nch, v->a_cred, LK_SHARED, &vp);	KKASSERT(error == 0);	vn_unlock(vp);	if (vp->v_type == VDIR) {		error = EISDIR;		goto out;	}	dnode = VP_TO_TMPFS_DIR(dvp);	node = VP_TO_TMPFS_NODE(vp);	tmp = VFS_TO_TMPFS(vp->v_mount);	de = tmpfs_dir_lookup(dnode, node, ncp);	if (de == NULL) {		error = ENOENT;		goto out;	}	/* Files marked as immutable or append-only cannot be deleted. */	if ((node->tn_flags & (IMMUTABLE | APPEND | NOUNLINK)) ||	    (dnode->tn_flags & APPEND)) {		error = EPERM;		goto out;	}	/* Remove the entry from the directory; as it is a file, we do not	 * have to change the number of hard links of the directory. */	tmpfs_dir_detach(dnode, de);	/* Free the directory entry we just deleted.  Note that the node	 * referred by it will not be removed until the vnode is really	 * reclaimed. */	tmpfs_free_dirent(tmp, de);	if (node->tn_links > 0) {	        TMPFS_NODE_LOCK(node);		node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | /	                TMPFS_NODE_MODIFIED;	        TMPFS_NODE_UNLOCK(node);	}	cache_unlink(v->a_nch);	tmpfs_knote(vp, NOTE_DELETE);	tmpfs_knote(dvp, NOTE_WRITE);	error = 0;out:	vrele(vp);	return error;}

//.........这里部分代码省略.........			mp->mnt_flag |= MNT_RDONLY;			MNT_IUNLOCK(mp);		} else if ((pmp->pm_flags & MSDOSFSMNT_RONLY) &&		    !vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {			/*			 * If upgrade to read-write by non-root, then verify			 * that user has necessary permissions on the device.			 */			devvp = pmp->pm_devvp;			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);			error = VOP_ACCESS(devvp, VREAD | VWRITE,			    td->td_ucred, td);			if (error)				error = priv_check(td, PRIV_VFS_MOUNT_PERM);			if (error) {				VOP_UNLOCK(devvp, 0);				return (error);			}			VOP_UNLOCK(devvp, 0);			DROP_GIANT();			g_topology_lock();			error = g_access(pmp->pm_cp, 0, 1, 0);			g_topology_unlock();			PICKUP_GIANT();			if (error)				return (error);			pmp->pm_fmod = 1;			pmp->pm_flags &= ~MSDOSFSMNT_RONLY;			MNT_ILOCK(mp);			mp->mnt_flag &= ~MNT_RDONLY;			MNT_IUNLOCK(mp);			/* Now that the volume is modifiable, mark it dirty. */			error = markvoldirty(pmp, 1);			if (error)				return (error); 		}	}	/*	 * Not an update, or updating the name: look up the name	 * and verify that it refers to a sensible disk device.	 */	if (vfs_getopt(mp->mnt_optnew, "from", (void **)&from, NULL))		return (EINVAL);	NDINIT(&ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, from, td);	error = namei(&ndp);	if (error)		return (error);	devvp = ndp.ni_vp;	NDFREE(&ndp, NDF_ONLY_PNBUF);	if (!vn_isdisk(devvp, &error)) {		vput(devvp);		return (error);	}	/*	 * If mount by non-root, then verify that user has necessary	 * permissions on the device.	 */	accmode = VREAD;	if ((mp->mnt_flag & MNT_RDONLY) == 0)		accmode |= VWRITE;	error = VOP_ACCESS(devvp, accmode, td->td_ucred, td);	if (error)		error = priv_check(td, PRIV_VFS_MOUNT_PERM);	if (error) {		vput(devvp);		return (error);	}	if ((mp->mnt_flag & MNT_UPDATE) == 0) {		error = mountmsdosfs(devvp, mp);#ifdef MSDOSFS_DEBUG		/* only needed for the printf below */		pmp = VFSTOMSDOSFS(mp);#endif	} else {		vput(devvp);		if (devvp != pmp->pm_devvp)			return (EINVAL);	/* XXX needs translation */	}	if (error) {		vrele(devvp);		return (error);	}	error = update_mp(mp, td);	if (error) {		if ((mp->mnt_flag & MNT_UPDATE) == 0)			msdosfs_unmount(mp, MNT_FORCE);		return error;	}	if (devvp->v_type == VCHR && devvp->v_rdev != NULL)		devvp->v_rdev->si_mountpt = mp;	vfs_mountedfrom(mp, from);#ifdef MSDOSFS_DEBUG	printf("msdosfs_mount(): mp %p, pmp %p, inusemap %p/n", mp, pmp, pmp->pm_inusemap);#endif	return (0);}

/* * Obtain a dquot structure for the specified identifier and quota file * reading the information from the file if necessary. */static intdqget(struct vnode *vp, u_long id, struct ufsmount *ump, int type,      struct dquot **dqp){    uint8_t buf[sizeof(struct dqblk64)];    off_t base, recsize;    struct dquot *dq, *dq1;    struct dqhash *dqh;    struct vnode *dqvp;    struct iovec aiov;    struct uio auio;    int dqvplocked, error;#ifdef DEBUG_VFS_LOCKS    if (vp != NULLVP)        ASSERT_VOP_ELOCKED(vp, "dqget");#endif    if (vp != NULLVP && *dqp != NODQUOT) {        return (0);    }    /* XXX: Disallow negative id values to prevent the    * creation of 100GB+ quota data files.    */    if ((int)id < 0)        return (EINVAL);    UFS_LOCK(ump);    dqvp = ump->um_quotas[type];    if (dqvp == NULLVP || (ump->um_qflags[type] & QTF_CLOSING)) {        *dqp = NODQUOT;        UFS_UNLOCK(ump);        return (EINVAL);    }    vref(dqvp);    UFS_UNLOCK(ump);    error = 0;    dqvplocked = 0;    /*     * Check the cache first.     */    dqh = DQHASH(dqvp, id);    DQH_LOCK();    dq = dqhashfind(dqh, id, dqvp);    if (dq != NULL) {        DQH_UNLOCK();hfound:        DQI_LOCK(dq);        DQI_WAIT(dq, PINOD+1, "dqget");        DQI_UNLOCK(dq);        if (dq->dq_ump == NULL) {            dqrele(vp, dq);            dq = NODQUOT;            error = EIO;        }        *dqp = dq;        if (dqvplocked)            vput(dqvp);        else            vrele(dqvp);        return (error);    }    /*     * Quota vnode lock is before DQ_LOCK. Acquire dqvp lock there     * since new dq will appear on the hash chain DQ_LOCKed.     */    if (vp != dqvp) {        DQH_UNLOCK();        vn_lock(dqvp, LK_SHARED | LK_RETRY);        dqvplocked = 1;        DQH_LOCK();        /*         * Recheck the cache after sleep for quota vnode lock.         */        dq = dqhashfind(dqh, id, dqvp);        if (dq != NULL) {            DQH_UNLOCK();            goto hfound;        }    }    /*     * Not in cache, allocate a new one or take it from the     * free list.     */    if (TAILQ_FIRST(&dqfreelist) == NODQUOT &&            numdquot < MAXQUOTAS * desiredvnodes)        desireddquot += DQUOTINC;    if (numdquot < desireddquot) {        numdquot++;        DQH_UNLOCK();        dq1 = malloc(sizeof *dq1, M_DQUOT, M_WAITOK | M_ZERO);        mtx_init(&dq1->dq_lock, "dqlock", NULL, MTX_DEF);//.........这里部分代码省略.........

/* * Unmount the filesystem described by mp. */static intmsdosfs_unmount(struct mount *mp, int mntflags){	struct msdosfsmount *pmp;	int error, flags;	error = flags = 0;	pmp = VFSTOMSDOSFS(mp);	if ((pmp->pm_flags & MSDOSFSMNT_RONLY) == 0)		error = msdosfs_sync(mp, MNT_WAIT);	if ((mntflags & MNT_FORCE) != 0)		flags |= FORCECLOSE;	else if (error != 0)		return (error);	error = vflush(mp, 0, flags, curthread);	if (error != 0 && error != ENXIO)		return (error);	if ((pmp->pm_flags & MSDOSFSMNT_RONLY) == 0) {		error = markvoldirty(pmp, 0);		if (error && error != ENXIO) {			(void)markvoldirty(pmp, 1);			return (error);		}	}	if (pmp->pm_flags & MSDOSFSMNT_KICONV && msdosfs_iconv) {		if (pmp->pm_w2u)			msdosfs_iconv->close(pmp->pm_w2u);		if (pmp->pm_u2w)			msdosfs_iconv->close(pmp->pm_u2w);		if (pmp->pm_d2u)			msdosfs_iconv->close(pmp->pm_d2u);		if (pmp->pm_u2d)			msdosfs_iconv->close(pmp->pm_u2d);	}#ifdef MSDOSFS_DEBUG	{		struct vnode *vp = pmp->pm_devvp;		struct bufobj *bo;		bo = &vp->v_bufobj;		BO_LOCK(bo);		VI_LOCK(vp);		vn_printf(vp,		    "msdosfs_umount(): just before calling VOP_CLOSE()/n");		printf("freef %p, freeb %p, mount %p/n",		    TAILQ_NEXT(vp, v_actfreelist), vp->v_actfreelist.tqe_prev,		    vp->v_mount);		printf("cleanblkhd %p, dirtyblkhd %p, numoutput %ld, type %d/n",		    TAILQ_FIRST(&vp->v_bufobj.bo_clean.bv_hd),		    TAILQ_FIRST(&vp->v_bufobj.bo_dirty.bv_hd),		    vp->v_bufobj.bo_numoutput, vp->v_type);		VI_UNLOCK(vp);		BO_UNLOCK(bo);	}#endif	DROP_GIANT();	if (pmp->pm_devvp->v_type == VCHR && pmp->pm_devvp->v_rdev != NULL)		pmp->pm_devvp->v_rdev->si_mountpt = NULL;	g_topology_lock();	g_vfs_close(pmp->pm_cp);	g_topology_unlock();	PICKUP_GIANT();	vrele(pmp->pm_devvp);	dev_rel(pmp->pm_dev);	free(pmp->pm_inusemap, M_MSDOSFSFAT);	if (pmp->pm_flags & MSDOSFS_LARGEFS)		msdosfs_fileno_free(mp);	lockdestroy(&pmp->pm_fatlock);	free(pmp, M_MSDOSFSMNT);	mp->mnt_data = NULL;	MNT_ILOCK(mp);	mp->mnt_flag &= ~MNT_LOCAL;	MNT_IUNLOCK(mp);	return (error);}

//.........这里部分代码省略.........        UFS_UNLOCK(ump);        VOP_UNLOCK(vp, 0);        (void) vn_close(vp, FREAD|FWRITE, td->td_ucred, td);        vfs_unbusy(mp);        return (EALREADY);    }    ump->um_qflags[type] |= QTF_OPENING|QTF_CLOSING;    UFS_UNLOCK(ump);    if ((error = dqopen(vp, ump, type)) != 0) {        VOP_UNLOCK(vp, 0);        UFS_LOCK(ump);        ump->um_qflags[type] &= ~(QTF_OPENING|QTF_CLOSING);        UFS_UNLOCK(ump);        (void) vn_close(vp, FREAD|FWRITE, td->td_ucred, td);        vfs_unbusy(mp);        return (error);    }    VOP_UNLOCK(vp, 0);    MNT_ILOCK(mp);    mp->mnt_flag |= MNT_QUOTA;    MNT_IUNLOCK(mp);    vpp = &ump->um_quotas[type];    if (*vpp != vp)        quotaoff1(td, mp, type);    /*     * When the directory vnode containing the quota file is     * inactivated, due to the shared lookup of the quota file     * vput()ing the dvp, the qsyncvp() call for the containing     * directory would try to acquire the quota lock exclusive.     * At the same time, lookup already locked the quota vnode     * shared.  Mark the quota vnode lock as allowing recursion     * and automatically converting shared locks to exclusive.     *     * Also mark quota vnode as system.     */    vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);    vp->v_vflag |= VV_SYSTEM;    VN_LOCK_AREC(vp);    VN_LOCK_DSHARE(vp);    VOP_UNLOCK(vp, 0);    *vpp = vp;    /*     * Save the credential of the process that turned on quotas.     * Set up the time limits for this quota.     */    ump->um_cred[type] = crhold(td->td_ucred);    ump->um_btime[type] = MAX_DQ_TIME;    ump->um_itime[type] = MAX_IQ_TIME;    if (dqget(NULLVP, 0, ump, type, &dq) == 0) {        if (dq->dq_btime > 0)            ump->um_btime[type] = dq->dq_btime;        if (dq->dq_itime > 0)            ump->um_itime[type] = dq->dq_itime;        dqrele(NULLVP, dq);    }    /*     * Allow the getdq from getinoquota below to read the quota     * from file.     */    UFS_LOCK(ump);    ump->um_qflags[type] &= ~QTF_CLOSING;    UFS_UNLOCK(ump);    /*     * Search vnodes associated with this mount point,     * adding references to quota file being opened.     * NB: only need to add dquot's for inodes being modified.     */again:    MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {        if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {            MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);            goto again;        }        if (vp->v_type == VNON || vp->v_writecount == 0) {            VOP_UNLOCK(vp, 0);            vrele(vp);            continue;        }        error = getinoquota(VTOI(vp));        VOP_UNLOCK(vp, 0);        vrele(vp);        if (error) {            MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);            break;        }    }    if (error)        quotaoff_inchange(td, mp, type);    UFS_LOCK(ump);    ump->um_qflags[type] &= ~QTF_OPENING;    KASSERT((ump->um_qflags[type] & QTF_CLOSING) == 0,            ("quotaon: leaking flags"));    UFS_UNLOCK(ump);    vfs_unbusy(mp);    return (error);}

static intmsdosfs_sync(struct mount *mp, int waitfor){	struct vnode *vp, *nvp;	struct thread *td;	struct denode *dep;	struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);	int error, allerror = 0;	td = curthread;	/*	 * If we ever switch to not updating all of the fats all the time,	 * this would be the place to update them from the first one.	 */	if (pmp->pm_fmod != 0) {		if (pmp->pm_flags & MSDOSFSMNT_RONLY)			panic("msdosfs_sync: rofs mod");		else {			/* update fats here */		}	}	/*	 * Write back each (modified) denode.	 */loop:	MNT_VNODE_FOREACH_ALL(vp, mp, nvp) {		if (vp->v_type == VNON) {			VI_UNLOCK(vp);			continue;		}		dep = VTODE(vp);		if ((dep->de_flag &		    (DE_ACCESS | DE_CREATE | DE_UPDATE | DE_MODIFIED)) == 0 &&		    (vp->v_bufobj.bo_dirty.bv_cnt == 0 ||		    waitfor == MNT_LAZY)) {			VI_UNLOCK(vp);			continue;		}		error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, td);		if (error) {			if (error == ENOENT)				goto loop;			continue;		}		error = VOP_FSYNC(vp, waitfor, td);		if (error)			allerror = error;		VOP_UNLOCK(vp, 0);		vrele(vp);	}	/*	 * Flush filesystem control info.	 */	if (waitfor != MNT_LAZY) {		vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY);		error = VOP_FSYNC(pmp->pm_devvp, waitfor, td);		if (error)			allerror = error;		VOP_UNLOCK(pmp->pm_devvp, 0);	}	error = msdosfs_fsiflush(pmp, waitfor);	if (error != 0)		allerror = error;	return (allerror);}

//.........这里部分代码省略.........#ifdef MACHINE_STACK_GROWS_UP	stack = (char *)vm->vm_maxsaddr + sizeof(arginfo) + sgap;	slen = len - sizeof(arginfo) - sgap;#else	stack = (char *)(vm->vm_minsaddr - len);#endif	/* Now copy argc, args & environ to new stack */	if (!(*pack.ep_emul->e_copyargs)(&pack, &arginfo, stack, argp))		goto exec_abort;	/* copy out the process's ps_strings structure */	if (copyout(&arginfo, (char *)pr->ps_strings, sizeof(arginfo)))		goto exec_abort;	stopprofclock(pr);	/* stop profiling */	fdcloseexec(p);		/* handle close on exec */	execsigs(p);		/* reset caught signals */	TCB_SET(p, NULL);	/* reset the TCB address */	pr->ps_kbind_addr = 0;	/* reset the kbind bits */	pr->ps_kbind_cookie = 0;	/* set command name & other accounting info */	memset(p->p_comm, 0, sizeof(p->p_comm));	len = min(nid.ni_cnd.cn_namelen, MAXCOMLEN);	memcpy(p->p_comm, nid.ni_cnd.cn_nameptr, len);	pr->ps_acflag &= ~AFORK;	/* record proc's vnode, for use by sysctl */	otvp = pr->ps_textvp;	vref(pack.ep_vp);	pr->ps_textvp = pack.ep_vp;	if (otvp)		vrele(otvp);	atomic_setbits_int(&pr->ps_flags, PS_EXEC);	if (pr->ps_flags & PS_PPWAIT) {		atomic_clearbits_int(&pr->ps_flags, PS_PPWAIT);		atomic_clearbits_int(&pr->ps_pptr->ps_flags, PS_ISPWAIT);		wakeup(pr->ps_pptr);	}	/*	 * If process does execve() while it has a mismatched real,	 * effective, or saved uid/gid, we set PS_SUGIDEXEC.	 */	if (cred->cr_uid != cred->cr_ruid ||	    cred->cr_uid != cred->cr_svuid ||	    cred->cr_gid != cred->cr_rgid ||	    cred->cr_gid != cred->cr_svgid)		atomic_setbits_int(&pr->ps_flags, PS_SUGIDEXEC);	else		atomic_clearbits_int(&pr->ps_flags, PS_SUGIDEXEC);	atomic_clearbits_int(&pr->ps_flags, PS_TAMED);	tame_dropwpaths(pr);	/*	 * deal with set[ug]id.	 * MNT_NOEXEC has already been used to disable s[ug]id.	 */	if ((attr.va_mode & (VSUID | VSGID)) && proc_cansugid(p)) {		int i;		atomic_setbits_int(&pr->ps_flags, PS_SUGID|PS_SUGIDEXEC);

//.........这里部分代码省略.........#if 0	uprintf("loader is %s/n", emul_arg->loader_name);#endif	/*	 * open the loader, see if it's an ECOFF executable,	 * make sure the object type is amenable, then arrange to	 * load it up.	 */	ldr_vp = epp->ep_interp;	epp->ep_interp = NULL;	vn_lock(ldr_vp, LK_EXCLUSIVE | LK_RETRY);	/*	 * Basic access checks.  Reject if:	 *	not a regular file	 *	exec not allowed on binary	 *	exec not allowed on mount point	 */	if (ldr_vp->v_type != VREG) {		error = EACCES;		goto badunlock;	}	if ((error = VOP_ACCESS(ldr_vp, VEXEC, l->l_cred)) != 0)		goto badunlock;        if (ldr_vp->v_mount->mnt_flag & MNT_NOEXEC) {                error = EACCES;                goto badunlock;        }	/*	 * If loader's mount point disallows set-id execution,	 * disable set-id.	 */        if (ldr_vp->v_mount->mnt_flag & MNT_NOSUID)                epp->ep_vap->va_mode &= ~(S_ISUID | S_ISGID);	VOP_UNLOCK(ldr_vp);	/*	 * read the header, and make sure we got all of it.	 */        if ((error = vn_rdwr(UIO_READ, ldr_vp, (void *)&ldr_exechdr,	    sizeof ldr_exechdr, 0, UIO_SYSSPACE, 0, l->l_cred,	    &resid, NULL)) != 0)                goto bad;        if (resid != 0) {                error = ENOEXEC;                goto bad;	}	/*	 * Check the magic.  We expect it to be the native Alpha ECOFF	 * (Digital UNIX) magic number.  Also make sure it's not a shared	 * lib or dynamically linked executable.	 */	if (ldr_exechdr.f.f_magic != ECOFF_MAGIC_ALPHA) {		error = ENOEXEC;		goto bad;	}        switch (ldr_exechdr.f.f_flags & ECOFF_FLAG_OBJECT_TYPE_MASK) {        case ECOFF_OBJECT_TYPE_SHARABLE:        case ECOFF_OBJECT_TYPE_CALL_SHARED:		/* can't exec shared lib or dynamically linked executable. */		error = ENOEXEC;		goto bad;	}	switch (ldr_exechdr.a.magic) {	case ECOFF_OMAGIC:		error = exec_ecoff_prep_omagic(l, epp, &ldr_exechdr, ldr_vp);		break;	case ECOFF_NMAGIC:		error = exec_ecoff_prep_nmagic(l, epp, &ldr_exechdr, ldr_vp);		break;	case ECOFF_ZMAGIC:		error = exec_ecoff_prep_zmagic(l, epp, &ldr_exechdr, ldr_vp);		break;	default:		error = ENOEXEC;	}	if (error)		goto bad;	/* finally, set up the stack. */	error = (*epp->ep_esch->es_setup_stack)(l, epp);	if (error)		goto bad;	vrele(ldr_vp);	return (0);badunlock:	VOP_UNLOCK(ldr_vp);bad:	vrele(ldr_vp);	return (error);}

static intudf_mount(struct mount *mp){	struct vnode *devvp;	/* vnode of the mount device */	struct thread *td;	struct udf_mnt *imp = NULL;	struct vfsoptlist *opts;	char *fspec, *cs_disk, *cs_local;	int error, len, *udf_flags;	struct nameidata nd, *ndp = &nd;	td = curthread;	opts = mp->mnt_optnew;	/*	 * Unconditionally mount as read-only.	 */	MNT_ILOCK(mp);	mp->mnt_flag |= MNT_RDONLY;	MNT_IUNLOCK(mp);	/*	 * No root filesystem support.  Probably not a big deal, since the	 * bootloader doesn't understand UDF.	 */	if (mp->mnt_flag & MNT_ROOTFS)		return (ENOTSUP);	fspec = NULL;	error = vfs_getopt(opts, "from", (void **)&fspec, &len);	if (!error && fspec[len - 1] != '/0')		return (EINVAL);	if (mp->mnt_flag & MNT_UPDATE) {		return (0);	}	/* Check that the mount device exists */	if (fspec == NULL)		return (EINVAL);	NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td);	if ((error = namei(ndp)))		return (error);	NDFREE(ndp, NDF_ONLY_PNBUF);	devvp = ndp->ni_vp;	if (vn_isdisk(devvp, &error) == 0) {		vput(devvp);		return (error);	}	/* Check the access rights on the mount device */	error = VOP_ACCESS(devvp, VREAD, td->td_ucred, td);	if (error)		error = priv_check(td, PRIV_VFS_MOUNT_PERM);	if (error) {		vput(devvp);		return (error);	}	if ((error = udf_mountfs(devvp, mp))) {		vrele(devvp);		return (error);	}	imp = VFSTOUDFFS(mp);	udf_flags = NULL;	error = vfs_getopt(opts, "flags", (void **)&udf_flags, &len);	if (error || len != sizeof(int))		return (EINVAL);	imp->im_flags = *udf_flags;	if (imp->im_flags & UDFMNT_KICONV && udf_iconv) {		cs_disk = NULL;		error = vfs_getopt(opts, "cs_disk", (void **)&cs_disk, &len);		if (!error && cs_disk[len - 1] != '/0')			return (EINVAL);		cs_local = NULL;		error = vfs_getopt(opts, "cs_local", (void **)&cs_local, &len);		if (!error && cs_local[len - 1] != '/0')			return (EINVAL);		udf_iconv->open(cs_local, cs_disk, &imp->im_d2l);#if 0		udf_iconv->open(cs_disk, cs_local, &imp->im_l2d);#endif	}	vfs_mountedfrom(mp, fspec);	return 0;};

intudf_mount(struct mount *mp, const char *path, void *data,    struct nameidata *ndp,  struct proc *p){	struct vnode *devvp;	/* vnode of the mount device */	struct udf_args args;	size_t len;	int error;	if ((mp->mnt_flag & MNT_RDONLY) == 0) {		mp->mnt_flag |= MNT_RDONLY;#ifdef UDF_DEBUG		printf("udf_mount: enforcing read-only mode/n");#endif	}	/*	 * No root filesystem support.  Probably not a big deal, since the	 * bootloader doesn't understand UDF.	 */	if (mp->mnt_flag & MNT_ROOTFS)		return (EOPNOTSUPP);	error = copyin(data, &args, sizeof(struct udf_args));	if (error)		return (error);	if (args.fspec == NULL)		return (EINVAL);	NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);	if ((error = namei(ndp)))		return (error);	devvp = ndp->ni_vp;	if (devvp->v_type != VBLK) {		vrele(devvp);		return (ENOTBLK);	}	if (major(devvp->v_rdev) >= nblkdev) {		vrele(devvp);		return (ENXIO);	}	/* Check the access rights on the mount device */	if (p->p_ucred->cr_uid) {		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);		error = VOP_ACCESS(devvp, VREAD, p->p_ucred, p);		VOP_UNLOCK(devvp, 0, p);		if (error) {			vrele(devvp);			return (error);		}	}	if ((error = udf_mountfs(devvp, mp, args.lastblock, p))) {		vrele(devvp);		return (error);	}	/*	 * Keep a copy of the mount information.	 */	copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &len);	bzero(mp->mnt_stat.f_mntonname + len, MNAMELEN - len);	copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &len);	bzero(mp->mnt_stat.f_mntfromname + len, MNAMELEN - len);	return (0);};

//.........这里部分代码省略.........	/*	 * Found component in pathname.	 * If the final component of path name, save information	 * in the cache as to where the entry was found.	 */	if ((flags & ISLASTCN) && nameiop == LOOKUP)		results->ulr_diroff = results->ulr_offset &~ (dirblksiz - 1);	/*	 * If deleting, and at end of pathname, return	 * parameters which can be used to remove file.	 * Lock the inode, being careful with ".".	 */	if (nameiop == DELETE && (flags & ISLASTCN)) {		/*		 * Return pointer to current entry in results->ulr_offset,		 * and distance past previous entry (if there		 * is a previous entry in this block) in results->ulr_count.		 * Save directory inode pointer in ndp->ni_dvp for dirremove().		 */		if ((results->ulr_offset & (dirblksiz - 1)) == 0)			results->ulr_count = 0;		else			results->ulr_count = results->ulr_offset - prevoff;		if (dp->i_number == foundino) {			vref(vdp);			tdp = vdp;		} else {			error = vcache_get(vdp->v_mount,			    &foundino, sizeof(foundino), &tdp);			if (error)				return (error);		}		/*		 * Write access to directory required to delete files.		 */		if ((error = VOP_ACCESS(vdp, VWRITE, cred)) != 0) {			vrele(tdp);			return (error);		}		/*		 * If directory is "sticky", then user must own		 * the directory, or the file in it, else she		 * may not delete it (unless she's root). This		 * implements append-only directories.		 */		if (dp->i_e2fs_mode & ISVTX) {			error = kauth_authorize_vnode(cred, KAUTH_VNODE_DELETE,			    tdp, vdp, genfs_can_sticky(cred, dp->i_uid,			    VTOI(tdp)->i_uid));			if (error) {				vrele(tdp);				return (EPERM);			}		}		*vpp = tdp;		return (0);	}	/*	 * If rewriting (RENAME), return the inode and the	 * information required to rewrite the present directory	 * Must get inode of directory entry to verify it's a	 * regular file, or empty directory.	 */	if (nameiop == RENAME && (flags & ISLASTCN)) {		error = VOP_ACCESS(vdp, VWRITE, cred);		if (error)			return (error);		/*		 * Careful about locking second inode.		 * This can only occur if the target is ".".		 */		if (dp->i_number == foundino)			return (EISDIR);		error = vcache_get(vdp->v_mount,		    &foundino, sizeof(foundino), &tdp);		if (error)			return (error);		*vpp = tdp;		return (0);	}	if (dp->i_number == foundino) {		vref(vdp);	/* we want ourself, ie "." */		*vpp = vdp;	} else {		error = vcache_get(vdp->v_mount,		    &foundino, sizeof(foundino), &tdp);		if (error)			return (error);		*vpp = tdp;	}	/*	 * Insert name into cache if appropriate.	 */	cache_enter(vdp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags);	return 0;}