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

static voidvfs_mountroot_wait(void){	struct root_hold_token *h;	struct timeval lastfail;	int curfail;	curfail = 0;	while (1) {		DROP_GIANT();		g_waitidle();		PICKUP_GIANT();		mtx_lock(&mountlist_mtx);		if (LIST_EMPTY(&root_holds)) {			mtx_unlock(&mountlist_mtx);			break;		}		if (ppsratecheck(&lastfail, &curfail, 1)) {			printf("Root mount waiting for:");			LIST_FOREACH(h, &root_holds, list)				printf(" %s", h->who);			printf("/n");		}		msleep(&root_holds, &mountlist_mtx, PZERO | PDROP, "roothold",		    hz);	}}

voiduio_yield(void){	struct thread *td;	td = curthread;	DROP_GIANT();#ifndef __rtems__	thread_lock(td);	sched_prio(td, td->td_user_pri);	mi_switch(SW_INVOL | SWT_RELINQUISH, NULL);	thread_unlock(td);#else /* __rtems__ */	rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);#endif /* __rtems__ */	PICKUP_GIANT();}

static intudf_unmount(struct mount *mp, int mntflags){	struct udf_mnt *udfmp;	int error, flags = 0;	udfmp = VFSTOUDFFS(mp);	if (mntflags & MNT_FORCE)		flags |= FORCECLOSE;	if ((error = vflush(mp, 0, flags, curthread)))		return (error);	if (udfmp->im_flags & UDFMNT_KICONV && udf_iconv) {		if (udfmp->im_d2l)			udf_iconv->close(udfmp->im_d2l);#if 0		if (udfmp->im_l2d)			udf_iconv->close(udfmp->im_l2d);#endif	}	DROP_GIANT();	g_topology_lock();	g_vfs_close(udfmp->im_cp);	g_topology_unlock();	PICKUP_GIANT();	vrele(udfmp->im_devvp);	dev_rel(udfmp->im_dev);	if (udfmp->s_table != NULL)		free(udfmp->s_table, M_UDFMOUNT);	free(udfmp, M_UDFMOUNT);	mp->mnt_data = NULL;	MNT_ILOCK(mp);	mp->mnt_flag &= ~MNT_LOCAL;	MNT_IUNLOCK(mp);	return (0);}

static intg_mbr_ioctl(struct g_provider *pp, u_long cmd, void *data, int fflag, struct thread *td){	struct g_geom *gp;	struct g_mbr_softc *ms;	struct g_slicer *gsp;	struct g_consumer *cp;	int error, opened;	gp = pp->geom;	gsp = gp->softc;	ms = gsp->softc;	opened = 0;	error = 0;	switch(cmd) {	case DIOCSMBR: {		if (!(fflag & FWRITE))			return (EPERM);		DROP_GIANT();		g_topology_lock();		cp = LIST_FIRST(&gp->consumer);		if (cp->acw == 0) {			error = g_access(cp, 0, 1, 0);			if (error == 0)				opened = 1;		}		if (!error)			error = g_mbr_modify(gp, ms, data, 512);		if (!error)			error = g_write_data(cp, 0, data, 512);		if (opened)			g_access(cp, 0, -1 , 0);		g_topology_unlock();		PICKUP_GIANT();		return(error);	}	default:		return (ENOIOCTL);	}}

static intudf_mountfs(struct vnode *devvp, struct mount *mp){	struct buf *bp = NULL;	struct cdev *dev;	struct anchor_vdp avdp;	struct udf_mnt *udfmp = NULL;	struct part_desc *pd;	struct logvol_desc *lvd;	struct fileset_desc *fsd;	struct file_entry *root_fentry;	uint32_t sector, size, mvds_start, mvds_end;	uint32_t logical_secsize;	uint32_t fsd_offset = 0;	uint16_t part_num = 0, fsd_part = 0;	int error = EINVAL;	int logvol_found = 0, part_found = 0, fsd_found = 0;	int bsize;	struct g_consumer *cp;	struct bufobj *bo;	dev = devvp->v_rdev;	dev_ref(dev);	DROP_GIANT();	g_topology_lock();	error = g_vfs_open(devvp, &cp, "udf", 0);	g_topology_unlock();	PICKUP_GIANT();	VOP_UNLOCK(devvp, 0);	if (error)		goto bail;	bo = &devvp->v_bufobj;	if (devvp->v_rdev->si_iosize_max != 0)		mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;	if (mp->mnt_iosize_max > MAXPHYS)		mp->mnt_iosize_max = MAXPHYS;	/* XXX: should be M_WAITOK */	udfmp = malloc(sizeof(struct udf_mnt), M_UDFMOUNT,	    M_NOWAIT | M_ZERO);	if (udfmp == NULL) {		printf("Cannot allocate UDF mount struct/n");		error = ENOMEM;		goto bail;	}	mp->mnt_data = udfmp;	mp->mnt_stat.f_fsid.val[0] = dev2udev(devvp->v_rdev);	mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;	MNT_ILOCK(mp);	mp->mnt_flag |= MNT_LOCAL;	mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_EXTENDED_SHARED;	MNT_IUNLOCK(mp);	udfmp->im_mountp = mp;	udfmp->im_dev = dev;	udfmp->im_devvp = devvp;	udfmp->im_d2l = NULL;	udfmp->im_cp = cp;	udfmp->im_bo = bo;#if 0	udfmp->im_l2d = NULL;#endif	/*	 * The UDF specification defines a logical sectorsize of 2048	 * for DVD media.	 */	logical_secsize = 2048;	if (((logical_secsize % cp->provider->sectorsize) != 0) ||	    (logical_secsize < cp->provider->sectorsize)) {		error = EINVAL;		goto bail;	}	bsize = cp->provider->sectorsize;	/* 	 * Get the Anchor Volume Descriptor Pointer from sector 256.	 * XXX Should also check sector n - 256, n, and 512.	 */	sector = 256;	if ((error = bread(devvp, sector * btodb(logical_secsize), bsize,			   NOCRED, &bp)) != 0)		goto bail;	if ((error = udf_checktag((struct desc_tag *)bp->b_data, TAGID_ANCHOR)))		goto bail;	bcopy(bp->b_data, &avdp, sizeof(struct anchor_vdp));	brelse(bp);	bp = NULL;	/*	 * Extract the Partition Descriptor and Logical Volume Descriptor	 * from the Volume Descriptor Sequence.	 * XXX Should we care about the partition type right now?	 * XXX What about multiple partitions?	 *///.........这里部分代码省略.........

/* * 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);}

static intmountmsdosfs(struct vnode *devvp, struct mount *mp){	struct msdosfsmount *pmp;	struct buf *bp;	struct cdev *dev;	union bootsector *bsp;	struct byte_bpb33 *b33;	struct byte_bpb50 *b50;	struct byte_bpb710 *b710;	u_int8_t SecPerClust;	u_long clusters;	int ronly, error;	struct g_consumer *cp;	struct bufobj *bo;	bp = NULL;		/* This and pmp both used in error_exit. */	pmp = NULL;	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;	dev = devvp->v_rdev;	dev_ref(dev);	DROP_GIANT();	g_topology_lock();	error = g_vfs_open(devvp, &cp, "msdosfs", ronly ? 0 : 1);	g_topology_unlock();	PICKUP_GIANT();	VOP_UNLOCK(devvp, 0);	if (error)		goto error_exit;	bo = &devvp->v_bufobj;	/*	 * Read the boot sector of the filesystem, and then check the	 * boot signature.  If not a dos boot sector then error out.	 *	 * NOTE: 8192 is a magic size that works for ffs.	 */	error = bread(devvp, 0, 8192, NOCRED, &bp);	if (error)		goto error_exit;	bp->b_flags |= B_AGE;	bsp = (union bootsector *)bp->b_data;	b33 = (struct byte_bpb33 *)bsp->bs33.bsBPB;	b50 = (struct byte_bpb50 *)bsp->bs50.bsBPB;	b710 = (struct byte_bpb710 *)bsp->bs710.bsBPB;#ifndef MSDOSFS_NOCHECKSIG	if (bsp->bs50.bsBootSectSig0 != BOOTSIG0	    || bsp->bs50.bsBootSectSig1 != BOOTSIG1) {		error = EINVAL;		goto error_exit;	}#endif	pmp = malloc(sizeof *pmp, M_MSDOSFSMNT, M_WAITOK | M_ZERO);	pmp->pm_mountp = mp;	pmp->pm_cp = cp;	pmp->pm_bo = bo;	lockinit(&pmp->pm_fatlock, 0, msdosfs_lock_msg, 0, 0);	/*	 * Initialize ownerships and permissions, since nothing else will	 * initialize them iff we are mounting root.	 */	pmp->pm_uid = UID_ROOT;	pmp->pm_gid = GID_WHEEL;	pmp->pm_mask = pmp->pm_dirmask = S_IXUSR | S_IXGRP | S_IXOTH |	    S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR;	/*	 * Experimental support for large MS-DOS filesystems.	 * WARNING: This uses at least 32 bytes of kernel memory (which is not	 * reclaimed until the FS is unmounted) for each file on disk to map	 * between the 32-bit inode numbers used by VFS and the 64-bit	 * pseudo-inode numbers used internally by msdosfs. This is only	 * safe to use in certain controlled situations (e.g. read-only FS	 * with less than 1 million files).	 * Since the mappings do not persist across unmounts (or reboots), these	 * filesystems are not suitable for exporting through NFS, or any other	 * application that requires fixed inode numbers.	 */	vfs_flagopt(mp->mnt_optnew, "large", &pmp->pm_flags, MSDOSFS_LARGEFS);	/*	 * Compute several useful quantities from the bpb in the	 * bootsector.  Copy in the dos 5 variant of the bpb then fix up	 * the fields that are different between dos 5 and dos 3.3.	 */	SecPerClust = b50->bpbSecPerClust;	pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec);	if (pmp->pm_BytesPerSec < DEV_BSIZE) {		error = EINVAL;		goto error_exit;	}	pmp->pm_ResSectors = getushort(b50->bpbResSectors);	pmp->pm_FATs = b50->bpbFATs;	pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts);//.........这里部分代码省略.........

/* * mp - path - addr in user space of mount point (ie /usr or whatever) * data - addr in user space of mount params including the name of the block * special file to treat as a filesystem. */static intmsdosfs_mount(struct mount *mp){	struct vnode *devvp;	  /* vnode for blk device to mount */	struct thread *td;	/* msdosfs specific mount control block */	struct msdosfsmount *pmp = NULL;	struct nameidata ndp;	int error, flags;	accmode_t accmode;	char *from;	td = curthread;	if (vfs_filteropt(mp->mnt_optnew, msdosfs_opts))		return (EINVAL);	/*	 * 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) {		pmp = VFSTOMSDOSFS(mp);		if (vfs_flagopt(mp->mnt_optnew, "export", NULL, 0)) {			/*			 * Forbid export requests if filesystem has			 * MSDOSFS_LARGEFS flag set.			 */			if ((pmp->pm_flags & MSDOSFS_LARGEFS) != 0) {				vfs_mount_error(mp,				    "MSDOSFS_LARGEFS flag set, cannot export");				return (EOPNOTSUPP);			}		}		if (!(pmp->pm_flags & MSDOSFSMNT_RONLY) &&		    vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {			error = VFS_SYNC(mp, MNT_WAIT);			if (error)				return (error);			flags = WRITECLOSE;			if (mp->mnt_flag & MNT_FORCE)				flags |= FORCECLOSE;			error = vflush(mp, 0, flags, td);			if (error)				return (error);			/*			 * Now the volume is clean.  Mark it so while the			 * device is still rw.			 */			error = markvoldirty(pmp, 0);			if (error) {				(void)markvoldirty(pmp, 1);				return (error);			}			/* Downgrade the device from rw to ro. */			DROP_GIANT();			g_topology_lock();			error = g_access(pmp->pm_cp, 0, -1, 0);			g_topology_unlock();			PICKUP_GIANT();			if (error) {				(void)markvoldirty(pmp, 1);				return (error);			}			/*			 * Backing out after an error was painful in the			 * above.  Now we are committed to succeeding.			 */			pmp->pm_fmod = 0;			pmp->pm_flags |= MSDOSFSMNT_RONLY;			MNT_ILOCK(mp);			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);//.........这里部分代码省略.........

/*- * This start routine is only called for non-trivial requests, all the * trivial ones are handled autonomously by the slice code. * For requests we handle here, we must call the g_io_deliver() on the * bio, and return non-zero to indicate to the slice code that we did so. * This code executes in the "DOWN" I/O path, this means: *    * No sleeping. *    * Don't grab the topology lock. *    * Don't call biowait, g_getattr(), g_setattr() or g_read_data() */static intg_bsd_ioctl(struct g_provider *pp, u_long cmd, void *data, int fflag, struct thread *td){	struct g_geom *gp;	struct g_bsd_softc *ms;	struct g_slicer *gsp;	u_char *label;	int error;	gp = pp->geom;	gsp = gp->softc;	ms = gsp->softc;	switch(cmd) {	case DIOCGDINFO:		/* Return a copy of the disklabel to userland. */		bsd_disklabel_le_dec(ms->label, data, MAXPARTITIONS);		return(0);	case DIOCBSDBB: {		struct g_consumer *cp;		u_char *buf;		void *p;		int error, i;		uint64_t sum;		if (!(fflag & FWRITE))			return (EPERM);		/* The disklabel to set is the ioctl argument. */		buf = g_malloc(BBSIZE, M_WAITOK);		p = *(void **)data;		error = copyin(p, buf, BBSIZE);		if (!error) {			/* XXX: Rude, but supposedly safe */			DROP_GIANT();			g_topology_lock();			/* Validate and modify our slice instance to match. */			error = g_bsd_modify(gp, buf + ms->labeloffset);			if (!error) {				cp = LIST_FIRST(&gp->consumer);				if (ms->labeloffset == ALPHA_LABEL_OFFSET) {					sum = 0;					for (i = 0; i < 63; i++)						sum += le64dec(buf + i * 8);					le64enc(buf + 504, sum);				}				error = g_write_data(cp, 0, buf, BBSIZE);			}			g_topology_unlock();			PICKUP_GIANT();		}		g_free(buf);		return (error);	}	case DIOCSDINFO:	case DIOCWDINFO: {		if (!(fflag & FWRITE))			return (EPERM);		label = g_malloc(LABELSIZE, M_WAITOK);		/* The disklabel to set is the ioctl argument. */		bsd_disklabel_le_enc(label, data);		DROP_GIANT();		g_topology_lock();		/* Validate and modify our slice instance to match. */		error = g_bsd_modify(gp, label);		if (error == 0 && cmd == DIOCWDINFO)			error = g_bsd_writelabel(gp, NULL);		g_topology_unlock();		PICKUP_GIANT();		g_free(label);		return(error);	}	default:		return (ENOIOCTL);	}}

static intparse_dir_md(char **conf){	struct stat sb;	struct thread *td;	struct md_ioctl *mdio;	char *path, *tok;	int error, fd, len;	td = curthread;	error = parse_token(conf, &tok);	if (error)		return (error);	len = strlen(tok);	mdio = malloc(sizeof(*mdio) + len + 1, M_TEMP, M_WAITOK | M_ZERO);	path = (void *)(mdio + 1);	bcopy(tok, path, len);	free(tok, M_TEMP);	/* Get file status. */	error = kern_stat(td, path, UIO_SYSSPACE, &sb);	if (error)		goto out;	/* Open /dev/mdctl so that we can attach/detach. */	error = kern_open(td, "/dev/" MDCTL_NAME, UIO_SYSSPACE, O_RDWR, 0);	if (error)		goto out;	fd = td->td_retval[0];	mdio->md_version = MDIOVERSION;	mdio->md_type = MD_VNODE;	if (root_mount_mddev != -1) {		mdio->md_unit = root_mount_mddev;		DROP_GIANT();		error = kern_ioctl(td, fd, MDIOCDETACH, (void *)mdio);		PICKUP_GIANT();		/* Ignore errors. We don't care. */		root_mount_mddev = -1;	}	mdio->md_file = (void *)(mdio + 1);	mdio->md_options = MD_AUTOUNIT | MD_READONLY;	mdio->md_mediasize = sb.st_size;	mdio->md_unit = 0;	DROP_GIANT();	error = kern_ioctl(td, fd, MDIOCATTACH, (void *)mdio);	PICKUP_GIANT();	if (error)		goto out;	if (mdio->md_unit > 9) {		printf("rootmount: too many md units/n");		mdio->md_file = NULL;		mdio->md_options = 0;		mdio->md_mediasize = 0;		DROP_GIANT();		error = kern_ioctl(td, fd, MDIOCDETACH, (void *)mdio);		PICKUP_GIANT();		/* Ignore errors. We don't care. */		error = ERANGE;		goto out;	}	root_mount_mddev = mdio->md_unit;	printf(MD_NAME "%u attached to %s/n", root_mount_mddev, mdio->md_file);	error = kern_close(td, fd); out:	free(mdio, M_TEMP);	return (error);}

/* * Shutdown the system cleanly to prepare for reboot, halt, or power off. */voidkern_reboot(int howto){	static int first_buf_printf = 1;#if defined(SMP)	/*	 * Bind us to CPU 0 so that all shutdown code runs there.  Some	 * systems don't shutdown properly (i.e., ACPI power off) if we	 * run on another processor.	 */	if (!SCHEDULER_STOPPED()) {		thread_lock(curthread);		sched_bind(curthread, 0);		thread_unlock(curthread);		KASSERT(PCPU_GET(cpuid) == 0, ("boot: not running on cpu 0"));	}#endif	/* We're in the process of rebooting. */	rebooting = 1;	/* collect extra flags that shutdown_nice might have set */	howto |= shutdown_howto;	/* We are out of the debugger now. */	kdb_active = 0;	/*	 * Do any callouts that should be done BEFORE syncing the filesystems.	 */	EVENTHANDLER_INVOKE(shutdown_pre_sync, howto);	/* 	 * Now sync filesystems	 */	if (!cold && (howto & RB_NOSYNC) == 0 && waittime < 0) {		register struct buf *bp;		int iter, nbusy, pbusy;#ifndef PREEMPTION		int subiter;#endif		waittime = 0;		wdog_kern_pat(WD_LASTVAL);		sys_sync(curthread, NULL);		/*		 * With soft updates, some buffers that are		 * written will be remarked as dirty until other		 * buffers are written.		 */		for (iter = pbusy = 0; iter < 20; iter++) {			nbusy = 0;			for (bp = &buf[nbuf]; --bp >= buf; )				if (isbufbusy(bp))					nbusy++;			if (nbusy == 0) {				if (first_buf_printf)					printf("All buffers synced.");				break;			}			if (first_buf_printf) {				printf("Syncing disks, buffers remaining... ");				first_buf_printf = 0;			}			printf("%d ", nbusy);			if (nbusy < pbusy)				iter = 0;			pbusy = nbusy;			wdog_kern_pat(WD_LASTVAL);			sys_sync(curthread, NULL);#ifdef PREEMPTION			/*			 * Drop Giant and spin for a while to allow			 * interrupt threads to run.			 */			DROP_GIANT();			DELAY(50000 * iter);			PICKUP_GIANT();#else			/*			 * Drop Giant and context switch several times to			 * allow interrupt threads to run.			 */			DROP_GIANT();			for (subiter = 0; subiter < 50 * iter; subiter++) {				thread_lock(curthread);				mi_switch(SW_VOL, NULL);				thread_unlock(curthread);				DELAY(1000);			}			PICKUP_GIANT();#endif		}//.........这里部分代码省略.........

/*ARGSUSED*/static intzfs_mount(vfs_t *vfsp){	kthread_t	*td = curthread;	vnode_t		*mvp = vfsp->mnt_vnodecovered;	cred_t		*cr = td->td_ucred;	char		*osname;	int		error = 0;	int		canwrite;	if (vfs_getopt(vfsp->mnt_optnew, "from", (void **)&osname, NULL))		return (EINVAL);	/*	 * If full-owner-access is enabled and delegated administration is	 * turned on, we must set nosuid.	 */	if (zfs_super_owner &&	    dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr) != ECANCELED) {		secpolicy_fs_mount_clearopts(cr, vfsp);	}	/*	 * Check for mount privilege?	 *	 * If we don't have privilege then see if	 * we have local permission to allow it	 */	error = secpolicy_fs_mount(cr, mvp, vfsp);	if (error) {		error = dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr);		if (error != 0)			goto out;		if (!(vfsp->vfs_flag & MS_REMOUNT)) {			vattr_t		vattr;			/*			 * Make sure user is the owner of the mount point			 * or has sufficient privileges.			 */			vattr.va_mask = AT_UID;			vn_lock(mvp, LK_SHARED | LK_RETRY);			if (error = VOP_GETATTR(mvp, &vattr, cr)) {				VOP_UNLOCK(mvp, 0);				goto out;			}#if 0 /* CHECK THIS! Is probably needed for zfs_suser. */			if (secpolicy_vnode_owner(mvp, cr, vattr.va_uid) != 0 &&			    VOP_ACCESS(mvp, VWRITE, cr, td) != 0) {				error = EPERM;				goto out;			}#else			if (error = secpolicy_vnode_owner(mvp, cr, vattr.va_uid)) {				VOP_UNLOCK(mvp, 0);				goto out;			}			if (error = VOP_ACCESS(mvp, VWRITE, cr, td)) {				VOP_UNLOCK(mvp, 0);				goto out;			}			VOP_UNLOCK(mvp, 0);#endif		}		secpolicy_fs_mount_clearopts(cr, vfsp);	}	/*	 * Refuse to mount a filesystem if we are in a local zone and the	 * dataset is not visible.	 */	if (!INGLOBALZONE(curthread) &&	    (!zone_dataset_visible(osname, &canwrite) || !canwrite)) {		error = EPERM;		goto out;	}	/*	 * When doing a remount, we simply refresh our temporary properties	 * according to those options set in the current VFS options.	 */	if (vfsp->vfs_flag & MS_REMOUNT) {		/* refresh mount options */		zfs_unregister_callbacks(vfsp->vfs_data);		error = zfs_register_callbacks(vfsp);		goto out;	}	DROP_GIANT();	error = zfs_domount(vfsp, osname);	PICKUP_GIANT();out:	return (error);//.........这里部分代码省略.........