[unix-history] / usr / src / sys / kern / tty_subr.c

/*	tty_subr.c	4.8	%G%	*/

#include "../h/param.h"
#include "../h/systm.h"
#include "../h/conf.h"
#include "../h/buf.h"
#include "../h/tty.h"
#include "../h/clist.h"

char	cwaiting;

/*
 * Character list get/put
 */
getc(p)
register struct clist *p;
{
	register struct cblock *bp;
	register int c, s;

	s = spl6();
	if (p->c_cc <= 0) {
		c = -1;
		p->c_cc = 0;
		p->c_cf = p->c_cl = NULL;
	} else {
		c = *p->c_cf++ & 0377;
		if (--p->c_cc<=0) {
			bp = (struct cblock *)(p->c_cf-1);
			bp = (struct cblock *) ((int)bp & ~CROUND);
			p->c_cf = NULL;
			p->c_cl = NULL;
			bp->c_next = cfreelist;
			cfreelist = bp;
			cfreecount += CBSIZE;
			if (cwaiting) {
				wakeup(&cwaiting);
				cwaiting = 0;
			}
		} else if (((int)p->c_cf & CROUND) == 0){
			bp = (struct cblock *)(p->c_cf);
			bp--;
			p->c_cf = bp->c_next->c_info;
			bp->c_next = cfreelist;
			cfreelist = bp;
			cfreecount += CBSIZE;
			if (cwaiting) {
				wakeup(&cwaiting);
				cwaiting = 0;
			}
		}
	}
	splx(s);
	return(c);
}

/*
 * copy clist to buffer.
 * return number of bytes moved.
 */
q_to_b(q, cp, cc)
register struct clist *q;
register char *cp;
{
	register struct cblock *bp;
	register int s;
	char *acp;

	if (cc <= 0)
		return(0);
	s = spl6();
	if (q->c_cc <= 0) {
		q->c_cc = 0;
		q->c_cf = q->c_cl = NULL;
		splx(s);
		return(0);
	}
	acp = cp;
	cc++;

	while (--cc) {
		*cp++ = *q->c_cf++;
		if (--q->c_cc <= 0) {
			bp = (struct cblock *)(q->c_cf-1);
			bp = (struct cblock *)((int)bp & ~CROUND);
			q->c_cf = q->c_cl = NULL;
			bp->c_next = cfreelist;
			cfreelist = bp;
			cfreecount += CBSIZE;
			if (cwaiting) {
				wakeup(&cwaiting);
				cwaiting = 0;
			}
			break;
		}
		if (((int)q->c_cf & CROUND) == 0) {
			bp = (struct cblock *)(q->c_cf);
			bp--;
			q->c_cf = bp->c_next->c_info;
			bp->c_next = cfreelist;
			cfreelist = bp;
			cfreecount += CBSIZE;
			if (cwaiting) {
				wakeup(&cwaiting);
				cwaiting = 0;
			}
		}
	}
	splx(s);
	return(cp-acp);
}

/*
 * Return count of contiguous characters
 * in clist starting at q->c_cf.
 * Stop counting if flag&character is non-null.
 */
ndqb(q, flag)
register struct clist *q;
{
register cc;
int s;

	s = spl6();
	if (q->c_cc <= 0) {
		cc = -q->c_cc;
		goto out;
	}
	cc = ((int)q->c_cf + CBSIZE) & ~CROUND;
	cc -= (int)q->c_cf;
	if (q->c_cc < cc)
		cc = q->c_cc;
	if (flag) {
		register char *p, *end;

		p = q->c_cf;
		end = p;
		end += cc;
		while (p < end) {
			if (*p & flag) {
				cc = (int)p;
				cc -= (int)q->c_cf;
				break;
			}
			p++;
		}
	}
out:
	splx(s);
	return(cc);
}


/*
 * Flush cc bytes from q.
 */
ndflush(q, cc)
register struct clist *q;
register cc;
{
register struct cblock *bp;
char *end;
int rem;
register s;

	s = spl6();
	if (q->c_cc < 0) {
		printf("neg q flush\n");
		goto out;
	}
	if (q->c_cc == 0) {
		goto out;
	}
	while (cc>0 && q->c_cc) {
		bp = (struct cblock *)((int)q->c_cf & ~CROUND);
		if ((int)bp == (((int)q->c_cl-1) & ~CROUND)) {
			end = q->c_cl;
		} else {
			end = (char *)((int)bp + sizeof (struct cblock));
		}
		rem = end - q->c_cf;
		if (cc >= rem) {
			cc -= rem;
			q->c_cc -= rem;
			q->c_cf = bp->c_next->c_info;
			bp->c_next = cfreelist;
			cfreelist = bp;
			cfreecount += CBSIZE;
			if (cwaiting) {
				wakeup(&cwaiting);
				cwaiting = 0;
			}
		} else {
			q->c_cc -= cc;
			q->c_cf += cc;
			if (q->c_cc <= 0) {
				bp->c_next = cfreelist;
				cfreelist = bp;
				cfreecount += CBSIZE;
				if (cwaiting) {
					wakeup(&cwaiting);
					cwaiting = 0;
				}
			}
			break;
		}
	}
	if (q->c_cc <= 0) {
		q->c_cf = q->c_cl = NULL;
		q->c_cc = 0;
	}
out:
	splx(s);
}


putc(c, p)
register struct clist *p;
{
	register struct cblock *bp;
	register char *cp;
	register s;

	s = spl6();
	if ((cp = p->c_cl) == NULL || p->c_cc < 0 ) {
		if ((bp = cfreelist) == NULL) {
			splx(s);
			return(-1);
		}
		cfreelist = bp->c_next;
		cfreecount -= CBSIZE;
		bp->c_next = NULL;
		p->c_cf = cp = bp->c_info;
	} else if (((int)cp & CROUND) == 0) {
		bp = (struct cblock *)cp - 1;
		if ((bp->c_next = cfreelist) == NULL) {
			splx(s);
			return(-1);
		}
		bp = bp->c_next;
		cfreelist = bp->c_next;
		cfreecount -= CBSIZE;
		bp->c_next = NULL;
		cp = bp->c_info;
	}
	*cp++ = c;
	p->c_cc++;
	p->c_cl = cp;
	splx(s);
	return(0);
}


/*
 * copy buffer to clist.
 * return number of bytes not transfered.
 */
b_to_q(cp, cc, q)
register char *cp;
struct clist *q;
register int cc;
{
	register char *cq;
	register struct cblock *bp;
	register s, acc;

	if (cc <= 0)
		return(0);
	acc = cc;


	s = spl6();
	if ((cq = q->c_cl) == NULL || q->c_cc < 0) {
		if ((bp = cfreelist) == NULL) 
			goto out;
		cfreelist = bp->c_next;
		cfreecount -= CBSIZE;
		bp->c_next = NULL;
		q->c_cf = cq = bp->c_info;
	}

	while (cc) {
		if (((int)cq & CROUND) == 0) {
			bp = (struct cblock *) cq - 1;
			if ((bp->c_next = cfreelist) == NULL) 
				goto out;
			bp = bp->c_next;
			cfreelist = bp->c_next;
			cfreecount -= CBSIZE;
			bp->c_next = NULL;
			cq = bp->c_info;
		}
		*cq++ = *cp++;
		cc--;
	}
out:
	q->c_cl = cq;
	q->c_cc += acc-cc;
	splx(s);
	return(cc);
}

char *
wb_to_q(cp, cc, q)
register char *cp;
register struct clist *q;
register cc;
{
char *f;
register s;

	s = spl6();
	while (cc > cfreecount) {
		cwaiting = 1;
		sleep(&cwaiting, TTOPRI);
	}
	if (q->c_cc==0) {
		b_to_q(cp, cc, q);
		f = q->c_cf;
	} else {
		(void) putc(*cp++, q);
		f = q->c_cl;
		f--;
		b_to_q(cp, --cc, q);
	}
	splx(s);
	return(f);
}

/*
 * Given a non-NULL pointter into the list (like c_cf which
 * always points to a real character if non-NULL) return the pointer
 * to the next character in the list or return NULL if no more chars.
 *
 * Callers must not allow getc's to happen between nextc's so that the
 * pointer becomes invalid.  Note that interrupts are NOT masked.
 */
char *
nextc(p, cp)
register struct clist *p;
register char *cp;
{

	if (p->c_cc && ++cp != p->c_cl) {
		if (((int)cp & CROUND) == 0)
			return (((struct cblock *)cp)[-1].c_next->c_info);
		return (cp);
	}
	return (0);
}

/*
 * Remove the last character in the list and return it.
 */
unputc(p)
register struct clist *p;
{
	register struct cblock *bp;
	register int c, s;
	struct cblock *obp;

	s = spl6();
	if (p->c_cc <= 0)
		c = -1;
	else {
		c = *--p->c_cl;
		if (--p->c_cc <= 0) {
			bp = (struct cblock *)p->c_cl;
			bp = (struct cblock *)((int)bp & ~CROUND);
			p->c_cl = p->c_cf = NULL;
			bp->c_next = cfreelist;
			cfreelist = bp;
			cfreecount += CBSIZE;
		} else if (((int)p->c_cl & CROUND) == sizeof(bp->c_next)) {
			p->c_cl = (char *)((int)p->c_cl & ~CROUND);
			bp = (struct cblock *)p->c_cf;
			bp = (struct cblock *)((int)bp & ~CROUND);
			while (bp->c_next != (struct cblock *)p->c_cl)
				bp = bp->c_next;
			obp = bp;
			p->c_cl = (char *)(bp + 1);
			bp = bp->c_next;
			bp->c_next = cfreelist;
			cfreelist = bp;
			cfreecount += CBSIZE;
			obp->c_next = NULL;
		}
	}
	splx(s);
	return (c);
}

/*
 * Put the chars in the from que
 * on the end of the to que.
 *
 * SHOULD JUST USE q_to_b AND THEN b_to_q HERE.
 */
catq(from, to)
struct clist *from, *to;
{
	register c;

	while ((c = getc(from)) >= 0)
		(void) putc(c, to);
}

/*
 * integer (2-byte) get/put
 * using clists
 */
getw(p)
register struct clist *p;
{
	register int s;

	if (p->c_cc <= 1)
		return(-1);
	s = getc(p);
	return(s | (getc(p)<<8));
}

putw(c, p)
register struct clist *p;
{
	register s;

	s = spl6();
	if (cfreelist==NULL) {
		splx(s);
		return(-1);
	}
	(void) putc(c, p);
	(void) putc(c>>8, p);
	splx(s);
	return(0);
}
Commit	Line	Data
0e8a6d93	1	/* tty_subr.c 4.8 %G% */
8f6119af	2
11bd398c	3	#include "../h/param.h"
11bd398c BJ	4	#include "../h/systm.h"
	5	#include "../h/conf.h"
	6	#include "../h/buf.h"
48575cec	7	#include "../h/tty.h"
d4df41fe	8	#include "../h/clist.h"
11bd398c	9
48575cec	10	char cwaiting;
11bd398c BJ	11
	12	/*
	13	* Character list get/put
	14	*/
	15	getc(p)
	16	register struct clist *p;
	17	{
	18	register struct cblock *bp;
	19	register int c, s;
	20
	21	s = spl6();
	22	if (p->c_cc <= 0) {
	23	c = -1;
	24	p->c_cc = 0;
	25	p->c_cf = p->c_cl = NULL;
	26	} else {
	27	c = *p->c_cf++ & 0377;
	28	if (--p->c_cc<=0) {
	29	bp = (struct cblock *)(p->c_cf-1);
	30	bp = (struct cblock *) ((int)bp & ~CROUND);
	31	p->c_cf = NULL;
	32	p->c_cl = NULL;
	33	bp->c_next = cfreelist;
	34	cfreelist = bp;
48575cec BJ	35	cfreecount += CBSIZE;
	36	if (cwaiting) {
	37	wakeup(&cwaiting);
	38	cwaiting = 0;
	39	}
11bd398c BJ	40	} else if (((int)p->c_cf & CROUND) == 0){
	41	bp = (struct cblock *)(p->c_cf);
	42	bp--;
	43	p->c_cf = bp->c_next->c_info;
	44	bp->c_next = cfreelist;
	45	cfreelist = bp;
48575cec BJ	46	cfreecount += CBSIZE;
	47	if (cwaiting) {
	48	wakeup(&cwaiting);
	49	cwaiting = 0;
	50	}
11bd398c BJ	51	}
	52	}
	53	splx(s);
	54	return(c);
	55	}
	56
	57	/*
	58	* copy clist to buffer.
	59	* return number of bytes moved.
	60	*/
	61	q_to_b(q, cp, cc)
	62	register struct clist *q;
	63	register char *cp;
	64	{
	65	register struct cblock *bp;
	66	register int s;
	67	char *acp;
	68
	69	if (cc <= 0)
	70	return(0);
	71	s = spl6();
	72	if (q->c_cc <= 0) {
	73	q->c_cc = 0;
	74	q->c_cf = q->c_cl = NULL;
48575cec	75	splx(s);
11bd398c BJ	76	return(0);
	77	}
	78	acp = cp;
	79	cc++;
	80
	81	while (--cc) {
	82	cp++ = q->c_cf++;
	83	if (--q->c_cc <= 0) {
	84	bp = (struct cblock *)(q->c_cf-1);
	85	bp = (struct cblock *)((int)bp & ~CROUND);
	86	q->c_cf = q->c_cl = NULL;
	87	bp->c_next = cfreelist;
	88	cfreelist = bp;
48575cec BJ	89	cfreecount += CBSIZE;
	90	if (cwaiting) {
	91	wakeup(&cwaiting);
	92	cwaiting = 0;
	93	}
11bd398c BJ	94	break;
	95	}
	96	if (((int)q->c_cf & CROUND) == 0) {
	97	bp = (struct cblock *)(q->c_cf);
	98	bp--;
	99	q->c_cf = bp->c_next->c_info;
	100	bp->c_next = cfreelist;
	101	cfreelist = bp;
48575cec BJ	102	cfreecount += CBSIZE;
	103	if (cwaiting) {
	104	wakeup(&cwaiting);
	105	cwaiting = 0;
	106	}
11bd398c BJ	107	}
	108	}
	109	splx(s);
	110	return(cp-acp);
	111	}
	112
11bd398c BJ	113	/*
	114	* Return count of contiguous characters
	115	* in clist starting at q->c_cf.
	116	* Stop counting if flag&character is non-null.
	117	*/
	118	ndqb(q, flag)
	119	register struct clist *q;
	120	{
	121	register cc;
	122	int s;
	123
	124	s = spl6();
	125	if (q->c_cc <= 0) {
	126	cc = -q->c_cc;
	127	goto out;
	128	}
	129	cc = ((int)q->c_cf + CBSIZE) & ~CROUND;
	130	cc -= (int)q->c_cf;
	131	if (q->c_cc < cc)
	132	cc = q->c_cc;
	133	if (flag) {
	134	register char p, end;
	135
	136	p = q->c_cf;
	137	end = p;
	138	end += cc;
	139	while (p < end) {
	140	if (*p & flag) {
48575cec BJ	141	cc = (int)p;
48575cec BJ	142	cc -= (int)q->c_cf;
11bd398c BJ	143	break;
	144	}
	145	p++;
	146	}
	147	}
	148	out:
	149	splx(s);
	150	return(cc);
	151	}
	152
48575cec BJ	153
48575cec BJ	154
11bd398c	155	/*
48575cec	156	* Flush cc bytes from q.
11bd398c BJ	157	*/
	158	ndflush(q, cc)
	159	register struct clist *q;
	160	register cc;
	161	{
48575cec BJ	162	register struct cblock *bp;
	163	char *end;
	164	int rem;
11bd398c BJ	165	register s;
11bd398c BJ	166
11bd398c BJ	167	s = spl6();
11bd398c BJ	168	if (q->c_cc < 0) {
48575cec	169	printf("neg q flush\n");
11bd398c BJ	170	goto out;
	171	}
	172	if (q->c_cc == 0) {
	173	goto out;
	174	}
48575cec BJ	175	while (cc>0 && q->c_cc) {
	176	bp = (struct cblock *)((int)q->c_cf & ~CROUND);
	177	if ((int)bp == (((int)q->c_cl-1) & ~CROUND)) {
	178	end = q->c_cl;
	179	} else {
	180	end = (char *)((int)bp + sizeof (struct cblock));
	181	}
	182	rem = end - q->c_cf;
	183	if (cc >= rem) {
	184	cc -= rem;
	185	q->c_cc -= rem;
11bd398c	186	q->c_cf = bp->c_next->c_info;
48575cec BJ	187	bp->c_next = cfreelist;
	188	cfreelist = bp;
	189	cfreecount += CBSIZE;
	190	if (cwaiting) {
	191	wakeup(&cwaiting);
	192	cwaiting = 0;
	193	}
11bd398c	194	} else {
48575cec BJ	195	q->c_cc -= cc;
	196	q->c_cf += cc;
	197	if (q->c_cc <= 0) {
	198	bp->c_next = cfreelist;
	199	cfreelist = bp;
	200	cfreecount += CBSIZE;
	201	if (cwaiting) {
	202	wakeup(&cwaiting);
	203	cwaiting = 0;
	204	}
	205	}
	206	break;
11bd398c	207	}
48575cec BJ	208	}
48575cec BJ	209	if (q->c_cc <= 0) {
11bd398c	210	q->c_cf = q->c_cl = NULL;
48575cec	211	q->c_cc = 0;
11bd398c BJ	212	}
	213	out:
	214	splx(s);
	215	}
b8f09f36	216
48575cec	217
11bd398c BJ	218	putc(c, p)
	219	register struct clist *p;
	220	{
	221	register struct cblock *bp;
	222	register char *cp;
	223	register s;
	224
	225	s = spl6();
	226	if ((cp = p->c_cl) == NULL \|\| p->c_cc < 0 ) {
	227	if ((bp = cfreelist) == NULL) {
	228	splx(s);
	229	return(-1);
	230	}
	231	cfreelist = bp->c_next;
48575cec	232	cfreecount -= CBSIZE;
11bd398c BJ	233	bp->c_next = NULL;
	234	p->c_cf = cp = bp->c_info;
	235	} else if (((int)cp & CROUND) == 0) {
	236	bp = (struct cblock *)cp - 1;
	237	if ((bp->c_next = cfreelist) == NULL) {
	238	splx(s);
	239	return(-1);
	240	}
	241	bp = bp->c_next;
	242	cfreelist = bp->c_next;
48575cec	243	cfreecount -= CBSIZE;
11bd398c BJ	244	bp->c_next = NULL;
	245	cp = bp->c_info;
	246	}
	247	*cp++ = c;
	248	p->c_cc++;
	249	p->c_cl = cp;
	250	splx(s);
	251	return(0);
	252	}
	253
48575cec BJ	254
48575cec BJ	255
11bd398c BJ	256	/*
	257	* copy buffer to clist.
	258	* return number of bytes not transfered.
	259	*/
	260	b_to_q(cp, cc, q)
	261	register char *cp;
	262	struct clist *q;
	263	register int cc;
	264	{
	265	register char *cq;
	266	register struct cblock *bp;
	267	register s, acc;
	268
	269	if (cc <= 0)
	270	return(0);
	271	acc = cc;
48575cec BJ	272
48575cec BJ	273
11bd398c BJ	274	s = spl6();
	275	if ((cq = q->c_cl) == NULL \|\| q->c_cc < 0) {
	276	if ((bp = cfreelist) == NULL)
	277	goto out;
	278	cfreelist = bp->c_next;
48575cec	279	cfreecount -= CBSIZE;
11bd398c BJ	280	bp->c_next = NULL;
	281	q->c_cf = cq = bp->c_info;
	282	}
	283
	284	while (cc) {
	285	if (((int)cq & CROUND) == 0) {
	286	bp = (struct cblock *) cq - 1;
	287	if ((bp->c_next = cfreelist) == NULL)
	288	goto out;
	289	bp = bp->c_next;
	290	cfreelist = bp->c_next;
48575cec	291	cfreecount -= CBSIZE;
11bd398c BJ	292	bp->c_next = NULL;
	293	cq = bp->c_info;
	294	}
	295	cq++ = cp++;
	296	cc--;
	297	}
	298	out:
	299	q->c_cl = cq;
	300	q->c_cc += acc-cc;
	301	splx(s);
	302	return(cc);
	303	}
	304
48575cec BJ	305	char *
	306	wb_to_q(cp, cc, q)
	307	register char *cp;
	308	register struct clist *q;
	309	register cc;
	310	{
	311	char *f;
	312	register s;
	313
	314	s = spl6();
	315	while (cc > cfreecount) {
	316	cwaiting = 1;
	317	sleep(&cwaiting, TTOPRI);
	318	}
	319	if (q->c_cc==0) {
	320	b_to_q(cp, cc, q);
	321	f = q->c_cf;
	322	} else {
	323	(void) putc(*cp++, q);
	324	f = q->c_cl;
	325	f--;
	326	b_to_q(cp, --cc, q);
	327	}
	328	splx(s);
	329	return(f);
	330	}
	331
b8f09f36 BJ	332	/*
	333	* Given a non-NULL pointter into the list (like c_cf which
	334	* always points to a real character if non-NULL) return the pointer
	335	* to the next character in the list or return NULL if no more chars.
	336	*
	337	* Callers must not allow getc's to happen between nextc's so that the
	338	* pointer becomes invalid. Note that interrupts are NOT masked.
	339	*/
	340	char *
	341	nextc(p, cp)
	342	register struct clist *p;
	343	register char *cp;
	344	{
	345
	346	if (p->c_cc && ++cp != p->c_cl) {
	347	if (((int)cp & CROUND) == 0)
	348	return (((struct cblock *)cp)[-1].c_next->c_info);
	349	return (cp);
	350	}
	351	return (0);
	352	}
	353
	354	/*
	355	* Remove the last character in the list and return it.
	356	*/
	357	unputc(p)
	358	register struct clist *p;
	359	{
	360	register struct cblock *bp;
	361	register int c, s;
	362	struct cblock *obp;
	363
	364	s = spl6();
	365	if (p->c_cc <= 0)
	366	c = -1;
	367	else {
	368	c = *--p->c_cl;
	369	if (--p->c_cc <= 0) {
	370	bp = (struct cblock *)p->c_cl;
	371	bp = (struct cblock *)((int)bp & ~CROUND);
	372	p->c_cl = p->c_cf = NULL;
	373	bp->c_next = cfreelist;
	374	cfreelist = bp;
48575cec	375	cfreecount += CBSIZE;
b8f09f36 BJ	376	} else if (((int)p->c_cl & CROUND) == sizeof(bp->c_next)) {
	377	p->c_cl = (char *)((int)p->c_cl & ~CROUND);
	378	bp = (struct cblock *)p->c_cf;
	379	bp = (struct cblock *)((int)bp & ~CROUND);
	380	while (bp->c_next != (struct cblock *)p->c_cl)
	381	bp = bp->c_next;
	382	obp = bp;
	383	p->c_cl = (char *)(bp + 1);
	384	bp = bp->c_next;
	385	bp->c_next = cfreelist;
	386	cfreelist = bp;
48575cec	387	cfreecount += CBSIZE;
b8f09f36 BJ	388	obp->c_next = NULL;
	389	}
	390	}
	391	splx(s);
	392	return (c);
	393	}
	394
	395	/*
	396	* Put the chars in the from que
	397	* on the end of the to que.
	398	*
	399	* SHOULD JUST USE q_to_b AND THEN b_to_q HERE.
	400	*/
	401	catq(from, to)
	402	struct clist from, to;
	403	{
	404	register c;
	405
	406	while ((c = getc(from)) >= 0)
	407	(void) putc(c, to);
	408	}
	409
11bd398c BJ	410	/*
	411	* integer (2-byte) get/put
	412	* using clists
	413	*/
11bd398c BJ	414	getw(p)
	415	register struct clist *p;
	416	{
	417	register int s;
	418
	419	if (p->c_cc <= 1)
	420	return(-1);
	421	s = getc(p);
	422	return(s \| (getc(p)<<8));
	423	}
48575cec	424
11bd398c BJ	425	putw(c, p)
	426	register struct clist *p;
	427	{
	428	register s;
	429
	430	s = spl6();
	431	if (cfreelist==NULL) {
	432	splx(s);
	433	return(-1);
	434	}
81263dba BJ	435	(void) putc(c, p);
81263dba BJ	436	(void) putc(c>>8, p);
11bd398c BJ	437	splx(s);
	438	return(0);
	439	}