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

voidicl_listen_free(struct icl_listen *il){	struct icl_listen_sock *ils;	sx_xlock(&il->il_lock);	while (!TAILQ_EMPTY(&il->il_sockets)) {		ils = TAILQ_FIRST(&il->il_sockets);		while (ils->ils_running) {			ICL_DEBUG("waiting for accept thread to terminate");			sx_xunlock(&il->il_lock);			ils->ils_disconnecting = true;			wakeup(&ils->ils_socket->so_timeo);			pause("icl_unlisten", 1 * hz);			sx_xlock(&il->il_lock);		}			TAILQ_REMOVE(&il->il_sockets, ils, ils_next);		soclose(ils->ils_socket);		free(ils, M_ICL_PROXY);	}	sx_xunlock(&il->il_lock);	free(il, M_ICL_PROXY);}

static intaxgbe_media_change(struct ifnet *ifp){	struct axgbe_softc *sc;	int cur_media;	sc = ifp->if_softc;	sx_xlock(&sc->prv.an_mutex);	cur_media = sc->media.ifm_cur->ifm_media;	switch (IFM_SUBTYPE(cur_media)) {	case IFM_10G_KR:		sc->prv.phy.speed = SPEED_10000;		sc->prv.phy.autoneg = AUTONEG_DISABLE;		break;	case IFM_2500_KX:		sc->prv.phy.speed = SPEED_2500;		sc->prv.phy.autoneg = AUTONEG_DISABLE;		break;	case IFM_1000_KX:		sc->prv.phy.speed = SPEED_1000;		sc->prv.phy.autoneg = AUTONEG_DISABLE;		break;	case IFM_AUTO:		sc->prv.phy.autoneg = AUTONEG_ENABLE;		break;	}	sx_xunlock(&sc->prv.an_mutex);	return (-sc->prv.phy_if.phy_config_aneg(&sc->prv));}

static intdevfs_unmount(struct mount *mp, int mntflags){	int error;	int flags = 0;	struct devfs_mount *fmp;	int hold;	u_int idx;	fmp = VFSTODEVFS(mp);	KASSERT(fmp->dm_mount != NULL,		("devfs_unmount unmounted devfs_mount"));	/* There is 1 extra root vnode reference from devfs_mount(). */	error = vflush(mp, 1, flags, curthread);	if (error)		return (error);	sx_xlock(&fmp->dm_lock);	devfs_cleanup(fmp);	devfs_rules_cleanup(fmp);	fmp->dm_mount = NULL;	hold = --fmp->dm_holdcnt;	mp->mnt_data = NULL;	idx = fmp->dm_idx;	sx_xunlock(&fmp->dm_lock);	free_unr(devfs_unr, idx);	if (hold == 0)		devfs_unmount_final(fmp);	return 0;}

static intsysctl_kern_randompid(SYSCTL_HANDLER_ARGS){	int error, pid;	error = sysctl_wire_old_buffer(req, sizeof(int));	if (error != 0)		return(error);	sx_xlock(&allproc_lock);	pid = randompid;	error = sysctl_handle_int(oidp, &pid, 0, req);	if (error == 0 && req->newptr != NULL) {		if (pid == 0)			randompid = 0;		else if (pid == 1)			/* generate a random PID modulus between 100 and 1123 */			randompid = 100 + arc4random() % 1024;		else if (pid < 0 || pid > pid_max - 100)			/* out of range */			randompid = pid_max - 100;		else if (pid < 100)	 			/* Make it reasonable */			randompid = 100;		else			randompid = pid;	}	sx_xunlock(&allproc_lock);	return (error);}

int intel_sprite_get_colorkey(struct drm_device *dev, void *data,			      struct drm_file *file_priv){	struct drm_intel_sprite_colorkey *get = data;	struct drm_mode_object *obj;	struct drm_plane *plane;	struct intel_plane *intel_plane;	int ret = 0;	if (!drm_core_check_feature(dev, DRIVER_MODESET))		return -ENODEV;	sx_xlock(&dev->mode_config.mutex);	obj = drm_mode_object_find(dev, get->plane_id, DRM_MODE_OBJECT_PLANE);	if (!obj) {		ret = -EINVAL;		goto out_unlock;	}	plane = obj_to_plane(obj);	intel_plane = to_intel_plane(plane);	intel_plane->get_colorkey(plane, get);out_unlock:	sx_xunlock(&dev->mode_config.mutex);	return ret;}

static inttracer_ioctl(struct ifnet *ifp, unsigned long cmd, caddr_t data){	int rc = 0;	struct adapter *sc;	struct ifreq *ifr = (struct ifreq *)data;	switch (cmd) {	case SIOCSIFMTU:	case SIOCSIFFLAGS:	case SIOCADDMULTI:	case SIOCDELMULTI:	case SIOCSIFCAP:		break;	case SIOCSIFMEDIA:	case SIOCGIFMEDIA:		sx_xlock(&t4_trace_lock);		sc = ifp->if_softc;		if (sc == NULL)			rc = EIO;		else			rc = ifmedia_ioctl(ifp, ifr, &sc->media, cmd);		sx_xunlock(&t4_trace_lock);		break;	default:		rc = ether_ioctl(ifp, cmd, data);	}	return (rc);}

intig4iic_detach(ig4iic_softc_t *sc){	int error;	if (device_is_attached(sc->dev)) {		error = bus_generic_detach(sc->dev);		if (error)			return (error);	}	if (sc->smb)		device_delete_child(sc->dev, sc->smb);	if (sc->intr_handle)		bus_teardown_intr(sc->dev, sc->intr_res, sc->intr_handle);	sx_xlock(&sc->call_lock);	mtx_lock(&sc->io_lock);	sc->smb = NULL;	sc->intr_handle = NULL;	reg_write(sc, IG4_REG_INTR_MASK, 0);	reg_read(sc, IG4_REG_CLR_INTR);	set_controller(sc, 0);	mtx_unlock(&sc->io_lock);	sx_xunlock(&sc->call_lock);	return (0);}

static voidsfxge_ev_stat_update(struct sfxge_softc *sc){	struct sfxge_evq *evq;	unsigned int index;	clock_t now;	sx_xlock(&sc->softc_lock);	if (sc->evq[0]->init_state != SFXGE_EVQ_STARTED)		goto out;	now = ticks;	if (now - sc->ev_stats_update_time < hz)		goto out;	sc->ev_stats_update_time = now;	/* Add event counts from each event queue in turn */	for (index = 0; index < sc->intr.n_alloc; index++) {		evq = sc->evq[index];		mtx_lock(&evq->lock);		efx_ev_qstats_update(evq->common, sc->ev_stats);		mtx_unlock(&evq->lock);	}out:	sx_xunlock(&sc->softc_lock);}

voidkproc_exit(int ecode){	struct thread *td;	struct proc *p;	td = curthread;	p = td->td_proc;	/*	 * Reparent curthread from proc0 to init so that the zombie	 * is harvested.	 */	sx_xlock(&proctree_lock);	PROC_LOCK(p);	proc_reparent(p, initproc);	PROC_UNLOCK(p);	sx_xunlock(&proctree_lock);	/*	 * Wakeup anyone waiting for us to exit.	 */	wakeup(p);	/* Buh-bye! */	exit1(td, ecode, 0);}

static voidsfxge_reset(void *arg, int npending){	struct sfxge_softc *sc;	int rc;	(void)npending;	sc = (struct sfxge_softc *)arg;	sx_xlock(&sc->softc_lock);	if (sc->init_state != SFXGE_STARTED)		goto done;	sfxge_stop(sc);	efx_nic_reset(sc->enp);	if ((rc = sfxge_start(sc)) != 0)		device_printf(sc->dev,			      "reset failed (%d); interface is now stopped/n",			      rc);done:	sx_xunlock(&sc->softc_lock);}

static intmfi_pci_detach(device_t dev){	struct mfi_softc *sc;	int error, devcount, i;	device_t *devlist;	sc = device_get_softc(dev);	sx_xlock(&sc->mfi_config_lock);	mtx_lock(&sc->mfi_io_lock);	if ((sc->mfi_flags & MFI_FLAGS_OPEN) != 0) {		mtx_unlock(&sc->mfi_io_lock);		sx_xunlock(&sc->mfi_config_lock);		return (EBUSY);	}	sc->mfi_detaching = 1;	mtx_unlock(&sc->mfi_io_lock);	if ((error = device_get_children(sc->mfi_dev, &devlist, &devcount)) != 0) {		sx_xunlock(&sc->mfi_config_lock);		return error;	}	for (i = 0; i < devcount; i++)		device_delete_child(sc->mfi_dev, devlist[i]);	free(devlist, M_TEMP);	sx_xunlock(&sc->mfi_config_lock);	EVENTHANDLER_DEREGISTER(shutdown_final, sc->mfi_eh);	mfi_shutdown(sc);	mfi_free(sc);	mfi_pci_free(sc);	return (0);}

/* * Close out the log. */static voidfilemon_close_log(struct filemon *filemon){	struct file *fp;	struct timeval now;	size_t len;	sx_assert(&filemon->lock, SA_XLOCKED);	if (filemon->fp == NULL)		return;	getmicrotime(&now);	len = snprintf(filemon->msgbufr,	    sizeof(filemon->msgbufr),	    "# Stop %ju.%06ju/n# Bye bye/n",	    (uintmax_t)now.tv_sec, (uintmax_t)now.tv_usec);	filemon_output(filemon, filemon->msgbufr, len);	fp = filemon->fp;	filemon->fp = NULL;	sx_xunlock(&filemon->lock);	fdrop(fp, curthread);	sx_xlock(&filemon->lock);}

int intel_sprite_set_colorkey(struct drm_device *dev, void *data,			      struct drm_file *file_priv){	struct drm_intel_sprite_colorkey *set = data;	struct drm_mode_object *obj;	struct drm_plane *plane;	struct intel_plane *intel_plane;	int ret = 0;	if (!drm_core_check_feature(dev, DRIVER_MODESET))		return -ENODEV;	/* Make sure we don't try to enable both src & dest simultaneously */	if ((set->flags & (I915_SET_COLORKEY_DESTINATION | I915_SET_COLORKEY_SOURCE)) == (I915_SET_COLORKEY_DESTINATION | I915_SET_COLORKEY_SOURCE))		return -EINVAL;	sx_xlock(&dev->mode_config.mutex);		obj = drm_mode_object_find(dev, set->plane_id, DRM_MODE_OBJECT_PLANE);	if (!obj) {		ret = -EINVAL;		goto out_unlock;	}	plane = obj_to_plane(obj);	intel_plane = to_intel_plane(plane);	ret = intel_plane->update_colorkey(plane, set);out_unlock:	sx_xunlock(&dev->mode_config.mutex);	return ret;}

static int i915_drm_thaw(struct drm_device *dev){	struct drm_i915_private *dev_priv = dev->dev_private;	int error = 0;	DRM_LOCK(dev);	if (drm_core_check_feature(dev, DRIVER_MODESET)) {		i915_gem_restore_gtt_mappings(dev);	}	i915_restore_state(dev);	intel_opregion_setup(dev);	/* KMS EnterVT equivalent */	if (drm_core_check_feature(dev, DRIVER_MODESET)) {		dev_priv->mm.suspended = 0;		error = i915_gem_init_hw(dev);		if (HAS_PCH_SPLIT(dev))			ironlake_init_pch_refclk(dev);		DRM_UNLOCK(dev);		sx_xlock(&dev->mode_config.mutex);		drm_mode_config_reset(dev);		sx_xunlock(&dev->mode_config.mutex);		drm_irq_install(dev);		sx_xlock(&dev->mode_config.mutex);		/* Resume the modeset for every activated CRTC */		drm_helper_resume_force_mode(dev);		sx_xunlock(&dev->mode_config.mutex);		if (IS_IRONLAKE_M(dev))			ironlake_enable_rc6(dev);		DRM_LOCK(dev);	}	intel_opregion_init(dev);	dev_priv->modeset_on_lid = 0;	DRM_UNLOCK(dev);	return error;}

/* * Simplified back end of syscall(), used when returning from fork() * directly into user mode.  Giant is not held on entry, and must not * be held on return.  This function is passed in to fork_exit() as the * first parameter and is called when returning to a new userland process. */voidfork_return(struct thread *td, struct trapframe *frame){	struct proc *p, *dbg;	p = td->td_proc;	if (td->td_dbgflags & TDB_STOPATFORK) {		sx_xlock(&proctree_lock);		PROC_LOCK(p);		if ((p->p_pptr->p_flag & (P_TRACED | P_FOLLOWFORK)) ==		    (P_TRACED | P_FOLLOWFORK)) {			/*			 * If debugger still wants auto-attach for the			 * parent's children, do it now.			 */			dbg = p->p_pptr->p_pptr;			p->p_flag |= P_TRACED;			p->p_oppid = p->p_pptr->p_pid;			CTR2(KTR_PTRACE,		    "fork_return: attaching to new child pid %d: oppid %d",			    p->p_pid, p->p_oppid);			proc_reparent(p, dbg);			sx_xunlock(&proctree_lock);			td->td_dbgflags |= TDB_CHILD | TDB_SCX;			ptracestop(td, SIGSTOP);			td->td_dbgflags &= ~(TDB_CHILD | TDB_SCX);		} else {			/*			 * ... otherwise clear the request.			 */			sx_xunlock(&proctree_lock);			td->td_dbgflags &= ~TDB_STOPATFORK;			cv_broadcast(&p->p_dbgwait);		}		PROC_UNLOCK(p);	} else if (p->p_flag & P_TRACED || td->td_dbgflags & TDB_BORN) { 		/*		 * This is the start of a new thread in a traced		 * process.  Report a system call exit event.		 */		PROC_LOCK(p);		td->td_dbgflags |= TDB_SCX;		_STOPEVENT(p, S_SCX, td->td_dbg_sc_code);		if ((p->p_stops & S_PT_SCX) != 0 ||		    (td->td_dbgflags & TDB_BORN) != 0)			ptracestop(td, SIGTRAP);		td->td_dbgflags &= ~(TDB_SCX | TDB_BORN);		PROC_UNLOCK(p);	}	userret(td, frame);#ifdef KTRACE	if (KTRPOINT(td, KTR_SYSRET))		ktrsysret(SYS_fork, 0, 0);#endif}

RTDECL(int)  RTSemFastMutexRequest(RTSEMFASTMUTEX hFastMtx){    PRTSEMFASTMUTEXINTERNAL pThis = hFastMtx;    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);    AssertMsgReturn(pThis->u32Magic == RTSEMFASTMUTEX_MAGIC, ("%p: u32Magic=%RX32/n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);    sx_xlock(&pThis->SxLock);    return VINF_SUCCESS;}

static bool_tsvc_vc_backchannel_reply(SVCXPRT *xprt, struct rpc_msg *msg,    struct sockaddr *addr, struct mbuf *m, uint32_t *seq){	struct ct_data *ct;	XDR xdrs;	struct mbuf *mrep;	bool_t stat = TRUE;	int error;	/*	 * Leave space for record mark.	 */	mrep = m_gethdr(M_WAITOK, MT_DATA);	mrep->m_data += sizeof(uint32_t);	xdrmbuf_create(&xdrs, mrep, XDR_ENCODE);	if (msg->rm_reply.rp_stat == MSG_ACCEPTED &&	    msg->rm_reply.rp_acpt.ar_stat == SUCCESS) {		if (!xdr_replymsg(&xdrs, msg))			stat = FALSE;		else			xdrmbuf_append(&xdrs, m);	} else {		stat = xdr_replymsg(&xdrs, msg);	}	if (stat) {		m_fixhdr(mrep);		/*		 * Prepend a record marker containing the reply length.		 */		M_PREPEND(mrep, sizeof(uint32_t), M_WAITOK);		*mtod(mrep, uint32_t *) =			htonl(0x80000000 | (mrep->m_pkthdr.len				- sizeof(uint32_t)));		sx_xlock(&xprt->xp_lock);		ct = (struct ct_data *)xprt->xp_p2;		if (ct != NULL)			error = sosend(ct->ct_socket, NULL, NULL, mrep, NULL,			    0, curthread);		else			error = EPIPE;		sx_xunlock(&xprt->xp_lock);		if (!error) {			stat = TRUE;		}	} else {		m_freem(mrep);	}	XDR_DESTROY(&xdrs);	return (stat);}

intosd_register(u_int type, osd_destructor_t destructor, osd_method_t *methods){	void *newptr;	u_int i, m;	KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));	/*	 * If no destructor is given, use default one. We need to use some	 * destructor, because NULL destructor means unused slot.	 */	if (destructor == NULL)		destructor = osd_default_destructor;	sx_xlock(&osd_module_lock[type]);	/*	 * First, we try to find unused slot.	 */	for (i = 0; i < osd_nslots[type]; i++) {		if (osd_destructors[type][i] == NULL) {			OSD_DEBUG("Unused slot found (type=%u, slot=%u).",			    type, i);			break;		}	}	/*	 * If no unused slot was found, allocate one.	 */	if (i == osd_nslots[type]) {		osd_nslots[type]++;		if (osd_nmethods[type] != 0)			osd_methods[type] = realloc(osd_methods[type],			    sizeof(osd_method_t) * osd_nslots[type] *			    osd_nmethods[type], M_OSD, M_WAITOK);		newptr = malloc(sizeof(osd_destructor_t) * osd_nslots[type],		    M_OSD, M_WAITOK);		rm_wlock(&osd_object_lock[type]);		bcopy(osd_destructors[type], newptr,		    sizeof(osd_destructor_t) * i);		free(osd_destructors[type], M_OSD);		osd_destructors[type] = newptr;		rm_wunlock(&osd_object_lock[type]);		OSD_DEBUG("New slot allocated (type=%u, slot=%u).",		    type, i + 1);	}	osd_destructors[type][i] = destructor;	if (osd_nmethods[type] != 0) {		for (m = 0; m < osd_nmethods[type]; m++)			osd_methods[type][i * osd_nmethods[type] + m] =			    methods != NULL ? methods[m] : NULL;	}	sx_xunlock(&osd_module_lock[type]);	return (i + 1);}

intshared_page_alloc(int size, int align){	int res;	sx_xlock(&shared_page_alloc_sx);	res = shared_page_alloc_locked(size, align);	sx_xunlock(&shared_page_alloc_sx);	return (res);}

static intintel_gmbus_transfer(device_t idev, struct iic_msg *msgs, uint32_t nmsgs){	struct intel_iic_softc *sc;	struct drm_i915_private *dev_priv;	u8 *buf;	int error, i, reg_offset, unit;	u32 val, loop;	u16 len;	sc = device_get_softc(idev);	dev_priv = sc->drm_dev->dev_private;	unit = device_get_unit(idev);	sx_xlock(&dev_priv->gmbus_sx);	if (sc->force_bit_dev) {		error = intel_iic_quirk_xfer(dev_priv->bbbus[unit], msgs, nmsgs);		goto out;	}	reg_offset = HAS_PCH_SPLIT(dev_priv->dev) ? PCH_GMBUS0 - GMBUS0 : 0;	I915_WRITE(GMBUS0 + reg_offset, sc->reg0);	for (i = 0; i < nmsgs; i++) {		len = msgs[i].len;		buf = msgs[i].buf;		if ((msgs[i].flags & IIC_M_RD) != 0) {			I915_WRITE(GMBUS1 + reg_offset, GMBUS_CYCLE_WAIT |			    (i + 1 == nmsgs ? GMBUS_CYCLE_STOP : 0) |			    (len << GMBUS_BYTE_COUNT_SHIFT) |			    (msgs[i].slave << GMBUS_SLAVE_ADDR_SHIFT) |			    GMBUS_SLAVE_READ | GMBUS_SW_RDY);			POSTING_READ(GMBUS2 + reg_offset);			do {				loop = 0;				if (_intel_wait_for(sc->drm_dev,				    (I915_READ(GMBUS2 + reg_offset) &					(GMBUS_SATOER | GMBUS_HW_RDY)) != 0,				    50, 1, "915gbr"))					goto timeout;				if ((I915_READ(GMBUS2 + reg_offset) &				    GMBUS_SATOER) != 0)					goto clear_err;				val = I915_READ(GMBUS3 + reg_offset);				do {					*buf++ = val & 0xff;					val >>= 8;				} while (--len != 0 && ++loop < 4);			} while (len != 0);		} else {

voidlock_sx(struct lock_object *lock, uintptr_t how){	struct sx *sx;	sx = (struct sx *)lock;	if (how)		sx_slock(sx);	else		sx_xlock(sx);}

static intfilemon_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag __unused,    struct thread *td){	int error = 0;	struct filemon *filemon;	struct proc *p;	cap_rights_t rights;	if ((error = devfs_get_cdevpriv((void **) &filemon)) != 0)		return (error);	sx_xlock(&filemon->lock);	switch (cmd) {	/* Set the output file descriptor. */	case FILEMON_SET_FD:		if (filemon->fp != NULL) {			error = EEXIST;			break;		}		error = fget_write(td, *(int *)data,		    cap_rights_init(&rights, CAP_PWRITE),		    &filemon->fp);		if (error == 0)			/* Write the file header. */			filemon_write_header(filemon);		break;	/* Set the monitored process ID. */	case FILEMON_SET_PID:		/* Invalidate any existing processes already set. */		filemon_untrack_processes(filemon);		error = pget(*((pid_t *)data),		    PGET_CANDEBUG | PGET_NOTWEXIT | PGET_NOTINEXEC, &p);		if (error == 0) {			KASSERT(p->p_filemon != filemon,			    ("%s: proc %p didn't untrack filemon %p",			    __func__, p, filemon));			error = filemon_attach_proc(filemon, p);			PROC_UNLOCK(p);		}		break;	default:		error = EINVAL;		break;	}	sx_xunlock(&filemon->lock);	return (error);}

/* Attach the filemon to the process. */static intfilemon_attach_proc(struct filemon *filemon, struct proc *p){	struct filemon *filemon2;	sx_assert(&filemon->lock, SA_XLOCKED);	PROC_LOCK_ASSERT(p, MA_OWNED);	KASSERT((p->p_flag & P_WEXIT) == 0,	    ("%s: filemon %p attaching to exiting process %p",	    __func__, filemon, p));	KASSERT((p->p_flag & P_INEXEC) == 0,	    ("%s: filemon %p attaching to execing process %p",	    __func__, filemon, p));	if (p->p_filemon == filemon)		return (0);	/*	 * Don't allow truncating other process traces.  It is	 * not really intended to trace procs other than curproc	 * anyhow.	 */	if (p->p_filemon != NULL && p != curproc)		return (EBUSY);	/*	 * Historic behavior of filemon has been to let a child initiate	 * tracing on itself and cease existing tracing.  Bmake	 * .META + .MAKE relies on this.  It is only relevant for attaching to	 * curproc.	 */	while (p->p_filemon != NULL) {		PROC_UNLOCK(p);		sx_xunlock(&filemon->lock);		while ((filemon2 = filemon_proc_get(p)) != NULL) {			/* It may have changed. */			if (p->p_filemon == filemon2)				filemon_proc_drop(p);			filemon_drop(filemon2);		}		sx_xlock(&filemon->lock);		PROC_LOCK(p);		/*		 * It may have been attached to, though unlikely.		 * Try again if needed.		 */	}	KASSERT(p->p_filemon == NULL,	    ("%s: proc %p didn't detach filemon %p", __func__, p,	    p->p_filemon));	p->p_filemon = filemon_acquire(filemon);	++filemon->proccnt;	return (0);}

static voidsfxge_if_init(void *arg){	struct sfxge_softc *sc;	sc = (struct sfxge_softc *)arg;	sx_xlock(&sc->softc_lock);	(void)sfxge_start(sc);	sx_xunlock(&sc->softc_lock);}

intshared_page_fill(int size, int align, const void *data){	int res;	sx_xlock(&shared_page_alloc_sx);	res = shared_page_alloc_locked(size, align);	if (res != -1)		shared_page_write(res, size, data);	sx_xunlock(&shared_page_alloc_sx);	return (res);}

static voidsfxge_ifnet_fini(struct ifnet *ifp){	struct sfxge_softc *sc = ifp->if_softc;	sx_xlock(&sc->softc_lock);	sfxge_stop(sc);	sx_xunlock(&sc->softc_lock);	ifmedia_removeall(&sc->media);	ether_ifdetach(ifp);	if_free(ifp);}