PCATCH
error = msleep(sc, &sc->aw_mtx, PCATCH, "mmchw", 0);
error = msleep(irq, &irq->sc_mtx, PCATCH | PDROP,
err = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "zy7i1", hz);
err = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "zy7i2", hz);
err = mtx_sleep(sc->dma_map, &sc->sc_mtx, PCATCH,
if ((error = cam_periph_hold(periph, PRIBIO|PCATCH)) != 0) {
retval = msleep(be_lun, &softc->lock, PCATCH, "ctlblockrm", 0);
retval = msleep(be_lun, &softc->lock, PCATCH, "ctlramrm", 0);
cam_periph_hold(periph, PRIBIO|PCATCH);
cam_periph_hold(periph, PRIBIO|PCATCH);
if ((error = cam_periph_hold(periph, PRIBIO|PCATCH)) != 0) {
if ((error = cam_periph_hold(periph, PRIBIO|PCATCH)) != 0) {
if ((error = cam_periph_hold(periph, PRIBIO | PCATCH)) != 0) {
if ((error = cam_periph_hold(periph, PRIBIO | PCATCH)) != 0) {
if ((error = cam_periph_hold(periph, PRIBIO | PCATCH)) != 0) {
if ((error = da_periph_hold(periph, PRIBIO|PCATCH, DA_REF_OPEN_HOLD)) != 0) {
error = cam_periph_hold(periph, PRIBIO|PCATCH);
error = cam_periph_hold(periph, PRIBIO|PCATCH);
if ((error = cam_periph_hold(periph, PRIBIO|PCATCH)) != 0) {
if (cam_periph_sleep(periph, rdwr, PCATCH, "sgread", 0) == ERESTART)
PRIBIO | PCATCH, "tgabrt", 0);
PRIBIO | PCATCH, "targrd", 0);
PCATCH, "aacaif", 0);
PCATCH, "aacaif", 0);
tsleep(sc->aac_dev, PUSER | PCATCH, "aac_dch", 30 * hz);
PCATCH, "acsrst", hz) == EINTR) {
PCATCH, "acmrst", hz) == EINTR) {
error = mtx_sleep(am, &am->am_lock, PCATCH, "acmtx", 0);
error = mtx_sleep(am, &am->am_lock, PCATCH,
tsleep(sc, PUSER | PCATCH, "adstop", 1);
tsleep(sc, PUSER | PCATCH, "adreset", 1);
error = tsleep(sc, PZERO | PCATCH, "psmrea", 0);
if (mtx_sleep(&sc->flags, &sc->lock, PCATCH, "cxgbinit", 0)) {
if (mtx_sleep(&sc->flags, &sc->lock, PCATCH, "cxgbunin", 0)) {
flags & INTR_OK ? PCATCH : 0, wmesg, 0)) {
mtx_sleep(&sc->detaching, &sc->mutex, PCATCH, "cyapadet", hz);
error = mtx_sleep(&sc->blocked, &sc->mutex, PCATCH, "cyablk", 0);
PCATCH, "drmwtq", (timeout)); \
PCATCH, "drmrea", 0);
PCATCH, "drmvbl", 3 * hz);
PCATCH, "drmlk2", 0);
ret = -msleep(c, &c->lock, PCATCH, "drmwco", timeout);
flags = PCATCH;
flags = PCATCH;
flags = PCATCH;
flags = PCATCH;
flags = PCATCH;
PCATCH, "evread", 0);
PCATCH, "uiread", 0);
msleep((void *)fc, &fc->wait_lock, PWAIT|PCATCH, "-", 0);
err = msleep(xfer, lock, PWAIT|PCATCH, "fw_xferwait", 0);
#define FWPRI (PWAIT | PCATCH)
tsleep(&sc->xdma_tx, PCATCH | PZERO, "spi", hz/2);
tsleep(&sc->xdma_rx, PCATCH | PZERO, "spi", hz/2);
err = mtx_sleep(priv, &priv->mtx, PCATCH, "gpintr", 0);
PZERO | PCATCH, "hidrawio", 0);
error = mtx_sleep(&sc->sc_q, &sc->sc_mtx, PZERO | PCATCH,
error = mtx_sleep(&sc->sc_buf, &sc->sc_mtx, PZERO | PCATCH,
msleep(thr, &thr->mtx, PCATCH, "hwt-mmap", 0);
msleep(ctx, &ctx->rec_mtx, PCATCH, "recsnd", 0);
error = mtx_sleep(sc, &sc->lock, IICPRI|PCATCH, "iicreq", 0);
error = msleep(sc, &sc->lock, PWAIT | PCATCH, "SMBWAI", hz / 8);
error = msleep(sc, &sc->sc_mtx, PCATCH, __func__, ms);
error = msleep(&so->so_timeo, SOCK_MTX(so), PSOCK | PCATCH,
error = msleep(desc, &sc->sc_mtx, PCATCH, "iwmcmd", hz);
return async ? 0 : msleep(desc, &sc->sc_mtx, PCATCH, "iwncmd", hz);
error = msleep(sc, &sc->sc_mtx, PCATCH, "iwncal", 2 * hz);
if ((error = msleep(sc, &sc->sc_mtx, PCATCH, "iwninit", hz)) != 0) {
return msleep(sc, &sc->sc_mtx, PCATCH, "iwninit", 5 * hz);
if ((error = msleep(sc, &sc->sc_mtx, PCATCH, "iwninit", hz)) != 0) {
err = msleep(desc, &sc->sc_mtx, PCATCH, "iwxcmd", hz);
error = tsleep(sc, PZERO | PCATCH, "kbdrea", 0);
mtx_sleep(mc->mc_private, &sc->mlx_io_lock, PRIBIO | PCATCH, "mlxwcmd", hz);
error = msleep(ctx, &sc->mpr_mtx, PCATCH, "mprwait", 0);
error = msleep(ctx, &sc->mps_mtx, PCATCH, "mpswait", 0);
error = sx_sleep(nt, &nvmf_transports_lock, PCATCH,
error = msleep(cmd, &sc->sc_mtx, PCATCH, "otuscmd", hz);
if (ppb_sleep(ppbus, lptdev, LPPRI | PCATCH, "lptinit",
if (ppb_sleep(ppbus, lptdev, LPPRI | PCATCH, "lpclose",
LPPRI|PCATCH, LPT_NAME "write", 0))) {
(how == PPB_NOINTR ? 0 : PCATCH), "ppbpoll", hz/100);
PPBPRI | PCATCH, "ppbreq", 0);
error = ppb_sleep(ppbus, ppi, PCATCH | PPBPRI, "ppiwrite", 0);
error = mtx_sleep(ppc, &ppc->ppc_lock, PPBPRI | PCATCH,
error = mtx_sleep(ppc, &ppc->ppc_lock, PPBPRI | PCATCH,
slpflags = interruptible ? PCATCH : 0;
error = tsleep_sbt(p_random_alg_context, PCATCH,
error = msleep(sc, &sc->lock, SMBPRI|PCATCH, "smbreq", 0);
PCATCH | PDROP, "midi RX", 0);
PCATCH | PDROP, "midi TX", 0);
PRIBIO | PCATCH, "pcmsg", timo);
tsleep(&endrest, SPKRPRI | PCATCH, "spkrrs", timo);
tsleep(&endtone, SPKRPRI | PCATCH, "spkrtn", timo);
tsleep(VTY_WCHAN(sc, i), PZERO | PCATCH, "waitvt", 0);
error = tsleep(&scrn_blanked, PZERO | PCATCH, "scrsav", 0);
&tcp_log_dev_queue_lock, PCATCH, "tcplogdev", 0);
error = msleep(cmd, &r->mtx, PCATCH, "nhi_tx", cmd->timeout);
rv = tsleep(sc, PRIBIO | PCATCH, "legacy_tpm_start",
rv = tsleep(sc, PRIBIO | PCATCH, "legacy_tpm_end",
rv = tsleep(sc->sc_init, PRIBIO | PCATCH, "tpm_locality", 1);
rv = tsleep(sc, PRIBIO | PCATCH, "tpm_getburst", 1);
rv = tsleep(c, PRIBIO | PCATCH, "tpm_poll", 1);
rv = tsleep(c, PRIBIO | PCATCH, "tpm_intr", to);
msleep(&(s)->f, &(s)->ks_lock, PCATCH | PZERO, d, t)
#define VKBD_SLEEP(s, f, d, t) tsleep(&(s)->f, PCATCH | PZERO, d, t)
return async ? 0 : mtx_sleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz);
if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) {
if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) {
error = sx_sleep(u, &u->ring_cons_mutex, PCATCH, "evtchw", 0);
error = msleep(xen_store, &xs.ring_lock, PCATCH|PDROP,
error = msleep(xen_store, &xs.ring_lock, PCATCH|PDROP,
PWAIT | PCATCH, "waitev", hz/10);
error = tsleep(u, PCATCH, "xsdread", hz/10);
PDROP | PCATCH | PSOCK, "fifoor", 0);
PDROP | PCATCH | PSOCK, "fifoow", 0);
err = msleep(data, &data->ms_mtx, PCATCH, "fu_msg", 0);
bp = getblk(vp, lbn, on, PCATCH, 0, 0);
bp = getblk(vp, lbn, bcount, PCATCH, 0, 0);
error = vinvalbuf(vp, V_SAVE, PCATCH, 0);
error = vinvalbuf(vp, V_SAVE, PCATCH, 0);
err = msleep(ftick, &ftick->tk_aw_mtx, PCATCH, "fu_ans",
err = msleep(&data->ticketer, &fuse_mtx, PCATCH | PDROP,
bp = getblk(vp, lbn, iosize, PCATCH, 0, 0);
bp = getblk(vp, left_lbn, iosize, PCATCH, 0, 0);
bp = getblk(vp, right_lbn, right_blksize, PCATCH, 0, 0);
if ((priority & PCATCH) == 0)
bp = getblk(vp, bn, size, PCATCH, 0, 0);
slpflag = PCATCH;
slpflag = PCATCH;
if (slpflag == PCATCH) {
error = msleep(&ncl_iodwant[myiod], &ncl_iod_mutex, PWAIT | PCATCH,
slpflag = PCATCH;
if (slpflag == PCATCH) {
if (slpflag == PCATCH) {
error = nfs_catnap(PZERO | PCATCH, ret,
PVFS | PCATCH, "nfsmrl", hz);
error = vinvalbuf(vp, V_SAVE, PCATCH, 0);
error = vinvalbuf(vp, V_SAVE, PCATCH, 0);
error = msleep(vp, VI_MTX(vp), PCATCH | PDROP, "unioncp", 0);
PPAUSE | PDROP | PCATCH, "ggwait", 0);
error = sx_sleep(&sc, &sc->sc_lock, PRIBIO | PCATCH | PDROP,
error = msleep_sbt(kq, &kq->kq_lock, PSOCK | PCATCH,
error = msleep(q, &q->p_mtx, PWAIT | PCATCH | PDROP, "wait", 0);
PWAIT | PCATCH | PDROP, "pdwait", 0);
if ((error = quiesce_all_cpus("ktrent", PCATCH)) != 0) {
(flags & LINKER_UB_PCATCH) != 0 ? PCATCH : 0,
catch = pri & PCATCH;
priority |= PCATCH;
error = msleep_sbt(&p->p_sigacts, &p->p_mtx, PPAUSE | PCATCH,
while (msleep(&p->p_sigacts, &p->p_mtx, PPAUSE | PCATCH,
catch = priority & PCATCH;
(flags & C_CATCH) ? PCATCH : 0, wmesg, sbt, pr, flags));
catch = (prio & PCATCH) != 0;
err = msleep(pps, pps->driver_mtx, PCATCH,
err = tsleep(pps, PCATCH, "ppsfch", timo);
PCATCH, "lthr", timo);
msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0);
error = tsleep_sbt(&nanowait[curcpu], PWAIT | PCATCH, "nanslp",
error = msleep_sbt(uq, &uc->uc_lock, PCATCH | PDROP, wmesg,
(flags & SFB_CATCH) ? PCATCH | PVM : PVM, "sfbufa", 0);
error = mtx_sleep(&efd->efd_count, &efd->efd_lock, PCATCH,
PCATCH, "efdwr", 0);
PRIBIO | PCATCH, "pipdww", 0);
PRIBIO | PCATCH, "pipdwc", 0);
error = msleep(wpipe, PIPE_MTX(wpipe), PRIBIO | PCATCH,
error = msleep(wpipe, PIPE_MTX(rpipe), PRIBIO | PCATCH,
PRIBIO | PCATCH, "pipewr", 0);
prio |= PCATCH;
PRIBIO | PCATCH,
error = msleep(&p->p_flag2, &p->p_mtx, PPAUSE | PCATCH |
PCATCH, "tfdrd", 0);
error = msleep(msqkptr, &msq_mtx, PVFS | PCATCH,
error = msleep(msqkptr, &msq_mtx, PVFS | PCATCH,
error = msleep_sbt(semakptr, sema_mtxp, PVFS | PCATCH,
PCATCH, "mqsend", timo);
PCATCH, "mqrecv", timo);
PSOCK | PCATCH, "sbwait", sb->sb_timeo, 0, 0));
error = msleep(&head->sol_comp, SOCK_MTX(head), PSOCK | PCATCH,
PSOCK | PCATCH, "soclos",
error = msleep(&so->so_timeo, &so->so_lock, PSOCK | PCATCH,
return (msleep_sbt(&sb->sb_acc, SOCK_RECVBUF_MTX(so), PSOCK | PCATCH,
error = msleep(&p->p_aioinfo, AIO_MTX(ki), PRIBIO | PCATCH,
PRIBIO | PCATCH, "aiospn", 0);
error = msleep(&p->p_aioinfo, AIO_MTX(ki), PRIBIO | PCATCH,
error = msleep(&sc->pending, &sc->lock, PCATCH, "inotify", 0);
MNT_MTX(mp), PCATCH, "umntqw", 0);
mflags |= PCATCH;
mflags |= PCATCH;
(void)tsleep(&wait, PWAIT | PCATCH, "init_machclk", timo);
error = mtx_sleep(&d->bd_hbuf, &d->bd_lock, PRINET | PCATCH,
error = msleep(d, &d->bd_lock, PRINET | PCATCH,
error = mtx_sleep(tp, &tp->tun_mtx, PCATCH | PZERO,
mtx_sleep(vap, IEEE80211_LOCK_OBJ(ic), PCATCH,
PZERO|PCATCH, "hcictl",
PZERO|PCATCH, "hcictl",
PZERO|PCATCH, "hcictl",
error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "hcictl",
error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl",
error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl",
error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl",
error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl",
error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl",
PDROP | PCATCH, "ngdread", 0);
# define SLEEP(id, n) tsleep((id), PPAUSE|PCATCH, n, 0)
error = tsleep(&args, PCATCH, "nlmgrace", 5*hz);
error = tsleep(&args, PCATCH, "nlmgrace", 5*hz);
error = tsleep(&args, PCATCH, "nlmgrace", retry);
error = msleep(nw, &nlm_global_lock, PCATCH, "nlmlock", timo);
cu->cu_waitflag = PCATCH;
.nl_prio = PSOCK | PCATCH,
nl->nl_prio |= PCATCH;
nl->nl_prio &= ~PCATCH;
*(int *)info = (nl->nl_prio & PCATCH) ? TRUE : FALSE;
rc->rc_intr ? PCATCH : 0, "rpcrecon", 0);
rc->rc_intr ? PCATCH : 0, "rpccon", hz);
sleep_flag |= PCATCH;
(ct->ct_waitflag & PCATCH) == 0 && trycnt-- > 0)) {
ct->ct_waitflag = PCATCH;
PSOCK | PCATCH, "auditd", 0);
return (vm_wait_flags(obj, PCATCH));