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

/* * Reload all incore data for a filesystem (used after running fsck on * the root filesystem and finding things to fix). The filesystem must * be mounted read-only. * * Things to do to update the mount: *	1) invalidate all cached meta-data. *	2) re-read superblock from disk. *	3) re-read summary information from disk. *	4) invalidate all inactive vnodes. *	5) invalidate all cached file data. *	6) re-read inode data for all active vnodes. */intext2fs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l){	struct vnode *vp, *devvp;	struct inode *ip;	struct buf *bp;	struct m_ext2fs *fs;	struct ext2fs *newfs;	int i, error;	struct ufsmount *ump;	struct vnode_iterator *marker;	if ((mp->mnt_flag & MNT_RDONLY) == 0)		return EINVAL;	ump = VFSTOUFS(mp);	/*	 * Step 1: invalidate all cached meta-data.	 */	devvp = ump->um_devvp;	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);	error = vinvalbuf(devvp, 0, cred, l, 0, 0);	VOP_UNLOCK(devvp);	if (error)		panic("ext2fs_reload: dirty1");	fs = ump->um_e2fs;	/*	 * Step 2: re-read superblock from disk. Copy in new superblock, and compute	 * in-memory values.	 */	error = bread(devvp, SBLOCK, SBSIZE, 0, &bp);	if (error)		return error;	newfs = (struct ext2fs *)bp->b_data;	e2fs_sbload(newfs, &fs->e2fs);	brelse(bp, 0);	error = ext2fs_sbfill(fs, (mp->mnt_flag & MNT_RDONLY) != 0);	if (error)		return error;	/*	 * Step 3: re-read summary information from disk.	 */	for (i = 0; i < fs->e2fs_ngdb; i++) {		error = bread(devvp ,		    EXT2_FSBTODB(fs, fs->e2fs.e2fs_first_dblock +		    1 /* superblock */ + i),		    fs->e2fs_bsize, 0, &bp);		if (error) {			return error;		}		e2fs_cgload((struct ext2_gd *)bp->b_data,		    &fs->e2fs_gd[i * fs->e2fs_bsize / sizeof(struct ext2_gd)],		    fs->e2fs_bsize);		brelse(bp, 0);	}	vfs_vnode_iterator_init(mp, &marker);	while ((vp = vfs_vnode_iterator_next(marker, NULL, NULL))) {		/*		 * Step 4: invalidate all inactive vnodes.		 */		if (vrecycle(vp))			continue;		/*		 * Step 5: invalidate all cached file data.		 */		if (vn_lock(vp, LK_EXCLUSIVE)) {			vrele(vp);			continue;		}		if (vinvalbuf(vp, 0, cred, l, 0, 0))			panic("ext2fs_reload: dirty2");		/*		 * Step 6: re-read inode data for all active vnodes.		 */		ip = VTOI(vp);		error = bread(devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)),		    (int)fs->e2fs_bsize, 0, &bp);		if (error) {			vput(vp);			break;		}		error = ext2fs_loadvnode_content(fs, ip->i_number, bp, ip);//.........这里部分代码省略.........

/* * Allocate a new inode. */intext2fs_makeinode(int mode, struct vnode *dvp, struct vnode **vpp,    struct componentname *cnp){	struct inode *ip, *pdir;	struct vnode *tvp;	int error;	pdir = VTOI(dvp);#ifdef DIAGNOSTIC	if ((cnp->cn_flags & HASBUF) == 0)		panic("ext2fs_makeinode: no name");#endif	*vpp = NULL;	if ((mode & IFMT) == 0)		mode |= IFREG;	if ((error = ext2fs_inode_alloc(pdir, mode, cnp->cn_cred, &tvp)) 	    != 0) {		pool_put(&namei_pool, cnp->cn_pnbuf);		vput(dvp);		return (error);	}	ip = VTOI(tvp);	ip->i_e2fs_gid = pdir->i_e2fs_gid;	ip->i_e2fs_uid = cnp->cn_cred->cr_uid;	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;	ip->i_e2fs_mode = mode;	tvp->v_type = IFTOVT(mode);	/* Rest init'd in getnewvnode(). */	ip->i_e2fs_nlink = 1;	if ((ip->i_e2fs_mode & ISGID) &&		!groupmember(ip->i_e2fs_gid, cnp->cn_cred) &&	    suser_ucred(cnp->cn_cred))		ip->i_e2fs_mode &= ~ISGID;	/*	 * Make sure inode goes to disk before directory entry.	 */	if ((error = ext2fs_update(ip, NULL, NULL, 1)) != 0)		goto bad;	error = ext2fs_direnter(ip, dvp, cnp);	if (error != 0)		goto bad;	if ((cnp->cn_flags & SAVESTART) == 0)		pool_put(&namei_pool, cnp->cn_pnbuf);	vput(dvp);	*vpp = tvp;	return (0);bad:	/*	 * Write error occurred trying to update the inode	 * or the directory so must deallocate the inode.	 */	pool_put(&namei_pool, cnp->cn_pnbuf);	vput(dvp);	ip->i_e2fs_nlink = 0;	ip->i_flag |= IN_CHANGE;	tvp->v_type = VNON;	vput(tvp);	return (error);}

static intufs_extattr_autostart_locked(struct mount *mp, struct thread *td){	struct vnode *rvp, *attr_dvp, *attr_system_dvp, *attr_user_dvp;	struct ufsmount *ump = VFSTOUFS(mp);	int error;	/*	 * UFS_EXTATTR applies only to UFS1, as UFS2 uses native extended	 * attributes, so don't autostart.	 */	if (ump->um_fstype != UFS1)		return (0);	/*	 * Does UFS_EXTATTR_FSROOTSUBDIR exist off the filesystem root?	 * If so, automatically start EA's.	 */	error = VFS_ROOT(mp, LK_EXCLUSIVE, &rvp);	if (error) {		printf("ufs_extattr_autostart.VFS_ROOT() returned %d/n",		    error);		return (error);	}	error = ufs_extattr_lookup(rvp, UE_GETDIR_LOCKPARENT_DONT,	    UFS_EXTATTR_FSROOTSUBDIR, &attr_dvp, td);	if (error) {		/* rvp ref'd but now unlocked */		vrele(rvp);		return (error);	}	if (rvp == attr_dvp) {		/* Should never happen. */		vput(rvp);		vrele(attr_dvp);		return (EINVAL);	}	vrele(rvp);	if (attr_dvp->v_type != VDIR) {		printf("ufs_extattr_autostart: %s != VDIR/n",		    UFS_EXTATTR_FSROOTSUBDIR);		goto return_vput_attr_dvp;	}	error = ufs_extattr_start_locked(ump, td);	if (error) {		printf("ufs_extattr_autostart: ufs_extattr_start failed (%d)/n",		    error);		goto return_vput_attr_dvp;	}	/*	 * Look for two subdirectories: UFS_EXTATTR_SUBDIR_SYSTEM,	 * UFS_EXTATTR_SUBDIR_USER.  For each, iterate over the sub-directory,	 * and start with appropriate type.  Failures in either don't	 * result in an over-all failure.  attr_dvp is left locked to	 * be cleaned up on exit.	 */	error = ufs_extattr_lookup(attr_dvp, UE_GETDIR_LOCKPARENT,	    UFS_EXTATTR_SUBDIR_SYSTEM, &attr_system_dvp, td);	if (!error) {		error = ufs_extattr_iterate_directory(VFSTOUFS(mp),		    attr_system_dvp, EXTATTR_NAMESPACE_SYSTEM, td);		if (error)			printf("ufs_extattr_iterate_directory returned %d/n",			    error);		vput(attr_system_dvp);	}	error = ufs_extattr_lookup(attr_dvp, UE_GETDIR_LOCKPARENT,	    UFS_EXTATTR_SUBDIR_USER, &attr_user_dvp, td);	if (!error) {		error = ufs_extattr_iterate_directory(VFSTOUFS(mp),		    attr_user_dvp, EXTATTR_NAMESPACE_USER, td);		if (error)			printf("ufs_extattr_iterate_directory returned %d/n",			    error);		vput(attr_user_dvp);	}	/* Mask startup failures in sub-directories. */	error = 0;return_vput_attr_dvp:	vput(attr_dvp);	return (error);}

/* * XXX Ugly bit of code.  But, this is the only safe time that the * match between BIOS disks and native disks can be done. */static voidmatchbiosdisks(void){	struct btinfo_biosgeom *big;	struct bi_biosgeom_entry *be;	device_t dv;	deviter_t di;	int i, ck, error, m, n;	struct vnode *tv;	char mbr[DEV_BSIZE];	int dklist_size;	int numbig;	big = lookup_bootinfo(BTINFO_BIOSGEOM);	numbig = big ? big->num : 0;	/* First, count all native disks. */	for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST); dv != NULL;	     dv = deviter_next(&di)) {		if (is_valid_disk(dv))			x86_ndisks++;	}	deviter_release(&di);	dklist_size = sizeof(struct disklist) + (x86_ndisks - 1) *	    sizeof(struct nativedisk_info);	/* XXX M_TEMP is wrong */	x86_alldisks = malloc(dklist_size, M_TEMP, M_NOWAIT | M_ZERO);	if (x86_alldisks == NULL)		return;	x86_alldisks->dl_nnativedisks = x86_ndisks;	x86_alldisks->dl_nbiosdisks = numbig;	for (i = 0; i < numbig; i++) {		x86_alldisks->dl_biosdisks[i].bi_dev = big->disk[i].dev;		x86_alldisks->dl_biosdisks[i].bi_sec = big->disk[i].sec;		x86_alldisks->dl_biosdisks[i].bi_head = big->disk[i].head;		x86_alldisks->dl_biosdisks[i].bi_cyl = big->disk[i].cyl;		x86_alldisks->dl_biosdisks[i].bi_lbasecs = big->disk[i].totsec;		x86_alldisks->dl_biosdisks[i].bi_flags = big->disk[i].flags;#ifdef GEOM_DEBUG#ifdef notyet		printf("disk %x: flags %x, interface %x, device %llx/n",		       big->disk[i].dev, big->disk[i].flags,		       big->disk[i].interface_path, big->disk[i].device_path);#endif#endif	}	/* XXX Code duplication from findroot(). */	n = -1;	for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST); dv != NULL;	     dv = deviter_next(&di)) {		if (device_class(dv) != DV_DISK)			continue;#ifdef GEOM_DEBUG		printf("matchbiosdisks: trying to match (%s) %s/n",		    device_xname(dv), device_cfdata(dv)->cf_name);#endif		if (is_valid_disk(dv)) {			n++;			snprintf(x86_alldisks->dl_nativedisks[n].ni_devname,			    sizeof(x86_alldisks->dl_nativedisks[n].ni_devname),			    "%s", device_xname(dv));			if ((tv = opendisk(dv)) == NULL)				continue;			error = vn_rdwr(UIO_READ, tv, mbr, DEV_BSIZE, 0,			    UIO_SYSSPACE, 0, NOCRED, NULL, NULL);			VOP_CLOSE(tv, FREAD, NOCRED);			vput(tv);			if (error) {#ifdef GEOM_DEBUG				printf("matchbiosdisks: %s: MBR read failure/n",				    device_xname(dv));#endif				continue;			}			for (ck = i = 0; i < DEV_BSIZE; i++)				ck += mbr[i];			for (m = i = 0; i < numbig; i++) {				be = &big->disk[i];#ifdef GEOM_DEBUG				printf("match %s with %d "				    "dev ck %x bios ck %x/n", device_xname(dv), i,				    ck, be->cksum);#endif				if (be->flags & BI_GEOM_INVALID)					continue;				if (be->cksum == ck &&				    memcmp(&mbr[MBR_PART_OFFSET], be->mbrparts,				        MBR_PART_COUNT *//.........这里部分代码省略.........

/* * nfs statfs call */static intnfs_statfs(struct mount *mp, struct statfs *sbp){	struct vnode *vp;	struct thread *td;	struct nfs_statfs *sfp;	caddr_t bpos, dpos;	struct nfsmount *nmp = VFSTONFS(mp);	int error = 0, v3 = (nmp->nm_flag & NFSMNT_NFSV3), retattr;	struct mbuf *mreq, *mrep, *md, *mb;	struct nfsnode *np;	u_quad_t tquad;	td = curthread;#ifndef nolint	sfp = NULL;#endif	error = vfs_busy(mp, MBF_NOWAIT);	if (error)		return (error);	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np, LK_EXCLUSIVE);	if (error) {		vfs_unbusy(mp);		return (error);	}	vp = NFSTOV(np);	mtx_lock(&nmp->nm_mtx);	if (v3 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) {		mtx_unlock(&nmp->nm_mtx);				(void)nfs_fsinfo(nmp, vp, td->td_ucred, td);	} else		mtx_unlock(&nmp->nm_mtx);	nfsstats.rpccnt[NFSPROC_FSSTAT]++;	mreq = nfsm_reqhead(vp, NFSPROC_FSSTAT, NFSX_FH(v3));	mb = mreq;	bpos = mtod(mb, caddr_t);	nfsm_fhtom(vp, v3);	nfsm_request(vp, NFSPROC_FSSTAT, td, td->td_ucred);	if (v3)		nfsm_postop_attr(vp, retattr);	if (error) {		if (mrep != NULL)			m_freem(mrep);		goto nfsmout;	}	sfp = nfsm_dissect(struct nfs_statfs *, NFSX_STATFS(v3));	mtx_lock(&nmp->nm_mtx);	sbp->f_iosize = nfs_iosize(nmp);	mtx_unlock(&nmp->nm_mtx);	if (v3) {		sbp->f_bsize = NFS_FABLKSIZE;		tquad = fxdr_hyper(&sfp->sf_tbytes);		sbp->f_blocks = tquad / NFS_FABLKSIZE;		tquad = fxdr_hyper(&sfp->sf_fbytes);		sbp->f_bfree = tquad / NFS_FABLKSIZE;		tquad = fxdr_hyper(&sfp->sf_abytes);		sbp->f_bavail = tquad / NFS_FABLKSIZE;		sbp->f_files = (fxdr_unsigned(int32_t,		    sfp->sf_tfiles.nfsuquad[1]) & 0x7fffffff);		sbp->f_ffree = (fxdr_unsigned(int32_t,		    sfp->sf_ffiles.nfsuquad[1]) & 0x7fffffff);	} else {		sbp->f_bsize = fxdr_unsigned(int32_t, sfp->sf_bsize);		sbp->f_blocks = fxdr_unsigned(int32_t, sfp->sf_blocks);		sbp->f_bfree = fxdr_unsigned(int32_t, sfp->sf_bfree);		sbp->f_bavail = fxdr_unsigned(int32_t, sfp->sf_bavail);		sbp->f_files = 0;		sbp->f_ffree = 0;	}	m_freem(mrep);nfsmout:	vput(vp);	vfs_unbusy(mp);	return (error);}

//.........这里部分代码省略.........    struct ucred *cred = proc->p_ucred;#endif    int flags = FFLAGS(user_flags);    int index;    struct file *fp;    int mode;    struct nnpfs_fhandle_t fh;    NNPFSDEB(XDEBVFOPS, ("nnpfs_fhopen: flags = %d/n", user_flags));    error = copyin (fhp, &fh, sizeof(fh));    if (error)	return error;    error = nnpfs_fhlookup (proc, &fh, &vp);    NNPFSDEB(XDEBVFOPS, ("nnpfs_fhlookup returned %d/n", error));    if (error)	return error;    switch (vp->v_type) {    case VDIR :    case VREG :	break;    case VLNK :	error = EMLINK;	goto out;    default :	error = EOPNOTSUPP;	goto out;    }    mode = 0;    if (flags & FWRITE) {	switch (vp->v_type) {	case VREG :	    break;	case VDIR :	    error = EISDIR;	    goto out;	default :	    error = EOPNOTSUPP;	    goto out;	}	error = vn_writechk (vp);	if (error)	    goto out;	mode |= VWRITE;    }    if (flags & FREAD)	mode |= VREAD;    if (mode) {	error = VOP_ACCESS(vp, mode, cred, proc);	if (error)	    goto out;    }    error = VOP_OPEN(vp, flags, cred, proc);    if (error)	goto out;    error = falloc(proc, &fp, &index);    if (error)	goto out;    if (flags & FWRITE)        vp->v_writecount++;#if defined(__FreeBSD_version) && __FreeBSD_version >= 300000    if (vp->v_type == VREG) {#ifdef HAVE_FREEBSD_THREAD	error = nnpfs_vfs_object_create(vp, proc, proc->td_proc->p_ucred);#else	error = nnpfs_vfs_object_create(vp, proc, proc->p_ucred);#endif	if (error)	    goto out;    }#endif    fp->f_flag = flags & FMASK;    fp->f_type = DTYPE_VNODE;    fp->f_ops  = &vnops;    fp->f_data = (caddr_t)vp;    nnpfs_vfs_unlock(vp, proc);    *retval = index;#ifdef FILE_UNUSE    FILE_UNUSE(fp, proc);#endif#ifdef __APPLE__    *fdflags(proc, index) &= ~UF_RESERVED;#endif    return 0;out:    NNPFSDEB(XDEBVFOPS, ("nnpfs_fhopen: error = %d/n", error));    vput(vp);    return error;}

/* * If deget() succeeds it returns with the gotten denode locked().  * * pmp	     - address of msdosfsmount structure of the filesystem containing *	       the denode of interest.  The pm_dev field and the address of *	       the msdosfsmount structure are used.  * dirclust  - which cluster bp contains, if dirclust is 0 (root directory) *	       diroffset is relative to the beginning of the root directory, *	       otherwise it is cluster relative.  * diroffset - offset past begin of cluster of denode we want  * depp	     - returns the address of the gotten denode. */intdeget(struct msdosfsmount *pmp, uint32_t dirclust, uint32_t diroffset,    struct denode **depp){	int error;	extern struct vops msdosfs_vops;	struct direntry *direntptr;	struct denode *ldep;	struct vnode *nvp;	struct buf *bp;	struct proc *p = curproc; /* XXX */#ifdef MSDOSFS_DEBUG	printf("deget(pmp %08x, dirclust %d, diroffset %x, depp %08x)/n",	    pmp, dirclust, diroffset, depp);#endif	/*	 * On FAT32 filesystems, root is a (more or less) normal	 * directory	 */	if (FAT32(pmp) && dirclust == MSDOSFSROOT)		dirclust = pmp->pm_rootdirblk;	/*	 * See if the denode is in the denode cache. Use the location of	 * the directory entry to compute the hash value. For subdir use	 * address of "." entry. For root dir (if not FAT32) use cluster	 * MSDOSFSROOT, offset MSDOSFSROOT_OFS	 * 	 * NOTE: The check for de_refcnt > 0 below insures the denode being	 * examined does not represent an unlinked but still open file.	 * These files are not to be accessible even when the directory	 * entry that represented the file happens to be reused while the	 * deleted file is still open.	 */retry:	ldep = msdosfs_hashget(pmp->pm_dev, dirclust, diroffset);	if (ldep) {		*depp = ldep;		return (0);	}	/*	 * Directory entry was not in cache, have to create a vnode and	 * copy it from the passed disk buffer.	 */	/* getnewvnode() does a vref() on the vnode */	error = getnewvnode(VT_MSDOSFS, pmp->pm_mountp, &msdosfs_vops, &nvp);	if (error) {		*depp = 0;		return (error);	}	ldep = malloc(sizeof(*ldep), M_MSDOSFSNODE, M_WAITOK | M_ZERO);	lockinit(&ldep->de_lock, PINOD, "denode", 0, 0);	nvp->v_data = ldep;	ldep->de_vnode = nvp;	ldep->de_flag = 0;	ldep->de_devvp = 0;	ldep->de_lockf = 0;	ldep->de_dev = pmp->pm_dev;	ldep->de_dirclust = dirclust;	ldep->de_diroffset = diroffset;	fc_purge(ldep, 0);	/* init the fat cache for this denode */	/*	 * Insert the denode into the hash queue and lock the denode so it	 * can't be accessed until we've read it in and have done what we	 * need to it.	 */	vn_lock(nvp, LK_EXCLUSIVE | LK_RETRY, p);	error = msdosfs_hashins(ldep);	if (error) {		vput (nvp);				if (error == EEXIST)			goto retry;		return (error);	}	ldep->de_pmp = pmp;	ldep->de_devvp = pmp->pm_devvp;	ldep->de_refcnt = 1;	/*	 * Copy the directory entry into the denode area of the vnode.	 *///.........这里部分代码省略.........

//.........这里部分代码省略.........		    dnode->tn_dir.tn_parent, cnp->cn_lkflags, vpp);		if (error != 0)			goto out;	} else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {		VREF(dvp);		*vpp = dvp;		error = 0;	} else {		de = tmpfs_dir_lookup(dnode, NULL, cnp);		if (de != NULL && de->td_node == NULL)			cnp->cn_flags |= ISWHITEOUT;		if (de == NULL || de->td_node == NULL) {			/* The entry was not found in the directory.			 * This is OK if we are creating or renaming an			 * entry and are working on the last component of			 * the path name. */			if ((cnp->cn_flags & ISLASTCN) &&			    (cnp->cn_nameiop == CREATE || /			    cnp->cn_nameiop == RENAME ||			    (cnp->cn_nameiop == DELETE &&			    cnp->cn_flags & DOWHITEOUT &&			    cnp->cn_flags & ISWHITEOUT))) {				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,				    cnp->cn_thread);				if (error != 0)					goto out;				/* Keep the component name in the buffer for				 * future uses. */				cnp->cn_flags |= SAVENAME;				error = EJUSTRETURN;			} else				error = ENOENT;		} else {			struct tmpfs_node *tnode;			/* The entry was found, so get its associated			 * tmpfs_node. */			tnode = de->td_node;			/* If we are not at the last path component and			 * found a non-directory or non-link entry (which			 * may itself be pointing to a directory), raise			 * an error. */			if ((tnode->tn_type != VDIR &&			    tnode->tn_type != VLNK) &&			    !(cnp->cn_flags & ISLASTCN)) {				error = ENOTDIR;				goto out;			}			/* If we are deleting or renaming the entry, keep			 * track of its tmpfs_dirent so that it can be			 * easily deleted later. */			if ((cnp->cn_flags & ISLASTCN) &&			    (cnp->cn_nameiop == DELETE ||			    cnp->cn_nameiop == RENAME)) {				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,				    cnp->cn_thread);				if (error != 0)					goto out;				/* Allocate a new vnode on the matching entry. */				error = tmpfs_alloc_vp(dvp->v_mount, tnode,				    cnp->cn_lkflags, vpp);				if (error != 0)					goto out;				if ((dnode->tn_mode & S_ISTXT) &&				  VOP_ACCESS(dvp, VADMIN, cnp->cn_cred, cnp->cn_thread) &&				  VOP_ACCESS(*vpp, VADMIN, cnp->cn_cred, cnp->cn_thread)) {					error = EPERM;					vput(*vpp);					*vpp = NULL;					goto out;				}				cnp->cn_flags |= SAVENAME;			} else {				error = tmpfs_alloc_vp(dvp->v_mount, tnode,				    cnp->cn_lkflags, vpp);				if (error != 0)					goto out;			}		}	}	/* Store the result of this lookup in the cache.  Avoid this if the	 * request was for creation, as it does not improve timings on	 * emprical tests. */	if ((cnp->cn_flags & MAKEENTRY) != 0)		cache_enter(dvp, *vpp, cnp);out:	/* If there were no errors, *vpp cannot be null and it must be	 * locked. */	MPASS(IFF(error == 0, *vpp != NULLVP && VOP_ISLOCKED(*vpp)));	return error;}

//.........这里部分代码省略.........	if (nameiop == NAMEI_DELETE) {		/*		 * Write access to directory required to delete files.		 */		if ((error = VOP_EACCESS(vdp, VWRITE, cred)) != 0)			return (error);		/*		 * Return pointer to current entry in dp->i_offset,		 * and distance past previous entry (if there		 * is a previous entry in this block) in dp->i_count.		 * Save directory inode pointer in ndp->ni_dvp for dirremove().		 */		if ((dp->i_offset & (DIRBLKSIZ - 1)) == 0)			dp->i_count = 0;		else			dp->i_count = dp->i_offset - prevoff;		if (dp->i_number == dp->i_ino) {			vref(vdp);			*vpp = vdp;			return (0);		}		if ((error = VFS_VGET(vdp->v_mount, NULL, dp->i_ino, &tdp)) != 0)			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_mode & ISVTX) &&		    cred->cr_uid != 0 &&		    cred->cr_uid != dp->i_uid &&		    VTOI(tdp)->i_uid != cred->cr_uid) {			vput(tdp);			return (EPERM);		}		*vpp = tdp;		if (!lockparent)			vn_unlock(vdp);		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 == NAMEI_RENAME && wantparent) {		if ((error = VOP_EACCESS(vdp, VWRITE, cred)) != 0)			return (error);		/*		 * Careful about locking second inode.		 * This can only occur if the target is ".".		 */		if (dp->i_number == dp->i_ino)			return (EISDIR);		if ((error = VFS_VGET(vdp->v_mount, NULL, dp->i_ino, &tdp)) != 0)			return (error);		*vpp = tdp;		if (!lockparent)			vn_unlock(vdp);		return (0);	}	/*

//.........这里部分代码省略.........			TMPFS_UNLOCK(tmp);			if (n == NULL) {				error = EINVAL;				if (newname != NULL)					    free(newname, M_TMPFSNAME);				goto out_locked;			}			TMPFS_NODE_UNLOCK(n);			/* Adjust the parent pointer. */			TMPFS_VALIDATE_DIR(fnode);			TMPFS_NODE_LOCK(de->td_node);			de->td_node->tn_dir.tn_parent = tdnode;			TMPFS_NODE_UNLOCK(de->td_node);			/* As a result of changing the target of the '..'			 * entry, the link count of the source and target			 * directories has to be adjusted. */			TMPFS_NODE_LOCK(tdnode);			TMPFS_ASSERT_LOCKED(tdnode);			tdnode->tn_links++;			TMPFS_NODE_UNLOCK(tdnode);			TMPFS_NODE_LOCK(fdnode);			TMPFS_ASSERT_LOCKED(fdnode);			fdnode->tn_links--;			TMPFS_NODE_UNLOCK(fdnode);		}	}	/* Do the move: just remove the entry from the source directory	 * and insert it into the target one. */	tmpfs_dir_detach(fdvp, de);	if (fcnp->cn_flags & DOWHITEOUT)		tmpfs_dir_whiteout_add(fdvp, fcnp);	if (tcnp->cn_flags & ISWHITEOUT)		tmpfs_dir_whiteout_remove(tdvp, tcnp);	/* If the name has changed, we need to make it effective by changing	 * it in the directory entry. */	if (newname != NULL) {		MPASS(tcnp->cn_namelen <= MAXNAMLEN);		free(de->ud.td_name, M_TMPFSNAME);		de->ud.td_name = newname;		tmpfs_dirent_init(de, tcnp->cn_nameptr, tcnp->cn_namelen);		fnode->tn_status |= TMPFS_NODE_CHANGED;		tdnode->tn_status |= TMPFS_NODE_MODIFIED;	}	/* If we are overwriting an entry, we have to remove the old one	 * from the target directory. */	if (tvp != NULL) {		struct tmpfs_dirent *tde;		/* Remove the old entry from the target directory. */		tde = tmpfs_dir_lookup(tdnode, tnode, tcnp);		tmpfs_dir_detach(tdvp, tde);		/* 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);	}	tmpfs_dir_attach(tdvp, de);	cache_purge(fvp);	if (tvp != NULL)		cache_purge(tvp);	cache_purge_negative(tdvp);	error = 0;out_locked:	if (fdvp != tdvp && fdvp != tvp)		VOP_UNLOCK(fdvp, 0);out:	/* Release target nodes. */	/* XXX: I don't understand when tdvp can be the same as tvp, but	 * other code takes care of this... */	if (tdvp == tvp)		vrele(tdvp);	else		vput(tdvp);	if (tvp != NULL)		vput(tvp);	/* Release source nodes. */	vrele(fdvp);	vrele(fvp);	if (mp != NULL)		vfs_unbusy(mp);	return error;}

static intpuffs_vnop_rename(struct vop_nrename_args *ap){    PUFFS_MSG_VARS(vn, rename);    struct nchandle *fnch = ap->a_fnch;    struct nchandle *tnch = ap->a_tnch;    struct vnode *fdvp = ap->a_fdvp;    struct vnode *fvp = fnch->ncp->nc_vp;    struct vnode *tdvp = ap->a_tdvp;    struct vnode *tvp = tnch->ncp->nc_vp;    struct ucred *cred = ap->a_cred;    struct puffs_mount *pmp = MPTOPUFFSMP(fdvp->v_mount);    int error;    if (!EXISTSOP(pmp, RENAME))        return EOPNOTSUPP;    error = vget(tdvp, LK_EXCLUSIVE);    if (error != 0) {        DPRINTF(("puffs_vnop_rename: EAGAIN on tdvp vnode %p %s/n",                 tdvp, tnch->ncp->nc_name));        return EAGAIN;    }    if (tvp != NULL) {        error = vget(tvp, LK_EXCLUSIVE);        if (error != 0) {            DPRINTF(("puffs_vnop_rename: EAGAIN on tvp vnode %p %s/n",                     tvp, tnch->ncp->nc_name));            vput(tdvp);            return EAGAIN;        }    }    if ((fvp->v_mount != tdvp->v_mount) ||            (tvp && (fvp->v_mount != tvp->v_mount))) {        error = EXDEV;        goto out;    }    if (tvp) {        if (fvp->v_type == VDIR && tvp->v_type != VDIR) {            error = ENOTDIR;            goto out;        } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {            error = EISDIR;            goto out;        }    }    PUFFS_MSG_ALLOC(vn, rename);    rename_msg->pvnr_cookie_src = VPTOPNC(fvp);    rename_msg->pvnr_cookie_targdir = VPTOPNC(tdvp);    if (tvp)        rename_msg->pvnr_cookie_targ = VPTOPNC(tvp);    else        rename_msg->pvnr_cookie_targ = NULL;    puffs_makecn(&rename_msg->pvnr_cn_src, &rename_msg->pvnr_cn_src_cred,                 fnch->ncp, cred);    puffs_makecn(&rename_msg->pvnr_cn_targ, &rename_msg->pvnr_cn_targ_cred,                 tnch->ncp, cred);    puffs_msg_setinfo(park_rename, PUFFSOP_VN,                      PUFFS_VN_RENAME, VPTOPNC(fdvp));    PUFFS_MSG_ENQUEUEWAIT2(pmp, park_rename, fdvp->v_data, NULL, error);    PUFFS_MSG_RELEASE(rename);    error = checkerr(pmp, error, __func__);    if (error == 0)        puffs_updatenode(VPTOPP(fvp), PUFFS_UPDATECTIME);out:    if (tvp != NULL)        vn_unlock(tvp);    if (tdvp != tvp)        vn_unlock(tdvp);    if (error == 0)        cache_rename(fnch, tnch);    if (tvp != NULL)        vrele(tvp);    vrele(tdvp);    return error;}

intntfs_lookup(void *v){	struct vop_lookup_args *ap = v;	struct vnode *dvp = ap->a_dvp;	struct ntnode *dip = VTONT(dvp);	struct ntfsmount *ntmp = dip->i_mp;	struct componentname *cnp = ap->a_cnp;	struct ucred *cred = cnp->cn_cred;	int error;	int lockparent = cnp->cn_flags & LOCKPARENT;	struct proc *p = cnp->cn_proc;#if NTFS_DEBUG	int wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);#endif	DPRINTF("ntfs_lookup: /"%.*s/" (%ld bytes) in %u, lp: %d, wp: %d /n",	    (unsigned int)cnp->cn_namelen, cnp->cn_nameptr, cnp->cn_namelen,	    dip->i_number, lockparent, wantparent);	error = VOP_ACCESS(dvp, VEXEC, cred, cnp->cn_proc);	if(error)		return (error);	if ((cnp->cn_flags & ISLASTCN) &&	    (dvp->v_mount->mnt_flag & MNT_RDONLY) &&	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))		return (EROFS);	/*	 * We now have a segment name to search for, and a directory	 * to search.	 *	 * Before tediously performing a linear scan of the directory,	 * check the name cache to see if the directory/name pair	 * we are looking for is known already.	 */	if ((error = cache_lookup(ap->a_dvp, ap->a_vpp, cnp)) >= 0)		return (error);	if(cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {		DPRINTF("ntfs_lookup: faking . directory in %u/n",		    dip->i_number);		vref(dvp);		*ap->a_vpp = dvp;		error = 0;	} else if (cnp->cn_flags & ISDOTDOT) {		struct ntvattr *vap;		DPRINTF("ntfs_lookup: faking .. directory in %u/n",		    dip->i_number);		VOP_UNLOCK(dvp, 0, p);		cnp->cn_flags |= PDIRUNLOCK;		error = ntfs_ntvattrget(ntmp, dip, NTFS_A_NAME, NULL, 0, &vap);		if(error)			return (error);		DPRINTF("ntfs_lookup: parentdir: %u/n",		    vap->va_a_name->n_pnumber);		error = VFS_VGET(ntmp->ntm_mountp,				 vap->va_a_name->n_pnumber,ap->a_vpp); 		ntfs_ntvattrrele(vap);		if (error) {			if (vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p) == 0)				cnp->cn_flags &= ~PDIRUNLOCK;			return (error);		}		if (lockparent && (cnp->cn_flags & ISLASTCN)) {			error = vn_lock(dvp, LK_EXCLUSIVE, p);			if (error) {				vput( *(ap->a_vpp) );				return (error);			}			cnp->cn_flags &= ~PDIRUNLOCK;		}	} else {		error = ntfs_ntlookupfile(ntmp, dvp, cnp, ap->a_vpp, p);		if (error) {			DPRINTF("ntfs_ntlookupfile: returned %d/n", error);			return (error);		}		DPRINTF("ntfs_lookup: found ino: %u/n",		    VTONT(*ap->a_vpp)->i_number);		if(!lockparent || (cnp->cn_flags & ISLASTCN) == 0) {			VOP_UNLOCK(dvp, 0, p);			cnp->cn_flags |= PDIRUNLOCK;		}	}	if (cnp->cn_flags & MAKEENTRY)		cache_enter(dvp, *ap->a_vpp, cnp);	return (error);}

VMBlockVFSMount(struct mount *mp,        // IN: mount(2) parameters                struct thread *td)       // IN: caller's thread context#endif{   struct VMBlockMount *xmp;   struct nameidata nd, *ndp = &nd;   struct vnode *lowerrootvp, *vp;   char *target;   char *pathname;   int len, error = 0;   VMBLOCKDEBUG("VMBlockVFSMount(mp = %p)/n", (void *)mp);   /*    * TODO:  Strip out extraneous export & other misc cruft.    */   /*    * Disallow the following:    *   1.  Mounting over the system root.    *   2.  Mount updates/remounts.  (Reconsider for rw->ro, ro->rw?)    *   3.  Mounting VMBlock on top of a VMBlock.    */   if ((mp->mnt_flag & MNT_ROOTFS) ||       (mp->mnt_flag & MNT_UPDATE) ||       (mp->mnt_vnodecovered->v_op == &VMBlockVnodeOps)) {      return EOPNOTSUPP;   }   /*    * XXX Should only be unlocked if mnt_flag & MNT_UPDATE.    */   ASSERT_VOP_UNLOCKED(mp->mnt_vnodecovered, "Covered vnode already locked!");   /*    * Look up path to lower layer (VMBlock source / DnD staging area).    * (E.g., in the command "mount /tmp/VMwareDnD /var/run/vmblock",    * /tmp/VMwareDnD is the staging area.)    */   error = vfs_getopt(mp->mnt_optnew, "target", (void **)&target, &len);   if (error || target[len - 1] != '/0') {      return EINVAL;   }   pathname = uma_zalloc(VMBlockPathnameZone, M_WAITOK);   if (pathname == NULL) {      return ENOMEM;   }   if (strlcpy(pathname, target, MAXPATHLEN) >= MAXPATHLEN) {      uma_zfree(VMBlockPathnameZone, pathname);      return ENAMETOOLONG;   }   /*    * Find lower node and lock if not already locked.    */   NDINIT(ndp, LOOKUP, FOLLOW|LOCKLEAF, UIO_SYSSPACE, target, compat_td);   error = namei(ndp);   if (error) {      NDFREE(ndp, 0);      uma_zfree(VMBlockPathnameZone, pathname);      return error;   }   NDFREE(ndp, NDF_ONLY_PNBUF);   /*    * Check multi VMBlock mount to avoid `lock against myself' panic.    */   lowerrootvp = ndp->ni_vp;   if (lowerrootvp == VPTOVMB(mp->mnt_vnodecovered)->lowerVnode) {      VMBLOCKDEBUG("VMBlockVFSMount: multi vmblock mount?/n");      vput(lowerrootvp);      uma_zfree(VMBlockPathnameZone, pathname);      return EDEADLK;   }   xmp = malloc(sizeof *xmp, M_VMBLOCKFSMNT, M_WAITOK);   /*    * Record pointer (mountVFS) to the staging area's file system.  Follow up    * by grabbing a VMBlockNode for our layer's root.    */   xmp->mountVFS = lowerrootvp->v_mount;   error = VMBlockNodeGet(mp, lowerrootvp, &vp, pathname);   /*    * Make sure the node alias worked    */   if (error) {      COMPAT_VOP_UNLOCK(vp, 0, compat_td);      vrele(lowerrootvp);      free(xmp, M_VMBLOCKFSMNT);   /* XXX */      uma_zfree(VMBlockPathnameZone, pathname);      return error;   }   /*    * Record a reference to the new filesystem's root vnode & mark it as such.//.........这里部分代码省略.........

static intsmbfs_node_alloc(struct mount *mp, struct vnode *dvp, const char *dirnm, 	int dirlen, const char *name, int nmlen, char sep, 	struct smbfattr *fap, struct vnode **vpp){	struct vattr vattr;	struct thread *td = curthread;	/* XXX */	struct smbmount *smp = VFSTOSMBFS(mp);	struct smbnode *np, *dnp;	struct vnode *vp, *vp2;	struct smbcmp sc;	char *p, *rpath;	int error, rplen;	sc.n_parent = dvp;	sc.n_nmlen = nmlen;	sc.n_name = name;		if (smp->sm_root != NULL && dvp == NULL) {		SMBERROR("do not allocate root vnode twice!/n");		return EINVAL;	}	if (nmlen == 2 && bcmp(name, "..", 2) == 0) {		if (dvp == NULL)			return EINVAL;		vp = VTOSMB(VTOSMB(dvp)->n_parent)->n_vnode;		error = vget(vp, LK_EXCLUSIVE, td);		if (error == 0)			*vpp = vp;		return error;	} else if (nmlen == 1 && name[0] == '.') {		SMBERROR("do not call me with dot!/n");		return EINVAL;	}	dnp = dvp ? VTOSMB(dvp) : NULL;	if (dnp == NULL && dvp != NULL) {		vprint("smbfs_node_alloc: dead parent vnode", dvp);		return EINVAL;	}	error = vfs_hash_get(mp, smbfs_hash(name, nmlen), LK_EXCLUSIVE, td,	    vpp, smbfs_vnode_cmp, &sc);	if (error)		return (error);	if (*vpp) {		np = VTOSMB(*vpp);		/* Force cached attributes to be refreshed if stale. */		(void)VOP_GETATTR(*vpp, &vattr, td->td_ucred);		/*		 * If the file type on the server is inconsistent with		 * what it was when we created the vnode, kill the		 * bogus vnode now and fall through to the code below		 * to create a new one with the right type.		 */		if (((*vpp)->v_type == VDIR && 		    (np->n_dosattr & SMB_FA_DIR) == 0) ||	    	    ((*vpp)->v_type == VREG && 		    (np->n_dosattr & SMB_FA_DIR) != 0)) {			vgone(*vpp);			vput(*vpp);		}		else {			SMBVDEBUG("vnode taken from the hashtable/n");			return (0);		}	}	/*	 * If we don't have node attributes, then it is an explicit lookup	 * for an existing vnode.	 */	if (fap == NULL)		return ENOENT;	error = getnewvnode("smbfs", mp, &smbfs_vnodeops, vpp);	if (error)		return (error);	vp = *vpp;	np = malloc(sizeof *np, M_SMBNODE, M_WAITOK | M_ZERO);	rplen = dirlen;	if (sep != '/0')		rplen++;	rplen += nmlen;	rpath = malloc(rplen + 1, M_SMBNODENAME, M_WAITOK);	p = rpath;	bcopy(dirnm, p, dirlen);	p += dirlen;	if (sep != '/0')		*p++ = sep;	if (name != NULL) {		bcopy(name, p, nmlen);		p += nmlen;	}	*p = '/0';	MPASS(p == rpath + rplen);	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);	/* Vnode initialization */	vp->v_type = fap->fa_attr & SMB_FA_DIR ? VDIR : VREG;	vp->v_data = np;	np->n_vnode = vp;	np->n_mount = VFSTOSMBFS(mp);	np->n_rpath = rpath;	np->n_rplen = rplen;//.........这里部分代码省略.........

//.........这里部分代码省略.........	/*	 * Copy the directory entry into the denode area of the vnode.	 */	if ((dirclust == MSDOSFSROOT	     || (FAT32(pmp) && dirclust == pmp->pm_rootdirblk))	    && diroffset == MSDOSFSROOT_OFS) {		/*		 * Directory entry for the root directory. There isn't one,		 * so we manufacture one. We should probably rummage		 * through the root directory and find a label entry (if it		 * exists), and then use the time and date from that entry		 * as the time and date for the root denode.		 */		nvp->v_vflag |= VV_ROOT; /* should be further down XXX */		ldep->de_Attributes = ATTR_DIRECTORY;		ldep->de_LowerCase = 0;		if (FAT32(pmp))			ldep->de_StartCluster = pmp->pm_rootdirblk;			/* de_FileSize will be filled in further down */		else {			ldep->de_StartCluster = MSDOSFSROOT;			ldep->de_FileSize = pmp->pm_rootdirsize * DEV_BSIZE;		}		/*		 * fill in time and date so that fattime2timespec() doesn't		 * spit up when called from msdosfs_getattr() with root		 * denode		 */		ldep->de_CHun = 0;		ldep->de_CTime = 0x0000;	/* 00:00:00	 */		ldep->de_CDate = (0 << DD_YEAR_SHIFT) | (1 << DD_MONTH_SHIFT)		    | (1 << DD_DAY_SHIFT);		/* Jan 1, 1980	 */		ldep->de_ADate = ldep->de_CDate;		ldep->de_MTime = ldep->de_CTime;		ldep->de_MDate = ldep->de_CDate;		/* leave the other fields as garbage */	} else {		error = readep(pmp, dirclust, diroffset, &bp, &direntptr);		if (error) {			/*			 * The denode does not contain anything useful, so			 * it would be wrong to leave it on its hash chain.			 * Arrange for vput() to just forget about it.			 */			ldep->de_Name[0] = SLOT_DELETED;			vput(nvp);			*depp = NULL;			return (error);		}		(void)DE_INTERNALIZE(ldep, direntptr);		brelse(bp);	}	/*	 * Fill in a few fields of the vnode and finish filling in the	 * denode.  Then return the address of the found denode.	 */	if (ldep->de_Attributes & ATTR_DIRECTORY) {		/*		 * Since DOS directory entries that describe directories		 * have 0 in the filesize field, we take this opportunity		 * to find out the length of the directory and plug it into		 * the denode structure.		 */		u_long size;		/*		 * XXX it sometimes happens that the "." entry has cluster		 * number 0 when it shouldn't.  Use the actual cluster number		 * instead of what is written in directory entry.		 */		if (diroffset == 0 && ldep->de_StartCluster != dirclust) {#ifdef MSDOSFS_DEBUG			printf("deget(): /"./" entry at clust %lu != %lu/n",			    dirclust, ldep->de_StartCluster);#endif			ldep->de_StartCluster = dirclust;		}		nvp->v_type = VDIR;		if (ldep->de_StartCluster != MSDOSFSROOT) {			error = pcbmap(ldep, 0xffff, 0, &size, 0);			if (error == E2BIG) {				ldep->de_FileSize = de_cn2off(pmp, size);				error = 0;			} else {#ifdef MSDOSFS_DEBUG				printf("deget(): pcbmap returned %d/n", error);#endif			}		}	} else		nvp->v_type = VREG;	ldep->de_modrev = init_va_filerev();	*depp = ldep;	return (0);}

/* ARGSUSED */intcompat_43_sys_lstat(struct lwp *l, const struct compat_43_sys_lstat_args *uap, register_t *retval){	/* {		syscallarg(char *) path;		syscallarg(struct ostat *) ub;	} */	struct vnode *vp, *dvp;	struct stat sb, sb1;	struct stat43 osb;	int error;	struct pathbuf *pb;	struct nameidata nd;	int ndflags;	error = pathbuf_copyin(SCARG(uap, path), &pb);	if (error) {		return error;	}	ndflags = NOFOLLOW | LOCKLEAF | LOCKPARENT | TRYEMULROOT;again:	NDINIT(&nd, LOOKUP, ndflags, pb);	if ((error = namei(&nd))) {		if (error == EISDIR && (ndflags & LOCKPARENT) != 0) {			/*			 * Should only happen on '/'. Retry without LOCKPARENT;			 * this is safe since the vnode won't be a VLNK.			 */			ndflags &= ~LOCKPARENT;			goto again;		}		pathbuf_destroy(pb);		return (error);	}	/*	 * For symbolic links, always return the attributes of its	 * containing directory, except for mode, size, and links.	 */	vp = nd.ni_vp;	dvp = nd.ni_dvp;	pathbuf_destroy(pb);	if (vp->v_type != VLNK) {		if ((ndflags & LOCKPARENT) != 0) {			if (dvp == vp)				vrele(dvp);			else				vput(dvp);		}		error = vn_stat(vp, &sb);		vput(vp);		if (error)			return (error);	} else {		error = vn_stat(dvp, &sb);		vput(dvp);		if (error) {			vput(vp);			return (error);		}		error = vn_stat(vp, &sb1);		vput(vp);		if (error)			return (error);		sb.st_mode &= ~S_IFDIR;		sb.st_mode |= S_IFLNK;		sb.st_nlink = sb1.st_nlink;		sb.st_size = sb1.st_size;		sb.st_blocks = sb1.st_blocks;	}	cvtstat(&sb, &osb);	error = copyout((void *)&osb, (void *)SCARG(uap, ub), sizeof (osb));	return (error);}

intnnpfs_fhlookup (d_thread_t *proc,	      struct nnpfs_fhandle_t *fhp,	      struct vnode **vpp){    int error;    struct mount *mp;#if !(defined(HAVE_GETFH) && defined(HAVE_FHOPEN))    struct ucred *cred = proc->p_ucred;    struct vattr vattr;    fsid_t fsid;    struct nnpfs_fh_args *fh_args = (struct nnpfs_fh_args *)fhp->fhdata;    NNPFSDEB(XDEBVFOPS, ("nnpfs_fhlookup (nnpfs)/n"));    error = nnpfs_suser (proc);    if (error)	return EPERM;    if (fhp->len < sizeof(struct nnpfs_fh_args))	return EINVAL;        fsid = SCARG(fh_args, fsid);    mp = nnpfs_vfs_getvfs (&fsid);    if (mp == NULL)	return ENXIO;#ifdef __APPLE__    {	uint32_t ino = SCARG(fh_args, fileid);	error = VFS_VGET(mp, &ino, vpp);    }#else    error = VFS_VGET(mp, SCARG(fh_args, fileid), vpp);#endif    if (error)	return error;    if (*vpp == NULL)	return ENOENT;    error = VOP_GETATTR(*vpp, &vattr, cred, proc);    if (error) {	vput(*vpp);	return error;    }    if (vattr.va_gen != SCARG(fh_args, gen)) {	vput(*vpp);	return ENOENT;    }#else /* HAVE_GETFH && HAVE_FHOPEN */    {	fhandle_t *fh = (fhandle_t *) fhp;	NNPFSDEB(XDEBVFOPS, ("nnpfs_fhlookup (native)/n"));	mp = nnpfs_vfs_getvfs (&fh->fh_fsid);	if (mp == NULL)	    return ESTALE;	if ((error = VFS_FHTOVP(mp, &fh->fh_fid, vpp)) != 0) {	    *vpp = NULL;	    return error;	}    }#endif  /* HAVE_GETFH && HAVE_FHOPEN */#ifdef HAVE_KERNEL_VFS_OBJECT_CREATE    if ((*vpp)->v_type == VREG && (*vpp)->v_object == NULL)#ifdef HAVE_FREEBSD_THREAD	nnpfs_vfs_object_create (*vpp, proc, proc->td_proc->p_ucred);#else	nnpfs_vfs_object_create (*vpp, proc, proc->p_ucred);#endif#elif __APPLE__    if ((*vpp)->v_type == VREG && (!UBCINFOEXISTS(*vpp))) {        ubc_info_init(*vpp);    }    ubc_hold(*vpp);#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);		DQH_LOCK();//.........这里部分代码省略.........

/* * Given a locked directory vnode, iterate over the names in the directory * and use ufs_extattr_lookup() to retrieve locked vnodes of potential * attribute files.  Then invoke ufs_extattr_enable_with_open() on each * to attempt to start the attribute.  Leaves the directory locked on * exit. */static intufs_extattr_iterate_directory(struct ufsmount *ump, struct vnode *dvp,    int attrnamespace, struct thread *td){	struct vop_readdir_args vargs;	struct dirent *dp, *edp;	struct vnode *attr_vp;	struct uio auio;	struct iovec aiov;	char *dirbuf;	int error, eofflag = 0;	if (dvp->v_type != VDIR)		return (ENOTDIR);	dirbuf = malloc(DIRBLKSIZ, M_TEMP, M_WAITOK);	auio.uio_iov = &aiov;	auio.uio_iovcnt = 1;	auio.uio_rw = UIO_READ;	auio.uio_segflg = UIO_SYSSPACE;	auio.uio_td = td;	auio.uio_offset = 0;	vargs.a_gen.a_desc = NULL;	vargs.a_vp = dvp;	vargs.a_uio = &auio;	vargs.a_cred = td->td_ucred;	vargs.a_eofflag = &eofflag;	vargs.a_ncookies = NULL;	vargs.a_cookies = NULL;	while (!eofflag) {		auio.uio_resid = DIRBLKSIZ;		aiov.iov_base = dirbuf;		aiov.iov_len = DIRBLKSIZ;		error = ufs_readdir(&vargs);		if (error) {			printf("ufs_extattr_iterate_directory: ufs_readdir "			    "%d/n", error);			return (error);		}		/*		 * XXXRW: While in UFS, we always get DIRBLKSIZ returns from		 * the directory code on success, on other file systems this		 * may not be the case.  For portability, we should check the		 * read length on return from ufs_readdir().		 */		edp = (struct dirent *)&dirbuf[DIRBLKSIZ];		for (dp = (struct dirent *)dirbuf; dp < edp; ) {#if (BYTE_ORDER == LITTLE_ENDIAN)			dp->d_type = dp->d_namlen;			dp->d_namlen = 0;#else			dp->d_type = 0;#endif			if (dp->d_reclen == 0)				break;			error = ufs_extattr_lookup(dvp, UE_GETDIR_LOCKPARENT,			    dp->d_name, &attr_vp, td);			if (error) {				printf("ufs_extattr_iterate_directory: lookup "				    "%s %d/n", dp->d_name, error);			} else if (attr_vp == dvp) {				vrele(attr_vp);			} else if (attr_vp->v_type != VREG) {				vput(attr_vp);			} else {				error = ufs_extattr_enable_with_open(ump,				    attr_vp, attrnamespace, dp->d_name, td);				vrele(attr_vp);				if (error) {					printf("ufs_extattr_iterate_directory: "					    "enable %s %d/n", dp->d_name,					    error);				} else if (bootverbose) {					printf("UFS autostarted EA %s/n",					    dp->d_name);				}			}			dp = (struct dirent *) ((char *)dp + dp->d_reclen);			if (dp >= edp)				break;		}	}	free(dirbuf, M_TEMP);		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)		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);}

//.........这里部分代码省略.........			    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(ump->um_cp, 0, 1, 0);			g_topology_unlock();			PICKUP_GIANT();			if (error)				return (error);			if ((fs->e2fs->e2fs_state & E2FS_ISCLEAN) == 0 ||			    (fs->e2fs->e2fs_state & E2FS_ERRORS)) {				if (mp->mnt_flag & MNT_FORCE) {					printf("WARNING: %s was not properly dismounted/n", fs->e2fs_fsmnt);				} else {					printf("WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck/n",					    fs->e2fs_fsmnt);					return (EPERM);				}			}			fs->e2fs->e2fs_state &= ~E2FS_ISCLEAN;			(void)ext2_cgupdate(ump, MNT_WAIT);			fs->e2fs_ronly = 0;			MNT_ILOCK(mp);			mp->mnt_flag &= ~MNT_RDONLY;			MNT_IUNLOCK(mp);		}		if (vfs_flagopt(opts, "export", NULL, 0)) {			/* Process export requests in vfs_mount.c. */			return (error);		}	}	/*	 * Not an update, or updating the name: look up the name	 * and verify that it refers to a sensible disk device.	 */	if (fspec == NULL)		return (EINVAL);	NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td);	if ((error = namei(ndp)) != 0)		return (error);	NDFREE(ndp, NDF_ONLY_PNBUF);	devvp = ndp->ni_vp;	if (!vn_isdisk(devvp, &error)) {		vput(devvp);		return (error);	}	/*	 * If mount by non-root, then verify that user has necessary	 * permissions on the device.	 *	 * XXXRW: VOP_ACCESS() enough?	 */	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 = ext2_mountfs(devvp, mp);	} else {		if (devvp != ump->um_devvp) {			vput(devvp);			return (EINVAL);	/* needs translation */		} else			vput(devvp);	}	if (error) {		vrele(devvp);		return (error);	}	ump = VFSTOEXT2(mp);	fs = ump->um_e2fs;	/*	 * Note that this strncpy() is ok because of a check at the start	 * of ext2_mount().	 */	strncpy(fs->e2fs_fsmnt, path, MAXMNTLEN);	fs->e2fs_fsmnt[MAXMNTLEN - 1] = '/0';	vfs_mountedfrom(mp, fspec);	return (0);}

/* When successful this function returns data in the following "out"-arguments: *  o res_vnode: the vnode of the parent directory of "name" *  o name: the `basename' (the element of the pathname) *  o namelen: the length of the basename * * For example: dir_namev("/s5fs/bin/ls", &namelen, &name, NULL, * &res_vnode) would put 2 in namelen, "ls" in name, and a pointer to the * vnode corresponding to "/s5fs/bin" in res_vnode. * * The "base" argument defines where we start resolving the path from: * A base value of NULL means to use the process's current working directory, * curproc->p_cwd.  If pathname[0] == '/', ignore base and start with * vfs_root_vn.  dir_namev() should call lookup() to take care of resolving each * piece of the pathname. * * Note: A successful call to this causes vnode refcount on *res_vnode to * be incremented. */intdir_namev(const char *pathname, size_t *namelen, const char **name,          vnode_t *base, vnode_t **res_vnode){        /* VFS {{{ */        char *saveptr;        int err;        char *dirtok;        int dirlen;        char *nextok;        int nextlen;        vnode_t *curdir;        vnode_t *nextdir;        KASSERT(NULL != pathname);        KASSERT(NULL != namelen);        KASSERT(NULL != name);        KASSERT(NULL != res_vnode);        if ('/0' == pathname[0]) {                return -EINVAL;        }        /* Choose base directory */        if (pathname[0] == '/') {                curdir = vfs_root_vn;        } else if (base == NULL) {                curdir = curproc->p_cwd;        } else {                curdir = base;        }        KASSERT(NULL != curdir);        vref(curdir);        /* Follow the path */        saveptr = (char *) pathname;        dirtok = namev_tokenize(&saveptr, &dirlen);        nextok = namev_tokenize(&saveptr, &nextlen);        while (nextlen != 0) {                err = lookup(curdir, dirtok, dirlen, &nextdir);                vput(curdir);                if (0 != err) {                        return err;                }                curdir = nextdir;                dirtok = nextok;                dirlen = nextlen;                nextok = namev_tokenize(&saveptr, &nextlen);        }        *res_vnode = curdir;        *name = dirtok;        *namelen = dirlen;        /* VFS }}} */        return 0;}

/* * Look up an EXT2FS dinode number to find its incore vnode, otherwise read it * in from disk.  If it is in core, wait for the lock bit to clear, then * return the inode locked.  Detection and handling of mount points must be * done by the calling routine. */static intext2_vget(struct mount *mp, ino_t ino, int flags, struct vnode **vpp){	struct m_ext2fs *fs;	struct inode *ip;	struct ext2mount *ump;	struct buf *bp;	struct vnode *vp;	struct cdev *dev;	struct thread *td;	int i, error;	int used_blocks;	td = curthread;	error = vfs_hash_get(mp, ino, flags, td, vpp, NULL, NULL);	if (error || *vpp != NULL)		return (error);	ump = VFSTOEXT2(mp);	dev = ump->um_dev;	/*	 * If this malloc() is performed after the getnewvnode()	 * it might block, leaving a vnode with a NULL v_data to be	 * found by ext2_sync() if a sync happens to fire right then,	 * which will cause a panic because ext2_sync() blindly	 * dereferences vp->v_data (as well it should).	 */	ip = malloc(sizeof(struct inode), M_EXT2NODE, M_WAITOK | M_ZERO);	/* Allocate a new vnode/inode. */	if ((error = getnewvnode("ext2fs", mp, &ext2_vnodeops, &vp)) != 0) {		*vpp = NULL;		free(ip, M_EXT2NODE);		return (error);	}	vp->v_data = ip;	ip->i_vnode = vp;	ip->i_e2fs = fs = ump->um_e2fs;	ip->i_ump  = ump;	ip->i_number = ino;	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);	error = insmntque(vp, mp);	if (error != 0) {		free(ip, M_EXT2NODE);		*vpp = NULL;		return (error);	}	error = vfs_hash_insert(vp, ino, flags, td, vpp, NULL, NULL);	if (error || *vpp != NULL)		return (error);	/* Read in the disk contents for the inode, copy into the inode. */	if ((error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),	    (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {		/*		 * The inode does not contain anything useful, so it would		 * be misleading to leave it on its hash chain. With mode		 * still zero, it will be unlinked and returned to the free		 * list by vput().		 */		brelse(bp);		vput(vp);		*vpp = NULL;		return (error);	}	/* convert ext2 inode to dinode */	ext2_ei2i((struct ext2fs_dinode *) ((char *)bp->b_data + EXT2_INODE_SIZE(fs) *			ino_to_fsbo(fs, ino)), ip);	ip->i_block_group = ino_to_cg(fs, ino);	ip->i_next_alloc_block = 0;	ip->i_next_alloc_goal = 0;	/*	 * Now we want to make sure that block pointers for unused	 * blocks are zeroed out - ext2_balloc depends on this	 * although for regular files and directories only	 */	if(S_ISDIR(ip->i_mode) || S_ISREG(ip->i_mode)) {		used_blocks = (ip->i_size+fs->e2fs_bsize-1) / fs->e2fs_bsize;		for (i = used_blocks; i < EXT2_NDIR_BLOCKS; i++)			ip->i_db[i] = 0;	}/*	ext2_print_inode(ip);*/	bqrelse(bp);	/*	 * Initialize the vnode from the inode, check for aliases.	 * Note that the underlying vnode may have changed.	 */	if ((error = ext2_vinit(mp, &ext2_fifoops, &vp)) != 0) {//.........这里部分代码省略.........

/* * Helper function for findroot(): * Return non-zero if disk device matches bootinfo. */static intmatch_bootdisk(struct device *dv, struct btinfo_bootdisk *bid){	struct vnode *tmpvn;	int error;	struct disklabel label;	int found = 0;	int bmajor;	/*	 * A disklabel is required here.  The boot loader doesn't refuse	 * to boot from a disk without a label, but this is normally not	 * wanted.	 */	if (bid->labelsector == -1)		return (0);		/*	 * Lookup major number for disk block device.	 */	bmajor = devsw_name2blk(dv->dv_xname, NULL, 0);	if (bmajor == -1)		return (0);	/* XXX panic ??? */	/*	 * Fake a temporary vnode for the disk, open it, and read	 * the disklabel for comparison.	 */	if (bdevvp(MAKEDISKDEV(bmajor, dv->dv_unit, RAW_PART), &tmpvn))		panic("match_bootdisk: can't alloc vnode");	error = VOP_OPEN(tmpvn, FREAD, NOCRED);	if (error) {#ifndef DEBUG		/*		 * Ignore errors caused by missing device, partition,		 * or medium.		 */		if (error != ENXIO && error != ENODEV)#endif			printf("match_bootdisk: can't open dev %s (%d)/n",			    dv->dv_xname, error);		vput(tmpvn);		return (0);	}	error = VOP_IOCTL(tmpvn, DIOCGDINFO, &label, FREAD, NOCRED);	if (error) {		/*		 * XXX Can't happen -- open() would have errored out		 * or faked one up.		 */		printf("match_bootdisk: can't get label for dev %s (%d)/n",		    dv->dv_xname, error);		goto closeout;	}	/* Compare with our data. */	if (label.d_type == bid->label.type &&	    label.d_checksum == bid->label.checksum &&	    strncmp(label.d_packname, bid->label.packname, 16) == 0)	    	found = 1;closeout:	VOP_CLOSE(tmpvn, FREAD, NOCRED);	vput(tmpvn);	return (found);}

/* * Rename system call. * 	rename("foo", "bar"); * is essentially *	unlink("bar"); *	link("foo", "bar"); *	unlink("foo"); * but ``atomically''.  Can't do full commit without saving state in the * inode on disk which isn't feasible at this time.  Best we can do is * always guarantee the target exists. * * Basic algorithm is: * * 1) Bump link count on source while we're linking it to the *    target.  This also ensure the inode won't be deleted out *    from underneath us while we work (it may be truncated by *    a concurrent `trunc' or `open' for creation). * 2) Link source to destination.  If destination already exists, *    delete it first. * 3) Unlink source reference to inode if still around. If a *    directory was moved and the parent of the destination *    is different from the source, patch the ".." entry in the *    directory. */intext2fs_rename(void *v){	struct vop_rename_args  *ap = v;	struct vnode *tvp = ap->a_tvp;	struct vnode *tdvp = ap->a_tdvp;	struct vnode *fvp = ap->a_fvp;	struct vnode *fdvp = ap->a_fdvp;	struct componentname *tcnp = ap->a_tcnp;	struct componentname *fcnp = ap->a_fcnp;	struct inode *ip, *xp, *dp;	struct proc *p = fcnp->cn_proc;	struct ext2fs_dirtemplate dirbuf;	/* struct timespec ts; */	int doingdirectory = 0, oldparent = 0, newparent = 0;	int error = 0;	u_char namlen;#ifdef DIAGNOSTIC	if ((tcnp->cn_flags & HASBUF) == 0 ||	    (fcnp->cn_flags & HASBUF) == 0)		panic("ext2fs_rename: no name");#endif	/*	 * Check for cross-device rename.	 */	if ((fvp->v_mount != tdvp->v_mount) ||	    (tvp && (fvp->v_mount != tvp->v_mount))) {		error = EXDEV;abortit:		VOP_ABORTOP(tdvp, tcnp); /* XXX, why not in NFS? */		if (tdvp == tvp)			vrele(tdvp);		else			vput(tdvp);		if (tvp)			vput(tvp);		VOP_ABORTOP(fdvp, fcnp); /* XXX, why not in NFS? */		vrele(fdvp);		vrele(fvp);		return (error);	}	/*	 * Check if just deleting a link name.	 */	if (tvp && ((VTOI(tvp)->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||	    (VTOI(tdvp)->i_e2fs_flags & EXT2_APPEND))) {		error = EPERM;		goto abortit;	}	if (fvp == tvp) {		if (fvp->v_type == VDIR) {			error = EINVAL;			goto abortit;		}		/* Release destination completely. */		VOP_ABORTOP(tdvp, tcnp);		vput(tdvp);		vput(tvp);		/* Delete source. */		vrele(fdvp);		vrele(fvp);		fcnp->cn_flags &= ~MODMASK;		fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;		if ((fcnp->cn_flags & SAVESTART) == 0)			panic("ext2fs_rename: lost from startdir");		fcnp->cn_nameiop = DELETE;		(void) vfs_relookup(fdvp, &fvp, fcnp);		return (VOP_REMOVE(fdvp, fvp, fcnp));	}	if ((error = vn_lock(fvp, LK_EXCLUSIVE, p)) != 0)		goto abortit;	dp = VTOI(fdvp);//.........这里部分代码省略.........

/* * s5fs_rmdir: * s5fs_rmdir removes the directory called name from dir. the directory * to be removed must be empty (except for . and .. of course). * param *parent: the pointer to the parent dir of the name specified * param *name: name string * param namelen: the length of the name string * return: 0 on success; negative numbers on a variety of errors */static ints5fs_rmdir(vnode_t *parent, const char *name, size_t namelen){    dbg(DBG_S5FS, "{/n");        KASSERT(parent != NULL);    KASSERT(name != NULL);    KASSERT(namelen <= NAME_LEN - 1);    KASSERT((uint32_t)parent->vn_len == VNODE_TO_S5INODE(parent)->s5_size);        kmutex_lock(&parent->vn_mutex);        int inode_number = 0;    if ((inode_number = s5_find_dirent(parent, name, namelen)) < 0)    {        kmutex_unlock(&parent->vn_mutex);        /* Need vput? */        return inode_number;    }        /* May block here */    vnode_t* vn = vget(parent->vn_fs, inode_number);    KASSERT(vn != NULL);        if (!S_ISDIR(vn->vn_mode))    {        /* May block here */        vput(vn);        kmutex_unlock(&parent->vn_mutex);        return -ENOTDIR;    }        /* Check empty */    if (VNODE_TO_S5INODE(vn)->s5_size > sizeof(dirent_t)*2)    {        vput(vn);        kmutex_unlock(&parent->vn_mutex);        return -ENOTEMPTY;    }        int ret;    if ((ret = s5_remove_dirent(parent, name, namelen)) < 0)    {        /* May block here */        vput(vn);        kmutex_unlock(&parent->vn_mutex);        return ret;    }    /* Decrease the linkcount because .. is removed */    s5_inode_t* parent_inode = VNODE_TO_S5INODE(parent);    parent_inode->s5_linkcount--;    s5_dirty_inode(VNODE_TO_S5FS(parent), parent_inode);        /* May block here */    vput(vn);    kmutex_unlock(&parent->vn_mutex);        dbg(DBG_S5FS, "}/n");        return ret;}