Adding tty support files from FREEBSD tree

freebsd/sys/kern/tty_inq.c

@@ -0,0 +1,497 @@
+#include <machine/rtems-bsd-kernel-space.h>
+
+/*-
+ * Copyright (c) 2008 Ed Schouten <ed@FreeBSD.org>
+ * All rights reserved.
+ *
+ * Portions of this software were developed under sponsorship from Snow
+ * B.V., the Netherlands.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <rtems/bsd/sys/param.h>
+#include <sys/kernel.h>
+#include <rtems/bsd/sys/lock.h>
+#include <sys/queue.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
+#include <sys/tty.h>
+#include <sys/uio.h>
+
+#include <vm/uma.h>
+
+/*
+ * TTY input queue buffering.
+ *
+ * Unlike the output queue, the input queue has more features that are
+ * needed to properly implement various features offered by the TTY
+ * interface:
+ *
+ * - Data can be removed from the tail of the queue, which is used to
+ *   implement backspace.
+ * - Once in a while, input has to be `canonicalized'. When ICANON is
+ *   turned on, this will be done after a CR has been inserted.
+ *   Otherwise, it should be done after any character has been inserted.
+ * - The input queue can store one bit per byte, called the quoting bit.
+ *   This bit is used by TTYDISC to make backspace work on quoted
+ *   characters.
+ *
+ * In most cases, there is probably less input than output, so unlike
+ * the outq, we'll stick to 128 byte blocks here.
+ */
+
+static int ttyinq_flush_secure = 1;
+SYSCTL_INT(_kern, OID_AUTO, tty_inq_flush_secure, CTLFLAG_RW,
+	&ttyinq_flush_secure, 0, "Zero buffers while flushing");
+
+#define TTYINQ_QUOTESIZE	(TTYINQ_DATASIZE / BMSIZE)
+#define BMSIZE			32
+#define GETBIT(tib,boff) \
+	((tib)->tib_quotes[(boff) / BMSIZE] & (1 << ((boff) % BMSIZE)))
+#define SETBIT(tib,boff) \
+	((tib)->tib_quotes[(boff) / BMSIZE] |= (1 << ((boff) % BMSIZE)))
+#define CLRBIT(tib,boff) \
+	((tib)->tib_quotes[(boff) / BMSIZE] &= ~(1 << ((boff) % BMSIZE)))
+
+struct ttyinq_block {
+	struct ttyinq_block	*tib_prev;
+	struct ttyinq_block	*tib_next;
+	uint32_t		tib_quotes[TTYINQ_QUOTESIZE];
+	char			tib_data[TTYINQ_DATASIZE];
+};
+
+static uma_zone_t ttyinq_zone;
+
+#define	TTYINQ_INSERT_TAIL(ti, tib) do {				\
+	if (ti->ti_end == 0) {						\
+		tib->tib_prev = NULL;					\
+		tib->tib_next = ti->ti_firstblock;			\
+		ti->ti_firstblock = tib;				\
+	} else {							\
+		tib->tib_prev = ti->ti_lastblock;			\
+		tib->tib_next = ti->ti_lastblock->tib_next;		\
+		ti->ti_lastblock->tib_next = tib;			\
+	}								\
+	if (tib->tib_next != NULL)					\
+		tib->tib_next->tib_prev = tib;				\
+	ti->ti_nblocks++;						\
+} while (0)
+
+#define	TTYINQ_REMOVE_HEAD(ti) do {					\
+	ti->ti_firstblock = ti->ti_firstblock->tib_next;		\
+	if (ti->ti_firstblock != NULL)					\
+		ti->ti_firstblock->tib_prev = NULL;			\
+	ti->ti_nblocks--;						\
+} while (0)
+
+#define	TTYINQ_RECYCLE(ti, tib) do {					\
+	if (ti->ti_quota <= ti->ti_nblocks)				\
+		uma_zfree(ttyinq_zone, tib);				\
+	else								\
+		TTYINQ_INSERT_TAIL(ti, tib);				\
+} while (0)
+
+int
+ttyinq_setsize(struct ttyinq *ti, struct tty *tp, size_t size)
+{
+	struct ttyinq_block *tib;
+
+	ti->ti_quota = howmany(size, TTYINQ_DATASIZE);
+
+	while (ti->ti_quota > ti->ti_nblocks) {
+		/*
+		 * List is getting bigger.
+		 * Add new blocks to the tail of the list.
+		 *
+		 * We must unlock the TTY temporarily, because we need
+		 * to allocate memory. This won't be a problem, because
+		 * in the worst case, another thread ends up here, which
+		 * may cause us to allocate too many blocks, but this
+		 * will be caught by the loop below.
+		 */
+		tty_unlock(tp);
+		tib = uma_zalloc(ttyinq_zone, M_WAITOK);
+		tty_lock(tp);
+
+		if (tty_gone(tp)) {
+			uma_zfree(ttyinq_zone, tib);
+			return (ENXIO);
+		}
+
+		TTYINQ_INSERT_TAIL(ti, tib);
+	}
+	return (0);
+}
+
+void
+ttyinq_free(struct ttyinq *ti)
+{
+	struct ttyinq_block *tib;
+
+	ttyinq_flush(ti);
+	ti->ti_quota = 0;
+
+	while ((tib = ti->ti_firstblock) != NULL) {
+		TTYINQ_REMOVE_HEAD(ti);
+		uma_zfree(ttyinq_zone, tib);
+	}
+
+	MPASS(ti->ti_nblocks == 0);
+}
+
+int
+ttyinq_read_uio(struct ttyinq *ti, struct tty *tp, struct uio *uio,
+    size_t rlen, size_t flen)
+{
+
+	MPASS(rlen <= uio->uio_resid);
+
+	while (rlen > 0) {
+		int error;
+		struct ttyinq_block *tib;
+		size_t cbegin, cend, clen;
+
+		/* See if there still is data. */
+		if (ti->ti_begin == ti->ti_linestart)
+			return (0);
+		tib = ti->ti_firstblock;
+		if (tib == NULL)
+			return (0);
+
+		/*
+		 * The end address should be the lowest of these three:
+		 * - The write pointer
+		 * - The blocksize - we can't read beyond the block
+		 * - The end address if we could perform the full read
+		 */
+		cbegin = ti->ti_begin;
+		cend = MIN(MIN(ti->ti_linestart, ti->ti_begin + rlen),
+		    TTYINQ_DATASIZE);
+		clen = cend - cbegin;
+		MPASS(clen >= flen);
+		rlen -= clen;
+
+		/*
+		 * We can prevent buffering in some cases:
+		 * - We need to read the block until the end.
+		 * - We don't need to read the block until the end, but
+		 *   there is no data beyond it, which allows us to move
+		 *   the write pointer to a new block.
+		 */
+		if (cend == TTYINQ_DATASIZE || cend == ti->ti_end) {
+			/*
+			 * Fast path: zero copy. Remove the first block,
+			 * so we can unlock the TTY temporarily.
+			 */
+			TTYINQ_REMOVE_HEAD(ti);
+			ti->ti_begin = 0;
+
+			/*
+			 * Because we remove the first block, we must
+			 * fix up the block offsets.
+			 */
+#define CORRECT_BLOCK(t) do {			\
+	if (t <= TTYINQ_DATASIZE)		\
+		t = 0;				\
+	else					\
+		t -= TTYINQ_DATASIZE;		\
+} while (0)
+			CORRECT_BLOCK(ti->ti_linestart);
+			CORRECT_BLOCK(ti->ti_reprint);
+			CORRECT_BLOCK(ti->ti_end);
+#undef CORRECT_BLOCK
+
+			/*
+			 * Temporary unlock and copy the data to
+			 * userspace. We may need to flush trailing
+			 * bytes, like EOF characters.
+			 */
+			tty_unlock(tp);
+			error = uiomove(tib->tib_data + cbegin,
+			    clen - flen, uio);
+			tty_lock(tp);
+
+			/* Block can now be readded to the list. */
+			TTYINQ_RECYCLE(ti, tib);
+		} else {
+			char ob[TTYINQ_DATASIZE - 1];
+
+			/*
+			 * Slow path: store data in a temporary buffer.
+			 */
+			memcpy(ob, tib->tib_data + cbegin, clen - flen);
+			ti->ti_begin += clen;
+			MPASS(ti->ti_begin < TTYINQ_DATASIZE);
+
+			/* Temporary unlock and copy the data to userspace. */
+			tty_unlock(tp);
+			error = uiomove(ob, clen - flen, uio);
+			tty_lock(tp);
+		}
+
+		if (error != 0)
+			return (error);
+		if (tty_gone(tp))
+			return (ENXIO);
+	}
+
+	return (0);
+}
+
+static __inline void
+ttyinq_set_quotes(struct ttyinq_block *tib, size_t offset,
+    size_t length, int value)
+{
+
+	if (value) {
+		/* Set the bits. */
+		for (; length > 0; length--, offset++)
+			SETBIT(tib, offset);
+	} else {
+		/* Unset the bits. */
+		for (; length > 0; length--, offset++)
+			CLRBIT(tib, offset);
+	}
+}
+
+size_t
+ttyinq_write(struct ttyinq *ti, const void *buf, size_t nbytes, int quote)
+{
+	const char *cbuf = buf;
+	struct ttyinq_block *tib;
+	unsigned int boff;
+	size_t l;
+
+	while (nbytes > 0) {
+		boff = ti->ti_end % TTYINQ_DATASIZE;
+
+		if (ti->ti_end == 0) {
+			/* First time we're being used or drained. */
+			MPASS(ti->ti_begin == 0);
+			tib = ti->ti_firstblock;
+			if (tib == NULL) {
+				/* Queue has no blocks. */
+				break;
+			}
+			ti->ti_lastblock = tib;
+		} else if (boff == 0) {
+			/* We reached the end of this block on last write. */
+			tib = ti->ti_lastblock->tib_next;
+			if (tib == NULL) {
+				/* We've reached the watermark. */
+				break;
+			}
+			ti->ti_lastblock = tib;
+		} else {
+			tib = ti->ti_lastblock;
+		}
+
+		/* Don't copy more than was requested. */
+		l = MIN(nbytes, TTYINQ_DATASIZE - boff);
+		MPASS(l > 0);
+		memcpy(tib->tib_data + boff, cbuf, l);
+
+		/* Set the quoting bits for the proper region. */
+		ttyinq_set_quotes(tib, boff, l, quote);
+
+		cbuf += l;
+		nbytes -= l;
+		ti->ti_end += l;
+	}
+
+	return (cbuf - (const char *)buf);
+}
+
+int
+ttyinq_write_nofrag(struct ttyinq *ti, const void *buf, size_t nbytes, int quote)
+{
+	size_t ret;
+
+	if (ttyinq_bytesleft(ti) < nbytes)
+		return (-1);
+
+	/* We should always be able to write it back. */
+	ret = ttyinq_write(ti, buf, nbytes, quote);
+	MPASS(ret == nbytes);
+
+	return (0);
+}
+
+void
+ttyinq_canonicalize(struct ttyinq *ti)
+{
+
+	ti->ti_linestart = ti->ti_reprint = ti->ti_end;
+	ti->ti_startblock = ti->ti_reprintblock = ti->ti_lastblock;
+}
+
+size_t
+ttyinq_findchar(struct ttyinq *ti, const char *breakc, size_t maxlen,
+    char *lastc)
+{
+	struct ttyinq_block *tib = ti->ti_firstblock;
+	unsigned int boff = ti->ti_begin;
+	unsigned int bend = MIN(MIN(TTYINQ_DATASIZE, ti->ti_linestart),
+	    ti->ti_begin + maxlen);
+
+	MPASS(maxlen > 0);
+
+	if (tib == NULL)
+		return (0);
+
+	while (boff < bend) {
+		if (strchr(breakc, tib->tib_data[boff]) && !GETBIT(tib, boff)) {
+			*lastc = tib->tib_data[boff];
+			return (boff - ti->ti_begin + 1);
+		}
+		boff++;
+	}
+
+	/* Not found - just process the entire block. */
+	return (bend - ti->ti_begin);
+}
+
+void
+ttyinq_flush(struct ttyinq *ti)
+{
+	struct ttyinq_block *tib;
+
+	ti->ti_begin = 0;
+	ti->ti_linestart = 0;
+	ti->ti_reprint = 0;
+	ti->ti_end = 0;
+
+	/* Zero all data in the input queue to get rid of passwords. */
+	if (ttyinq_flush_secure) {
+		for (tib = ti->ti_firstblock; tib != NULL; tib = tib->tib_next)
+			bzero(&tib->tib_data, sizeof tib->tib_data);
+	}
+}
+
+int
+ttyinq_peekchar(struct ttyinq *ti, char *c, int *quote)
+{
+	unsigned int boff;
+	struct ttyinq_block *tib = ti->ti_lastblock;
+
+	if (ti->ti_linestart == ti->ti_end)
+		return (-1);
+
+	MPASS(ti->ti_end > 0);
+	boff = (ti->ti_end - 1) % TTYINQ_DATASIZE;
+
+	*c = tib->tib_data[boff];
+	*quote = GETBIT(tib, boff);
+
+	return (0);
+}
+
+void
+ttyinq_unputchar(struct ttyinq *ti)
+{
+
+	MPASS(ti->ti_linestart < ti->ti_end);
+
+	if (--ti->ti_end % TTYINQ_DATASIZE == 0) {
+		/* Roll back to the previous block. */
+		ti->ti_lastblock = ti->ti_lastblock->tib_prev;
+		/*
+		 * This can only fail if we are unputchar()'ing the
+		 * first character in the queue.
+		 */
+		MPASS((ti->ti_lastblock == NULL) == (ti->ti_end == 0));
+	}
+}
+
+void
+ttyinq_reprintpos_set(struct ttyinq *ti)
+{
+
+	ti->ti_reprint = ti->ti_end;
+	ti->ti_reprintblock = ti->ti_lastblock;
+}
+
+void
+ttyinq_reprintpos_reset(struct ttyinq *ti)
+{
+
+	ti->ti_reprint = ti->ti_linestart;
+	ti->ti_reprintblock = ti->ti_startblock;
+}
+
+static void
+ttyinq_line_iterate(struct ttyinq *ti,
+    ttyinq_line_iterator_t *iterator, void *data,
+    unsigned int offset, struct ttyinq_block *tib)
+{
+	unsigned int boff;
+
+	/* Use the proper block when we're at the queue head. */
+	if (offset == 0)
+		tib = ti->ti_firstblock;
+
+	/* Iterate all characters and call the iterator function. */
+	for (; offset < ti->ti_end; offset++) {
+		boff = offset % TTYINQ_DATASIZE;
+		MPASS(tib != NULL);
+
+		/* Call back the iterator function. */
+		iterator(data, tib->tib_data[boff], GETBIT(tib, boff));
+
+		/* Last byte iterated - go to the next block. */
+		if (boff == TTYINQ_DATASIZE - 1)
+			tib = tib->tib_next;
+		MPASS(tib != NULL);
+	}
+}
+
+void
+ttyinq_line_iterate_from_linestart(struct ttyinq *ti,
+    ttyinq_line_iterator_t *iterator, void *data)
+{
+
+	ttyinq_line_iterate(ti, iterator, data,
+	    ti->ti_linestart, ti->ti_startblock);
+}
+
+void
+ttyinq_line_iterate_from_reprintpos(struct ttyinq *ti,
+    ttyinq_line_iterator_t *iterator, void *data)
+{
+
+	ttyinq_line_iterate(ti, iterator, data,
+	    ti->ti_reprint, ti->ti_reprintblock);
+}
+
+static void
+ttyinq_startup(void *dummy)
+{
+
+	ttyinq_zone = uma_zcreate("ttyinq", sizeof(struct ttyinq_block),
+	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
+}
+
+SYSINIT(ttyinq, SI_SUB_DRIVERS, SI_ORDER_FIRST, ttyinq_startup, NULL);

freebsd/sys/kern/tty_outq.c

@@ -0,0 +1,347 @@
+#include <machine/rtems-bsd-kernel-space.h>
+
+/*-
+ * Copyright (c) 2008 Ed Schouten <ed@FreeBSD.org>
+ * All rights reserved.
+ *
+ * Portions of this software were developed under sponsorship from Snow
+ * B.V., the Netherlands.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <rtems/bsd/sys/param.h>
+#include <sys/kernel.h>
+#include <rtems/bsd/sys/lock.h>
+#include <sys/queue.h>
+#include <sys/systm.h>
+#include <sys/tty.h>
+#include <sys/uio.h>
+
+#include <vm/uma.h>
+
+/*
+ * TTY output queue buffering.
+ *
+ * The previous design of the TTY layer offered the so-called clists.
+ * These clists were used for both the input queues and the output
+ * queue. We don't use certain features on the output side, like quoting
+ * bits for parity marking and such. This mechanism is similar to the
+ * old clists, but only contains the features we need to buffer the
+ * output.
+ */
+
+struct ttyoutq_block {
+	struct ttyoutq_block	*tob_next;
+	char			tob_data[TTYOUTQ_DATASIZE];
+};
+
+static uma_zone_t ttyoutq_zone;
+
+#define	TTYOUTQ_INSERT_TAIL(to, tob) do {				\
+	if (to->to_end == 0) {						\
+		tob->tob_next = to->to_firstblock;			\
+		to->to_firstblock = tob;				\
+	} else {							\
+		tob->tob_next = to->to_lastblock->tob_next;		\
+		to->to_lastblock->tob_next = tob;			\
+	}								\
+	to->to_nblocks++;						\
+} while (0)
+
+#define	TTYOUTQ_REMOVE_HEAD(to) do {					\
+	to->to_firstblock = to->to_firstblock->tob_next;		\
+	to->to_nblocks--;						\
+} while (0)
+
+#define	TTYOUTQ_RECYCLE(to, tob) do {					\
+	if (to->to_quota <= to->to_nblocks)				\
+		uma_zfree(ttyoutq_zone, tob);				\
+	else								\
+		TTYOUTQ_INSERT_TAIL(to, tob);				\
+} while(0)
+
+void
+ttyoutq_flush(struct ttyoutq *to)
+{
+
+	to->to_begin = 0;
+	to->to_end = 0;
+}
+
+int
+ttyoutq_setsize(struct ttyoutq *to, struct tty *tp, size_t size)
+{
+	struct ttyoutq_block *tob;
+
+	to->to_quota = howmany(size, TTYOUTQ_DATASIZE);
+
+	while (to->to_quota > to->to_nblocks) {
+		/*
+		 * List is getting bigger.
+		 * Add new blocks to the tail of the list.
+		 *
+		 * We must unlock the TTY temporarily, because we need
+		 * to allocate memory. This won't be a problem, because
+		 * in the worst case, another thread ends up here, which
+		 * may cause us to allocate too many blocks, but this
+		 * will be caught by the loop below.
+		 */
+		tty_unlock(tp);
+		tob = uma_zalloc(ttyoutq_zone, M_WAITOK);
+		tty_lock(tp);
+
+		if (tty_gone(tp)) {
+			uma_zfree(ttyoutq_zone, tob);
+			return (ENXIO);
+		}
+
+		TTYOUTQ_INSERT_TAIL(to, tob);
+	}
+	return (0);
+}
+
+void
+ttyoutq_free(struct ttyoutq *to)
+{
+	struct ttyoutq_block *tob;
+
+	ttyoutq_flush(to);
+	to->to_quota = 0;
+
+	while ((tob = to->to_firstblock) != NULL) {
+		TTYOUTQ_REMOVE_HEAD(to);
+		uma_zfree(ttyoutq_zone, tob);
+	}
+
+	MPASS(to->to_nblocks == 0);
+}
+
+size_t
+ttyoutq_read(struct ttyoutq *to, void *buf, size_t len)
+{
+	char *cbuf = buf;
+
+	while (len > 0) {
+		struct ttyoutq_block *tob;
+		size_t cbegin, cend, clen;
+
+		/* See if there still is data. */
+		if (to->to_begin == to->to_end)
+			break;
+		tob = to->to_firstblock;
+		if (tob == NULL)
+			break;
+
+		/*
+		 * The end address should be the lowest of these three:
+		 * - The write pointer
+		 * - The blocksize - we can't read beyond the block
+		 * - The end address if we could perform the full read
+		 */
+		cbegin = to->to_begin;
+		cend = MIN(MIN(to->to_end, to->to_begin + len),
+		    TTYOUTQ_DATASIZE);
+		clen = cend - cbegin;
+
+		/* Copy the data out of the buffers. */
+		memcpy(cbuf, tob->tob_data + cbegin, clen);
+		cbuf += clen;
+		len -= clen;
+
+		if (cend == to->to_end) {
+			/* Read the complete queue. */
+			to->to_begin = 0;
+			to->to_end = 0;
+		} else if (cend == TTYOUTQ_DATASIZE) {
+			/* Read the block until the end. */
+			TTYOUTQ_REMOVE_HEAD(to);
+			to->to_begin = 0;
+			to->to_end -= TTYOUTQ_DATASIZE;
+			TTYOUTQ_RECYCLE(to, tob);
+		} else {
+			/* Read the block partially. */
+			to->to_begin += clen;
+		}
+	}
+
+	return (cbuf - (char *)buf);
+}
+
+/*
+ * An optimized version of ttyoutq_read() which can be used in pseudo
+ * TTY drivers to directly copy data from the outq to userspace, instead
+ * of buffering it.
+ *
+ * We can only copy data directly if we need to read the entire block
+ * back to the user, because we temporarily remove the block from the
+ * queue. Otherwise we need to copy it to a temporary buffer first, to
+ * make sure data remains in the correct order.
+ */
+int
+ttyoutq_read_uio(struct ttyoutq *to, struct tty *tp, struct uio *uio)
+{
+
+	while (uio->uio_resid > 0) {
+		int error;
+		struct ttyoutq_block *tob;
+		size_t cbegin, cend, clen;
+
+		/* See if there still is data. */
+		if (to->to_begin == to->to_end)
+			return (0);
+		tob = to->to_firstblock;
+		if (tob == NULL)
+			return (0);
+
+		/*
+		 * The end address should be the lowest of these three:
+		 * - The write pointer
+		 * - The blocksize - we can't read beyond the block
+		 * - The end address if we could perform the full read
+		 */
+		cbegin = to->to_begin;
+		cend = MIN(MIN(to->to_end, to->to_begin + uio->uio_resid),
+		    TTYOUTQ_DATASIZE);
+		clen = cend - cbegin;
+
+		/*
+		 * We can prevent buffering in some cases:
+		 * - We need to read the block until the end.
+		 * - We don't need to read the block until the end, but
+		 *   there is no data beyond it, which allows us to move
+		 *   the write pointer to a new block.
+		 */
+		if (cend == TTYOUTQ_DATASIZE || cend == to->to_end) {
+			/*
+			 * Fast path: zero copy. Remove the first block,
+			 * so we can unlock the TTY temporarily.
+			 */
+			TTYOUTQ_REMOVE_HEAD(to);
+			to->to_begin = 0;
+			if (to->to_end <= TTYOUTQ_DATASIZE)
+				to->to_end = 0;
+			else
+				to->to_end -= TTYOUTQ_DATASIZE;
+
+			/* Temporary unlock and copy the data to userspace. */
+			tty_unlock(tp);
+			error = uiomove(tob->tob_data + cbegin, clen, uio);
+			tty_lock(tp);
+
+			/* Block can now be readded to the list. */
+			TTYOUTQ_RECYCLE(to, tob);
+		} else {
+			char ob[TTYOUTQ_DATASIZE - 1];
+
+			/*
+			 * Slow path: store data in a temporary buffer.
+			 */
+			memcpy(ob, tob->tob_data + cbegin, clen);
+			to->to_begin += clen;
+			MPASS(to->to_begin < TTYOUTQ_DATASIZE);
+
+			/* Temporary unlock and copy the data to userspace. */
+			tty_unlock(tp);
+			error = uiomove(ob, clen, uio);
+			tty_lock(tp);
+		}
+
+		if (error != 0)
+			return (error);
+	}
+
+	return (0);
+}
+
+size_t
+ttyoutq_write(struct ttyoutq *to, const void *buf, size_t nbytes)
+{
+	const char *cbuf = buf;
+	struct ttyoutq_block *tob;
+	unsigned int boff;
+	size_t l;
+
+	while (nbytes > 0) {
+		boff = to->to_end % TTYOUTQ_DATASIZE;
+
+		if (to->to_end == 0) {
+			/* First time we're being used or drained. */
+			MPASS(to->to_begin == 0);
+			tob = to->to_firstblock;
+			if (tob == NULL) {
+				/* Queue has no blocks. */
+				break;
+			}
+			to->to_lastblock = tob;
+		} else if (boff == 0) {
+			/* We reached the end of this block on last write. */
+			tob = to->to_lastblock->tob_next;
+			if (tob == NULL) {
+				/* We've reached the watermark. */
+				break;
+			}
+			to->to_lastblock = tob;
+		} else {
+			tob = to->to_lastblock;
+		}
+
+		/* Don't copy more than was requested. */
+		l = MIN(nbytes, TTYOUTQ_DATASIZE - boff);
+		MPASS(l > 0);
+		memcpy(tob->tob_data + boff, cbuf, l);
+
+		cbuf += l;
+		nbytes -= l;
+		to->to_end += l;
+	}
+
+	return (cbuf - (const char *)buf);
+}
+
+int
+ttyoutq_write_nofrag(struct ttyoutq *to, const void *buf, size_t nbytes)
+{
+	size_t ret;
+
+	if (ttyoutq_bytesleft(to) < nbytes)
+		return (-1);
+
+	/* We should always be able to write it back. */
+	ret = ttyoutq_write(to, buf, nbytes);
+	MPASS(ret == nbytes);
+
+	return (0);
+}
+
+static void
+ttyoutq_startup(void *dummy)
+{
+
+	ttyoutq_zone = uma_zcreate("ttyoutq", sizeof(struct ttyoutq_block),
+	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
+}
+
+SYSINIT(ttyoutq, SI_SUB_DRIVERS, SI_ORDER_FIRST, ttyoutq_startup, NULL);

freebsd/sys/sys/cons.h

@@ -0,0 +1,144 @@
+/*-
+ * Copyright (c) 1988 University of Utah.
+ * Copyright (c) 1991 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * the Systems Programming Group of the University of Utah Computer
+ * Science Department.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	from: @(#)cons.h	7.2 (Berkeley) 5/9/91
+ * $FreeBSD$
+ */
+
+#ifndef _MACHINE_CONS_H_
+#define	_MACHINE_CONS_H_
+
+struct consdev;
+struct tty;
+
+typedef	void	cn_probe_t(struct consdev *);
+typedef	void	cn_init_t(struct consdev *);
+typedef	void	cn_term_t(struct consdev *);
+typedef	void	cn_grab_t(struct consdev *);
+typedef	void	cn_ungrab_t(struct consdev *);
+typedef	int	cn_getc_t(struct consdev *);
+typedef	void	cn_putc_t(struct consdev *, int);
+
+struct consdev_ops {
+	cn_probe_t	*cn_probe;
+				/* probe hardware and fill in consdev info */
+	cn_init_t	*cn_init;
+				/* turn on as console */
+	cn_term_t	*cn_term;
+				/* turn off as console */
+	cn_getc_t	*cn_getc;
+				/* kernel getchar interface */
+	cn_putc_t	*cn_putc;
+				/* kernel putchar interface */
+	cn_grab_t	*cn_grab;
+				/* grab console for exclusive kernel use */
+	cn_ungrab_t	*cn_ungrab;
+				/* ungrab console */
+};
+
+struct consdev {
+	const struct consdev_ops *cn_ops;
+				/* console device operations. */
+	short	cn_pri;		/* pecking order; the higher the better */
+	void	*cn_arg;	/* drivers method argument */
+	int	cn_flags;	/* capabilities of this console */
+	char	cn_name[SPECNAMELEN + 1];	/* console (device) name */
+};
+
+/* values for cn_pri - reflect our policy for console selection */
+#define	CN_DEAD		0	/* device doesn't exist */
+#define CN_LOW		1	/* device is a last restort only */
+#define CN_NORMAL	2	/* device exists but is nothing special */
+#define CN_INTERNAL	3	/* "internal" bit-mapped display */
+#define CN_REMOTE	4	/* serial interface with remote bit set */
+
+/* Values for cn_flags. */
+#define	CN_FLAG_NODEBUG	0x00000001	/* Not supported with debugger. */
+#define	CN_FLAG_NOAVAIL	0x00000002	/* Temporarily not available. */
+
+/* Visibility of characters in cngets() */
+#define	GETS_NOECHO	0	/* Disable echoing of characters. */
+#define	GETS_ECHO	1	/* Enable echoing of characters. */
+#define	GETS_ECHOPASS	2	/* Print a * for every character. */
+
+#ifdef _KERNEL
+
+extern	struct msgbuf consmsgbuf; /* Message buffer for constty. */
+extern	struct tty *constty;	/* Temporary virtual console. */
+
+#define	CONSOLE_DEVICE(name, ops, arg)					\
+	static struct consdev name = {					\
+		.cn_ops = &ops,						\
+		.cn_arg = (arg),					\
+	};								\
+	DATA_SET(cons_set, name)
+
+#define	CONSOLE_DRIVER(name)						\
+	static const struct consdev_ops name##_consdev_ops = {		\
+		.cn_probe = name##_cnprobe,				\
+		.cn_init = name##_cninit,				\
+		.cn_term = name##_cnterm,				\
+		.cn_getc = name##_cngetc,				\
+		.cn_putc = name##_cnputc,				\
+		.cn_grab = name##_cngrab,				\
+		.cn_ungrab = name##_cnungrab,				\
+	};								\
+	CONSOLE_DEVICE(name##_consdev, name##_consdev_ops, NULL)
+
+/* Other kernel entry points. */
+void	cninit(void);
+void	cninit_finish(void);
+int	cnadd(struct consdev *);
+void	cnavailable(struct consdev *, int);
+void	cnremove(struct consdev *);
+void	cnselect(struct consdev *);
+void	cngrab(void);
+void	cnungrab(void);
+int	cncheckc(void);
+int	cngetc(void);
+void	cngets(char *, size_t, int);
+void	cnputc(int);
+void	cnputs(char *);
+int	cnunavailable(void);
+void	constty_set(struct tty *tp);
+void	constty_clear(void);
+
+/* sc(4) / vt(4) coexistence shim */
+#define	VTY_SC 0x01
+#define	VTY_VT 0x02
+int	vty_enabled(unsigned int);
+void	vty_set_preferred(unsigned int);
+
+#endif /* _KERNEL */
+
+#endif /* !_MACHINE_CONS_H_ */

freebsd/sys/sys/serial.h

@@ -0,0 +1,92 @@
+/*-
+ * Copyright (c) 2004 Poul-Henning Kamp
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file contains definitions which pertain to serial ports as such,
+ * (both async and sync), but which do not necessarily have anything to
+ * do with tty processing.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _SYS_SERIAL_H_
+#define	_SYS_SERIAL_H_
+
+
+/*
+ * Indentification of modem control signals.  These definitions match
+ * the TIOCMGET definitions in <sys/ttycom.h> shifted a bit down, and
+ * that identity is enforced with CTASSERT at the bottom of kern/tty.c
+ * Both the modem bits and delta bits must fit in 16 bit.
+ */
+#define	SER_DTR		0x0001		/* data terminal ready */
+#define	SER_RTS		0x0002		/* request to send */
+#define	SER_STX		0x0004		/* secondary transmit */
+#define	SER_SRX		0x0008		/* secondary receive */
+#define	SER_CTS		0x0010		/* clear to send */
+#define	SER_DCD		0x0020		/* data carrier detect */
+#define	SER_RI	 	0x0040		/* ring indicate */
+#define	SER_DSR		0x0080		/* data set ready */
+
+#define	SER_MASK_STATE	0x00ff
+
+/* Delta bits, used to indicate which signals should/was affected */
+#define	SER_DELTA(x)	((x) << 8)
+
+#define	SER_DDTR	SER_DELTA(SER_DTR)
+#define	SER_DRTS	SER_DELTA(SER_RTS)
+#define	SER_DSTX	SER_DELTA(SER_STX)
+#define	SER_DSRX	SER_DELTA(SER_SRX)
+#define	SER_DCTS	SER_DELTA(SER_CTS)
+#define	SER_DDCD	SER_DELTA(SER_DCD)
+#define	SER_DRI		SER_DELTA(SER_RI)
+#define	SER_DDSR	SER_DELTA(SER_DSR)
+
+#define	SER_MASK_DELTA	SER_DELTA(SER_MASK_STATE)
+
+#ifdef _KERNEL
+/*
+ * Specification of interrupt sources typical for serial ports. These are
+ * useful when some umbrella driver like scc(4) has enough knowledge of
+ * the hardware to obtain the set of pending interrupts but does not itself
+ * handle the interrupt. Each interrupt source can be given an interrupt
+ * resource for which inferior drivers can install handlers. The lower 16
+ * bits are kept free for the signals above.
+ */
+#define	SER_INT_OVERRUN	0x010000
+#define	SER_INT_BREAK	0x020000
+#define	SER_INT_RXREADY	0x040000
+#define	SER_INT_SIGCHG	0x080000
+#define	SER_INT_TXIDLE	0x100000
+
+#define	SER_INT_MASK	0xff0000
+#define	SER_INT_SIGMASK	(SER_MASK_DELTA | SER_MASK_STATE)
+
+#ifndef LOCORE
+typedef int serdev_intr_t(void*);
+#endif
+
+#endif	/* _KERNEL */
+
+#endif /* !_SYS_SERIAL_H_ */