int
procfs_doctl(struct proc *curp, struct lwp *lp, struct pfsnode *pfs,
struct uio *uio)
{
struct proc *p = lp->lwp_proc;
int xlen;
int error;
char msg[PROCFS_CTLLEN+1];
vfs_namemap_t *nm;
ASSERT_LWKT_TOKEN_HELD(&p->p_token);
ASSERT_LWKT_TOKEN_HELD(&proc_token);
if (uio->uio_rw != UIO_WRITE)
return (EOPNOTSUPP);
xlen = PROCFS_CTLLEN;
error = vfs_getuserstr(uio, msg, &xlen);
if (error)
return (error);
/*
* Map signal names into signal generation
* or debug control. Unknown commands and/or signals
* return EOPNOTSUPP.
*
* Sending a signal while the process is being debugged
* also has the side effect of letting the target continue
* to run. There is no way to single-step a signal delivery.
*/
error = EOPNOTSUPP;
nm = vfs_findname(ctlnames, msg, xlen);
if (nm) {
error = procfs_control(curp, lp, nm->nm_val);
} else {
nm = vfs_findname(signames, msg, xlen);
if (nm) {
if (TRACE_WAIT_P(curp, p)) {
p->p_xstat = nm->nm_val;
#ifdef FIX_SSTEP
FIX_SSTEP(lp);
#endif
/*
* Make the process runnable but do not
* break its tsleep.
*/
proc_unstop(p);
} else {
ksignal(p, nm->nm_val);
}
error = 0;
}
}
return (error);
}
/*
* This function creates and initializes a pair of ttys.
*
* NOTE: Must be called with tty_token held
*/
static void
nmdminit(int n)
{
cdev_t dev1, dev2;
struct nm_softc *pt;
/*
* Simplified unit number, use low 8 bits of minor number
* (remember, the minor number mask is 0xffff00ff).
*/
if (n & ~0x7f)
return;
ASSERT_LWKT_TOKEN_HELD(&tty_token);
pt = kmalloc(sizeof(*pt), M_NLMDM, M_WAITOK | M_ZERO);
pt->part1.dev = dev1 = make_dev(&nmdm_ops, n << 1,
0, 0, 0666, "nmdm%dA", n);
pt->part2.dev = dev2 = make_dev(&nmdm_ops, (n << 1) + 1,
0, 0, 0666, "nmdm%dB", n);
dev1->si_drv1 = dev2->si_drv1 = pt;
dev1->si_tty = &pt->part1.nm_tty;
dev2->si_tty = &pt->part2.nm_tty;
ttyregister(&pt->part1.nm_tty);
ttyregister(&pt->part2.nm_tty);
pt->part1.nm_tty.t_oproc = nmdmstart;
pt->part2.nm_tty.t_oproc = nmdmstart;
pt->part1.nm_tty.t_stop = nmdmstop;
pt->part2.nm_tty.t_dev = dev1;
pt->part1.nm_tty.t_dev = dev2;
pt->part2.nm_tty.t_stop = nmdmstop;
}
/*
* NOTE: Must be called with tty_token held
*/
static int
snp_detach(struct snoop *snp)
{
struct tty *tp;
ASSERT_LWKT_TOKEN_HELD(&tty_token);
snp->snp_base = 0;
snp->snp_len = 0;
/*
* If line disc. changed we do not touch this pointer, SLIP/PPP will
* change it anyway.
*/
tp = snp->snp_tty;
if (tp == NULL)
goto detach_notty;
if (tp && (tp->t_sc == snp) && (tp->t_state & TS_SNOOP) &&
tp->t_line == snooplinedisc) {
tp->t_sc = NULL;
tp->t_state &= ~TS_SNOOP;
tp->t_line = snp->snp_olddisc;
} else
kprintf("Snoop: bad attached tty data.\n");
snp->snp_tty = NULL;
snp->snp_target = NULL;
detach_notty:
KNOTE(&snp->snp_kq.ki_note, 0);
if ((snp->snp_flags & SNOOP_OPEN) == 0)
kfree(snp, M_SNP);
return (0);
}
/*
* Run the chain and if the bottom-most object is a vnode-type lock the
* underlying vnode. A locked vnode or NULL is returned.
*/
struct vnode *
vnode_pager_lock(vm_object_t object)
{
struct vnode *vp = NULL;
vm_object_t lobject;
vm_object_t tobject;
int error;
if (object == NULL)
return(NULL);
ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
lobject = object;
while (lobject->type != OBJT_VNODE) {
if (lobject->flags & OBJ_DEAD)
break;
tobject = lobject->backing_object;
if (tobject == NULL)
break;
vm_object_hold_shared(tobject);
if (tobject == lobject->backing_object) {
if (lobject != object) {
vm_object_lock_swap();
vm_object_drop(lobject);
}
lobject = tobject;
} else {
vm_object_drop(tobject);
}
}
while (lobject->type == OBJT_VNODE &&
(lobject->flags & OBJ_DEAD) == 0) {
/*
* Extract the vp
*/
vp = lobject->handle;
error = vget(vp, LK_SHARED | LK_RETRY | LK_CANRECURSE);
if (error == 0) {
if (lobject->handle == vp)
break;
vput(vp);
} else {
kprintf("vnode_pager_lock: vp %p error %d "
"lockstatus %d, retrying\n",
vp, error,
lockstatus(&vp->v_lock, curthread));
tsleep(object->handle, 0, "vnpgrl", hz);
}
vp = NULL;
}
if (lobject != object)
vm_object_drop(lobject);
return (vp);
}
/*
* NOTE: Must be called with tty_token held
*/
static int
snp_down(struct snoop *snp)
{
ASSERT_LWKT_TOKEN_HELD(&tty_token);
if (snp->snp_blen != SNOOP_MINLEN) {
kfree(snp->snp_buf, M_SNP);
snp->snp_buf = kmalloc(SNOOP_MINLEN, M_SNP, M_WAITOK);
snp->snp_blen = SNOOP_MINLEN;
}
snp->snp_flags |= SNOOP_DOWN;
return (snp_detach(snp));
}
/*
* NOTE: Must be called with tty_token held
*/
static void
ptcwakeup(struct tty *tp, int flag)
{
ASSERT_LWKT_TOKEN_HELD(&tty_token);
if (flag & FREAD) {
wakeup(TSA_PTC_READ(tp));
KNOTE(&tp->t_rkq.ki_note, 0);
}
if (flag & FWRITE) {
wakeup(TSA_PTC_WRITE(tp));
KNOTE(&tp->t_wkq.ki_note, 0);
}
}
/*
* vm_contig_pg_clean:
*
* Do a thorough cleanup of the specified 'queue', which can be either
* PQ_ACTIVE or PQ_INACTIVE by doing a walkthrough. If the page is not
* marked dirty, it is shoved into the page cache, provided no one has
* currently aqcuired it, otherwise localized action per object type
* is taken for cleanup:
*
* In the OBJT_VNODE case, the whole page range is cleaned up
* using the vm_object_page_clean() routine, by specyfing a
* start and end of '0'.
*
* Otherwise if the object is of any other type, the generic
* pageout (daemon) flush routine is invoked.
*
* The caller must hold vm_token.
*/
static int
vm_contig_pg_clean(int queue)
{
vm_object_t object;
vm_page_t m, m_tmp, next;
ASSERT_LWKT_TOKEN_HELD(&vm_token);
for (m = TAILQ_FIRST(&vm_page_queues[queue].pl); m != NULL; m = next) {
KASSERT(m->queue == queue,
("vm_contig_clean: page %p's queue is not %d",
m, queue));
next = TAILQ_NEXT(m, pageq);
if (m->flags & PG_MARKER)
continue;
if (vm_page_sleep_busy(m, TRUE, "vpctw0"))
return (TRUE);
vm_page_test_dirty(m);
if (m->dirty) {
object = m->object;
if (object->type == OBJT_VNODE) {
vn_lock(object->handle, LK_EXCLUSIVE|LK_RETRY);
vm_object_page_clean(object, 0, 0, OBJPC_SYNC);
vn_unlock(((struct vnode *)object->handle));
return (TRUE);
} else if (object->type == OBJT_SWAP ||
object->type == OBJT_DEFAULT) {
m_tmp = m;
vm_pageout_flush(&m_tmp, 1, 0);
return (TRUE);
}
}
KKASSERT(m->busy == 0);
if (m->dirty == 0 && m->hold_count == 0) {
vm_page_busy(m);
vm_page_cache(m);
}
}
return (FALSE);
}
/*
* NOTE: Must be called with tty_token held
*/
static int
snp_in(struct snoop *snp, char *buf, int n)
{
int s_free, s_tail;
int len, nblen;
caddr_t from, to;
char *nbuf;
ASSERT_LWKT_TOKEN_HELD(&tty_token);
KASSERT(n >= 0, ("negative snoop char count"));
if (n == 0)
return (0);
if (snp->snp_flags & SNOOP_DOWN) {
kprintf("Snoop: more data to down interface.\n");
return (0);
}
if (snp->snp_flags & SNOOP_OFLOW) {
kprintf("Snoop: buffer overflow.\n");
/*
* On overflow we just repeat the standart close
* procedure...yes , this is waste of space but.. Then next
* read from device will fail if one would recall he is
* snooping and retry...
*/
return (snp_down(snp));
}
s_tail = snp->snp_blen - (snp->snp_len + snp->snp_base);
s_free = snp->snp_blen - snp->snp_len;
if (n > s_free) {
crit_enter();
nblen = snp->snp_blen;
while ((n > s_free) && ((nblen * 2) <= SNOOP_MAXLEN)) {
nblen = snp->snp_blen * 2;
s_free = nblen - (snp->snp_len + snp->snp_base);
}
if ((n <= s_free) && (nbuf = kmalloc(nblen, M_SNP, M_NOWAIT))) {
bcopy(snp->snp_buf + snp->snp_base, nbuf, snp->snp_len);
kfree(snp->snp_buf, M_SNP);
snp->snp_buf = nbuf;
snp->snp_blen = nblen;
snp->snp_base = 0;
} else {
snp->snp_flags |= SNOOP_OFLOW;
if (snp->snp_flags & SNOOP_RWAIT) {
snp->snp_flags &= ~SNOOP_RWAIT;
wakeup((caddr_t)snp);
}
crit_exit();
return (0);
}
crit_exit();
}
if (n > s_tail) {
from = (caddr_t)(snp->snp_buf + snp->snp_base);
to = (caddr_t)(snp->snp_buf);
len = snp->snp_len;
bcopy(from, to, len);
snp->snp_base = 0;
}
to = (caddr_t)(snp->snp_buf + snp->snp_base + snp->snp_len);
bcopy(buf, to, n);
snp->snp_len += n;
if (snp->snp_flags & SNOOP_RWAIT) {
snp->snp_flags &= ~SNOOP_RWAIT;
wakeup((caddr_t)snp);
}
KNOTE(&snp->snp_kq.ki_note, 0);
return (n);
}
/*
* NOTE: Must be called with tty_token held
*/
static void
rp_do_receive(struct rp_port *rp, struct tty *tp,
CHANNEL_t *cp, unsigned int ChanStatus)
{
unsigned int CharNStat;
int ToRecv, wRecv, ch, ttynocopy;
ASSERT_LWKT_TOKEN_HELD(&tty_token);
ToRecv = sGetRxCnt(cp);
if(ToRecv == 0)
return;
/* If status indicates there are errored characters in the
FIFO, then enter status mode (a word in FIFO holds
characters and status)
*/
if(ChanStatus & (RXFOVERFL | RXBREAK | RXFRAME | RXPARITY)) {
if(!(ChanStatus & STATMODE)) {
ChanStatus |= STATMODE;
sEnRxStatusMode(cp);
}
}
/*
if we previously entered status mode then read down the
FIFO one word at a time, pulling apart the character and
the status. Update error counters depending on status.
*/
if(ChanStatus & STATMODE) {
while(ToRecv) {
if(tp->t_state & TS_TBLOCK) {
break;
}
CharNStat = rp_readch2(cp,sGetTxRxDataIO(cp));
ch = CharNStat & 0xff;
if((CharNStat & STMBREAK) || (CharNStat & STMFRAMEH))
ch |= TTY_FE;
else if (CharNStat & STMPARITYH)
ch |= TTY_PE;
else if (CharNStat & STMRCVROVRH)
rp->rp_overflows++;
(*linesw[tp->t_line].l_rint)(ch, tp);
ToRecv--;
}
/*
After emtying FIFO in status mode, turn off status mode
*/
if(sGetRxCnt(cp) == 0) {
sDisRxStatusMode(cp);
}
} else {
/*
* Avoid the grotesquely inefficient lineswitch routine
* (ttyinput) in "raw" mode. It usually takes about 450
* instructions (that's without canonical processing or echo!).
* slinput is reasonably fast (usually 40 instructions plus
* call overhead).
*/
ToRecv = sGetRxCnt(cp);
if ( tp->t_state & TS_CAN_BYPASS_L_RINT ) {
if ( ToRecv > RXFIFO_SIZE ) {
ToRecv = RXFIFO_SIZE;
}
wRecv = ToRecv >> 1;
if ( wRecv ) {
rp_readmultich2(cp,sGetTxRxDataIO(cp),(u_int16_t *)rp->RxBuf,wRecv);
}
if ( ToRecv & 1 ) {
((unsigned char *)rp->RxBuf)[(ToRecv-1)] = (u_char) rp_readch1(cp,sGetTxRxDataIO(cp));
}
tk_nin += ToRecv;
tk_rawcc += ToRecv;
tp->t_rawcc += ToRecv;
ttynocopy = b_to_q((char *)rp->RxBuf, ToRecv, &tp->t_rawq);
ttwakeup(tp);
} else {
while (ToRecv) {
if(tp->t_state & TS_TBLOCK) {
break;
}
ch = (u_char) rp_readch1(cp,sGetTxRxDataIO(cp));
crit_enter();
(*linesw[tp->t_line].l_rint)(ch, tp);
crit_exit();
ToRecv--;
}
}
}
static int
procfs_control(struct proc *curp, struct lwp *lp, int op)
{
struct proc *p = lp->lwp_proc;
int error;
ASSERT_LWKT_TOKEN_HELD(&p->p_token);
ASSERT_LWKT_TOKEN_HELD(&proc_token);
/* Can't trace a process that's currently exec'ing. */
if ((p->p_flags & P_INEXEC) != 0)
return EAGAIN;
/*
* Authorization check: rely on normal debugging protection, except
* allow processes to disengage debugging on a process onto which
* they have previously attached, but no longer have permission to
* debug.
*/
if (op != PROCFS_CTL_DETACH) {
if (securelevel > 0 && p->p_pid == 1)
return (EPERM);
if (!CHECKIO(curp, p) || p_trespass(curp->p_ucred, p->p_ucred))
return (EPERM);
}
/*
* Attach - attaches the target process for debugging
* by the calling process.
*/
if (op == PROCFS_CTL_ATTACH) {
/* check whether already being traced */
if (p->p_flags & P_TRACED)
return (EBUSY);
/* can't trace yourself! */
if (p->p_pid == curp->p_pid)
return (EINVAL);
/*
* Go ahead and set the trace flag.
* Save the old parent (it's reset in
* _DETACH, and also in kern_exit.c:wait4()
* Reparent the process so that the tracing
* proc gets to see all the action.
* Stop the target.
*/
p->p_flags |= P_TRACED;
faultin(p);
p->p_xstat = 0; /* XXX ? */
if (p->p_pptr != curp) {
p->p_oppid = p->p_pptr->p_pid;
proc_reparent(p, curp);
}
proc_stop(p);
return (0);
}
/*
* Target process must be stopped, owned by (curp) and
* be set up for tracing (P_TRACED flag set).
* Allow DETACH to take place at any time for sanity.
* Allow WAIT any time, of course.
*/
switch (op) {
case PROCFS_CTL_DETACH:
case PROCFS_CTL_WAIT:
break;
default:
if (!TRACE_WAIT_P(curp, p))
return (EBUSY);
}
#ifdef FIX_SSTEP
/*
* do single-step fixup if needed
*/
FIX_SSTEP(lp);
#endif
/*
* Don't deliver any signal by default.
* To continue with a signal, just send
* the signal name to the ctl file
*/
p->p_xstat = 0;
switch (op) {
/*
* Detach. Cleans up the target process, reparent it if possible
* and set it running once more.
*/
case PROCFS_CTL_DETACH:
/* if not being traced, then this is a painless no-op */
if ((p->p_flags & P_TRACED) == 0)
return (0);
/* not being traced any more */
p->p_flags &= ~P_TRACED;
/* remove pending SIGTRAP, else the process will die */
spin_lock(&lp->lwp_spin);
lwp_delsig(lp, SIGTRAP);
spin_unlock(&lp->lwp_spin);
/* give process back to original parent */
if (p->p_oppid != p->p_pptr->p_pid) {
struct proc *pp;
pp = pfs_pfind(p->p_oppid);
if (pp) {
proc_reparent(p, pp);
pfs_pdone(pp);
}
}
p->p_oppid = 0;
p->p_flags &= ~P_WAITED; /* XXX ? */
wakeup((caddr_t) curp); /* XXX for CTL_WAIT below ? */
break;
/*
* Step. Let the target process execute a single instruction.
*/
case PROCFS_CTL_STEP:
LWPHOLD(lp);
error = procfs_sstep(lp);
LWPRELE(lp);
if (error)
return (error);
break;
/*
* Run. Let the target process continue running until a breakpoint
* or some other trap.
*/
case PROCFS_CTL_RUN:
break;
/*
* Wait for the target process to stop.
* If the target is not being traced then just wait
* to enter
*/
case PROCFS_CTL_WAIT:
error = 0;
if (p->p_flags & P_TRACED) {
while (error == 0 &&
p->p_stat != SSTOP &&
(p->p_flags & P_TRACED) &&
(p->p_pptr == curp)) {
error = tsleep((caddr_t) p,
PCATCH, "procfsx", 0);
}
if (error == 0 && !TRACE_WAIT_P(curp, p))
error = EBUSY;
} else {
while (error == 0 && p->p_stat != SSTOP) {
error = tsleep((caddr_t) p,
PCATCH, "procfs", 0);
}
}
return (error);
default:
panic("procfs_control");
}
/*
* If the process is in a stopped state, make it runnable again.
* Do not set LWP_MP_BREAKTSLEEP - that is, do not break a tsleep
* that might be in progress.
*/
if (p->p_stat == SSTOP)
proc_unstop(p);
return (0);
}
