void
icl_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 int
axgbe_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 int
devfs_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 int
mfi_pci_detach(device_t dev)
{
struct mfi_softc *sc;
struct mfi_disk *ld;
int error;
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);
while ((ld = TAILQ_FIRST(&sc->mfi_ld_tqh)) != NULL) {
if ((error = device_delete_child(dev, ld->ld_dev)) != 0) {
sc->mfi_detaching = 0;
sx_xunlock(&sc->mfi_config_lock);
return (error);
}
}
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);
}
int
sys_shm_unlink(struct thread *td, struct shm_unlink_args *uap)
{
char *path;
Fnv32_t fnv;
int error;
path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
error = copyinstr(uap->path, path, MAXPATHLEN, NULL);
if (error) {
free(path, M_TEMP);
return (error);
}
#ifdef KTRACE
if (KTRPOINT(curthread, KTR_NAMEI))
ktrnamei(path);
#endif
fnv = fnv_32_str(path, FNV1_32_INIT);
sx_xlock(&shm_dict_lock);
error = shm_remove(path, fnv, td->td_ucred);
sx_xunlock(&shm_dict_lock);
free(path, M_TEMP);
return (error);
}
static int
sysctl_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 int
tracer_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);
}
int
ig4iic_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 void
sfxge_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);
}
void
kproc_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 void
sfxge_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 int
mfi_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 void
filemon_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 drm_global_item_ref(struct drm_global_reference *ref)
{
int ret;
struct drm_global_item *item = &glob[ref->global_type];
void *object;
sx_xlock(&item->mutex);
if (item->refcount == 0) {
item->object = malloc(ref->size, M_DRM_GLOBAL,
M_WAITOK | M_ZERO);
ref->object = item->object;
ret = ref->init(ref);
if (unlikely(ret != 0))
goto out_err;
}
++item->refcount;
ref->object = item->object;
object = item->object;
sx_xunlock(&item->mutex);
return 0;
out_err:
sx_xunlock(&item->mutex);
item->object = NULL;
return ret;
}
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.
*/
void
fork_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_t
svc_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);
}
int
osd_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);
}
int
shared_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 int
intel_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 {
void
lock_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 int
filemon_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 int
filemon_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 void
sfxge_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);
}
int
shared_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 void
sfxge_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);
}
void drm_global_item_unref(struct drm_global_reference *ref)
{
struct drm_global_item *item = &glob[ref->global_type];
sx_xlock(&item->mutex);
MPASS(item->refcount != 0);
MPASS(ref->object == item->object);
if (--item->refcount == 0) {
ref->release(ref);
free(item->object, M_DRM_GLOBAL);
item->object = NULL;
}
sx_xunlock(&item->mutex);
}
