#!/usr/sbin/dtrace -Cs
/*
 * $Id: termrw.d 759 2012-10-04 06:12:44Z elkner $
 *
 * License: CDDL 1.0   (see http://opensource.org/licenses/cddl-1.0)
 * Copyright (c) 2012 by Jens Elkner. All rights reserved.
 */

/* Use: termrw.d tty [what]
    tty   .. full path of the tty to trace (e.g. /dev/pts/6)
    what  .. If omitted it is equivalent to 'rw'. Otherwise a string of at most
			 3 characters, with:
			 'r' .. to trace reads
			 'w' .. to trace writes
			 'i' .. to trace ioctls
 */
#pragma D option quiet
#pragma D option defaultargs
#pragma D option rawbytes

/*
	According to termstack.d terminal input results into specfs_read,
	terminal output to specfs_write, signaling into specfs_ioctl, which
	are the last functions, where we can easily check the related tty.
	Since tty's usually have not stats flag, we can't simply use
	fsinfo:::{read|write|ioctl}.

	Other alternative is to trace at the stream level, but that would probably
	result into too many negativ hits:
   int strwrite(struct vnode *vp, struct uio *uiop, cred_t *crp)
   int strput(struct stdata *stp = vp->stp, mblk_t *mctl, struct uio *uiop,
   		ssize_t *iosize, int b_flag, int pri, int flags)
   strmakedata(iosize, uiop, stp, flags, &mp)
   uiomove(bp->b_wptr, size, UIO_WRITE, uiop)
   http://src.iws.cs.ovgu.de/source/xref/illumos-gate/usr/src/uts/common/sys/strsubr.h#167
 */
string fn[3];
string tty;

#define CHECK(str, len, c, pname) \
	(len > 2 && (str[0] == c || str[1] == c || str[2] == c)) ? pname : \
	(len > 1 && (str[0] == c || str[1] == c)) ? pname : \
	(len > 0 && str[0] == c ) ? pname : ""

/* see comment in BEGIN */
#define _KERNEL
#include <sys/time.h>
#include <sys/filio.h>
#include <sys/consdev.h>
#include <sys/stropts.h>
#include <sys/vt.h>
#include <sys/devctl.h>
#include <sys/eucioctl.h>
#include <sys/devpoll.h>
#include <sys/termios.h>
#include <sys/stermio.h>
#include <sys/csiioctl.h>
#include <sys/termiox.h>

#define IOCTL_VAR(a, b, c, d)	ioctl2name[(b)] = a

dtrace:::BEGIN
{
    MYNAME = basename($$0);
	tty = $$1 == NULL ? "<none>" : $$1;
	this->what = $$2 == NULL ? "rw" : $$2;
	this->len = strlen(this->what);
	fn[0] = CHECK(this->what, this->len, 'r', "spec_write");
	fn[1] = CHECK(this->what, this->len, 'w', "spec_read");
	fn[2] = CHECK(this->what, this->len, 'i', "spec_ioctl");
	this->ws = strjoin(strjoin((fn[0] == NULL ? "" : "r"),
		(fn[1] == NULL ? "" : "w")), (fn[2] == NULL ? "" : "i"));
	printf("Tracing %s on %s - hit ^C to stop\n", this->ws, tty);

	/* To create a more or less dumb map for ioctl cmd -> name the following
	   commands might be used:

	cat >/tmp/ioctl.awk<<EOF
BEGIN {
    ULEN = length("/usr/include/") + 1;
}
/.h:#define/ {
    HFILE=substr(\$1,ULEN,index(\$1,":")-ULEN);
    INCFILES[HFILE] = HFILE; DEF = \$2;
	if (match(\$3, "[(]'[A-Za-z]'") > 0) {
		P = substr(\$3, RSTART + RLENGTH - 3, 3);
		M = M "\n\tIOCTL_VAR(\"" DEF "\", " DEF ", \"" P "\", " P " << 8 );";
    } else if (match(\$3, "[_A-Za-z]+") > 0) {
        P = substr(\$3, RSTART, RLENGTH);
        M = M "\n\tIOCTL_VAR(\"" DEF "\", " DEF ", \"" P "\", " P ");";
    } else {
        print("No match: 2=" \$2 "\t3=" \$3);
    }
}
END {
    print("#define _KERNEL\n\n#include <sys/time.h>");
    for (I in INCFILES) {
        print("#include <" INCFILES[I]">");
    }
    print(M);
}
EOF

	egrep "\(((CSI_IOC|_CONSIOC|DEVCTL_IOC|DPIOC|EUC_IOC|STR|_TIOC|tIOC|XIOC|VTIOC) ?\|)|'[fX]'[,<]" /usr/include/sys/*.h | egrep -v '/(ttold|termio).h:' | \
	/usr/xpg4/bin/grep -v '#define[[:space:]]XIOC[[:space:]]' | \
	nawk -f /tmp/ioctl.awk

	 */
	IOCTL_VAR("CONSOPENPOLLEDIO", CONSOPENPOLLEDIO, "_CONSIOC", _CONSIOC);
	IOCTL_VAR("CONSGETABORTENABLE", CONSGETABORTENABLE, "_CONSIOC", _CONSIOC);
	IOCTL_VAR("CONSSETABORTENABLE", CONSSETABORTENABLE, "_CONSIOC", _CONSIOC);
	IOCTL_VAR("CONSCLOSEPOLLEDIO", CONSCLOSEPOLLEDIO, "_CONSIOC", _CONSIOC);
	IOCTL_VAR("CONSSETKBDTYPE", CONSSETKBDTYPE, "_CONSIOC", _CONSIOC);
	IOCTL_VAR("CSDATA_SET", CSDATA_SET, "CSI_IOC", CSI_IOC);
	IOCTL_VAR("CSDATA_GET", CSDATA_GET, "CSI_IOC", CSI_IOC);
	IOCTL_VAR("DEVCTL_IOC_MAX", DEVCTL_IOC_MAX, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_BUS_QUIESCE", DEVCTL_BUS_QUIESCE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_BUS_UNQUIESCE", DEVCTL_BUS_UNQUIESCE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_BUS_RESETALL", DEVCTL_BUS_RESETALL, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_BUS_RESET", DEVCTL_BUS_RESET, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_BUS_GETSTATE", DEVCTL_BUS_GETSTATE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_DEVICE_ONLINE", DEVCTL_DEVICE_ONLINE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_DEVICE_OFFLINE", DEVCTL_DEVICE_OFFLINE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_DEVICE_GETSTATE", DEVCTL_DEVICE_GETSTATE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_DEVICE_RESET", DEVCTL_DEVICE_RESET, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_BUS_CONFIGURE", DEVCTL_BUS_CONFIGURE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_BUS_UNCONFIGURE", DEVCTL_BUS_UNCONFIGURE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_DEVICE_REMOVE", DEVCTL_DEVICE_REMOVE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_AP_CONNECT", DEVCTL_AP_CONNECT, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_AP_DISCONNECT", DEVCTL_AP_DISCONNECT, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_AP_INSERT", DEVCTL_AP_INSERT, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_AP_REMOVE", DEVCTL_AP_REMOVE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_AP_CONFIGURE", DEVCTL_AP_CONFIGURE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_AP_UNCONFIGURE", DEVCTL_AP_UNCONFIGURE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_AP_GETSTATE", DEVCTL_AP_GETSTATE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_AP_CONTROL", DEVCTL_AP_CONTROL, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_BUS_DEV_CREATE", DEVCTL_BUS_DEV_CREATE, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_BUSY_COMP", DEVCTL_PM_BUSY_COMP, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_IDLE_COMP", DEVCTL_PM_IDLE_COMP, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_RAISE_PWR", DEVCTL_PM_RAISE_PWR, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_LOWER_PWR", DEVCTL_PM_LOWER_PWR, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_CHANGE_PWR_LOW", DEVCTL_PM_CHANGE_PWR_LOW, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_CHANGE_PWR_HIGH", DEVCTL_PM_CHANGE_PWR_HIGH, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_POWER", DEVCTL_PM_POWER, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_PROM_PRINTF", DEVCTL_PM_PROM_PRINTF, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_FAIL_SUSPEND", DEVCTL_PM_FAIL_SUSPEND, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_PWR_HAS_CHANGED_ON_RESUME", DEVCTL_PM_PWR_HAS_CHANGED_ON_RESUME, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_PUP_WITH_PWR_HAS_CHANGED", DEVCTL_PM_PUP_WITH_PWR_HAS_CHANGED, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_BUSY_COMP_TEST", DEVCTL_PM_BUSY_COMP_TEST, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_BUS_STRICT_TEST", DEVCTL_PM_BUS_STRICT_TEST, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_NO_LOWER_POWER", DEVCTL_PM_NO_LOWER_POWER, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_PM_BUS_NO_INVOL", DEVCTL_PM_BUS_NO_INVOL, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_SET_LED", DEVCTL_SET_LED, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_GET_LED", DEVCTL_GET_LED, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DEVCTL_NUM_LEDS", DEVCTL_NUM_LEDS, "DEVCTL_IOC", DEVCTL_IOC);
	IOCTL_VAR("DP_POLL", DP_POLL, "DPIOC", DPIOC);
	IOCTL_VAR("DP_ISPOLLED", DP_ISPOLLED, "DPIOC", DPIOC);
	IOCTL_VAR("EUC_WSET", EUC_WSET, "EUC_IOC", EUC_IOC);
	IOCTL_VAR("EUC_WGET", EUC_WGET, "EUC_IOC", EUC_IOC);
	IOCTL_VAR("EUC_MSAVE", EUC_MSAVE, "EUC_IOC", EUC_IOC);
	IOCTL_VAR("EUC_MREST", EUC_MREST, "EUC_IOC", EUC_IOC);
	IOCTL_VAR("EUC_IXLOFF", EUC_IXLOFF, "EUC_IOC", EUC_IOC);
	IOCTL_VAR("EUC_IXLON", EUC_IXLON, "EUC_IOC", EUC_IOC);
	IOCTL_VAR("EUC_OXLOFF", EUC_OXLOFF, "EUC_IOC", EUC_IOC);
	IOCTL_VAR("EUC_OXLON", EUC_OXLON, "EUC_IOC", EUC_IOC);
	IOCTL_VAR("FIOCLEX", FIOCLEX, "'f'", 'f' << 8 );
	IOCTL_VAR("FIONCLEX", FIONCLEX, "'f'", 'f' << 8 );
	IOCTL_VAR("FIONREAD", FIONREAD, "'f'", 'f' << 8 );
	IOCTL_VAR("FIONBIO", FIONBIO, "'f'", 'f' << 8 );
	IOCTL_VAR("FIOASYNC", FIOASYNC, "'f'", 'f' << 8 );
	IOCTL_VAR("FIOSETOWN", FIOSETOWN, "'f'", 'f' << 8 );
	IOCTL_VAR("FIOGETOWN", FIOGETOWN, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOLFS", _FIOLFS, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOLFSS", _FIOLFSS, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOFFS", _FIOFFS, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOOBSOLETE67", _FIOOBSOLETE67, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOSATIME", _FIOSATIME, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOSDIO", _FIOSDIO, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOGDIO", _FIOGDIO, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOIO", _FIOIO, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOISLOG", _FIOISLOG, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOISLOGOK", _FIOISLOGOK, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOLOGRESET", _FIOLOGRESET, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOISBUSY", _FIOISBUSY, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIODIRECTIO", _FIODIRECTIO, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOTUNE", _FIOTUNE, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOLOGENABLE", _FIOLOGENABLE, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOLOGDISABLE", _FIOLOGDISABLE, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOSNAPSHOTCREATE", _FIOSNAPSHOTCREATE, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOSNAPSHOTDELETE", _FIOSNAPSHOTDELETE, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOGETSUPERBLOCK", _FIOGETSUPERBLOCK, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOGETMAXPHYS", _FIOGETMAXPHYS, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIO_SET_LUFS_DEBUG", _FIO_SET_LUFS_DEBUG, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIO_SET_LUFS_ERROR", _FIO_SET_LUFS_ERROR, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIO_GET_TOP_STATS", _FIO_GET_TOP_STATS, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIOSNAPSHOTCREATE_MULTI", _FIOSNAPSHOTCREATE_MULTI, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIO_SEEK_DATA", _FIO_SEEK_DATA, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIO_SEEK_HOLE", _FIO_SEEK_HOLE, "'f'", 'f' << 8 );
	IOCTL_VAR("_FIO_COMPRESSED", _FIO_COMPRESSED, "'f'", 'f' << 8 );
	IOCTL_VAR("STGET", STGET, "'X'", 'X' << 8 );
	IOCTL_VAR("STSET", STSET, "'X'", 'X' << 8 );
	IOCTL_VAR("STTHROW", STTHROW, "'X'", 'X' << 8 );
	IOCTL_VAR("STWLINE", STWLINE, "'X'", 'X' << 8 );
	IOCTL_VAR("STTSV", STTSV, "'X'", 'X' << 8 );
	IOCTL_VAR("I_NREAD", I_NREAD, "STR", STR);
	IOCTL_VAR("I_PUSH", I_PUSH, "STR", STR);
	IOCTL_VAR("I_POP", I_POP, "STR", STR);
	IOCTL_VAR("I_LOOK", I_LOOK, "STR", STR);
	IOCTL_VAR("I_FLUSH", I_FLUSH, "STR", STR);
	IOCTL_VAR("I_SRDOPT", I_SRDOPT, "STR", STR);
	IOCTL_VAR("I_GRDOPT", I_GRDOPT, "STR", STR);
	IOCTL_VAR("I_STR", I_STR, "STR", STR);
	IOCTL_VAR("I_SETSIG", I_SETSIG, "STR", STR);
	IOCTL_VAR("I_GETSIG", I_GETSIG, "STR", STR);
	IOCTL_VAR("I_FIND", I_FIND, "STR", STR);
	IOCTL_VAR("I_LINK", I_LINK, "STR", STR);
	IOCTL_VAR("I_UNLINK", I_UNLINK, "STR", STR);
	IOCTL_VAR("I_PEEK", I_PEEK, "STR", STR);
	IOCTL_VAR("I_FDINSERT", I_FDINSERT, "STR", STR);
	IOCTL_VAR("I_SENDFD", I_SENDFD, "STR", STR);
	IOCTL_VAR("I_RECVFD", I_RECVFD, "STR", STR);
	IOCTL_VAR("I_E_RECVFD", I_E_RECVFD, "STR", STR);
	IOCTL_VAR("I_RECVFD", I_RECVFD, "STR", STR);
	IOCTL_VAR("I_SWROPT", I_SWROPT, "STR", STR);
	IOCTL_VAR("I_GWROPT", I_GWROPT, "STR", STR);
	IOCTL_VAR("I_LIST", I_LIST, "STR", STR);
	IOCTL_VAR("I_PLINK", I_PLINK, "STR", STR);
	IOCTL_VAR("I_PUNLINK", I_PUNLINK, "STR", STR);
	IOCTL_VAR("I_ANCHOR", I_ANCHOR, "STR", STR);
	IOCTL_VAR("I_FLUSHBAND", I_FLUSHBAND, "STR", STR);
	IOCTL_VAR("I_CKBAND", I_CKBAND, "STR", STR);
	IOCTL_VAR("I_GETBAND", I_GETBAND, "STR", STR);
	IOCTL_VAR("I_ATMARK", I_ATMARK, "STR", STR);
	IOCTL_VAR("I_SETCLTIME", I_SETCLTIME, "STR", STR);
	IOCTL_VAR("I_GETCLTIME", I_GETCLTIME, "STR", STR);
	IOCTL_VAR("I_CANPUT", I_CANPUT, "STR", STR);
	IOCTL_VAR("I_SERROPT", I_SERROPT, "STR", STR);
	IOCTL_VAR("I_GERROPT", I_GERROPT, "STR", STR);
	IOCTL_VAR("I_ESETSIG", I_ESETSIG, "STR", STR);
	IOCTL_VAR("I_EGETSIG", I_EGETSIG, "STR", STR);
	IOCTL_VAR("__I_PUSH_NOCTTY", __I_PUSH_NOCTTY, "STR", STR);
	IOCTL_VAR("_I_MUXID2FD", _I_MUXID2FD, "STR", STR);
	IOCTL_VAR("_I_INSERT", _I_INSERT, "STR", STR);
	IOCTL_VAR("_I_REMOVE", _I_REMOVE, "STR", STR);
	IOCTL_VAR("_I_GETPEERCRED", _I_GETPEERCRED, "STR", STR);
	IOCTL_VAR("_I_PLINK_LH", _I_PLINK_LH, "STR", STR);
	IOCTL_VAR("_I_CMD", _I_CMD, "STR", STR);
	IOCTL_VAR("TCGETA", TCGETA, "_TIOC", _TIOC);
	IOCTL_VAR("TCSETA", TCSETA, "_TIOC", _TIOC);
	IOCTL_VAR("TCSETAW", TCSETAW, "_TIOC", _TIOC);
	IOCTL_VAR("TCSETAF", TCSETAF, "_TIOC", _TIOC);
	IOCTL_VAR("TCSBRK", TCSBRK, "_TIOC", _TIOC);
	IOCTL_VAR("TCXONC", TCXONC, "_TIOC", _TIOC);
	IOCTL_VAR("TCFLSH", TCFLSH, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCKBON", TIOCKBON, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCKBOF", TIOCKBOF, "_TIOC", _TIOC);
	IOCTL_VAR("KBENABLED", KBENABLED, "_TIOC", _TIOC);
	IOCTL_VAR("TCDSET", TCDSET, "_TIOC", _TIOC);
	IOCTL_VAR("RTS_TOG", RTS_TOG, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCGWINSZ", TIOCGWINSZ, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCSWINSZ", TIOCSWINSZ, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCGSOFTCAR", TIOCGSOFTCAR, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCSSOFTCAR", TIOCSSOFTCAR, "_TIOC", _TIOC);
	IOCTL_VAR("TCGETS", TCGETS, "_TIOC", _TIOC);
	IOCTL_VAR("TCSETS", TCSETS, "_TIOC", _TIOC);
	IOCTL_VAR("TCSANOW", TCSANOW, "_TIOC", _TIOC);
	IOCTL_VAR("TCSETSW", TCSETSW, "_TIOC", _TIOC);
	IOCTL_VAR("TCSADRAIN", TCSADRAIN, "_TIOC", _TIOC);
	IOCTL_VAR("TCSETSF", TCSETSF, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCGPPS", TIOCGPPS, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCSPPS", TIOCSPPS, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCGPPSEV", TIOCGPPSEV, "_TIOC", _TIOC);
	IOCTL_VAR("TCSAFLUSH", TCSAFLUSH, "_TIOC", _TIOC);
	IOCTL_VAR("TIOCGETD", TIOCGETD, "tIOC", tIOC);
	IOCTL_VAR("TIOCSETD", TIOCSETD, "tIOC", tIOC);
	IOCTL_VAR("TIOCHPCL", TIOCHPCL, "tIOC", tIOC);
	IOCTL_VAR("TIOCGETP", TIOCGETP, "tIOC", tIOC);
	IOCTL_VAR("TIOCSETP", TIOCSETP, "tIOC", tIOC);
	IOCTL_VAR("TIOCSETN", TIOCSETN, "tIOC", tIOC);
	IOCTL_VAR("TIOCEXCL", TIOCEXCL, "tIOC", tIOC);
	IOCTL_VAR("TIOCNXCL", TIOCNXCL, "tIOC", tIOC);
	IOCTL_VAR("TIOCFLUSH", TIOCFLUSH, "tIOC", tIOC);
	IOCTL_VAR("TIOCSETC", TIOCSETC, "tIOC", tIOC);
	IOCTL_VAR("TIOCGETC", TIOCGETC, "tIOC", tIOC);
	IOCTL_VAR("TIOCLBIS", TIOCLBIS, "tIOC", tIOC);
	IOCTL_VAR("TIOCLBIC", TIOCLBIC, "tIOC", tIOC);
	IOCTL_VAR("TIOCLSET", TIOCLSET, "tIOC", tIOC);
	IOCTL_VAR("TIOCLGET", TIOCLGET, "tIOC", tIOC);
	IOCTL_VAR("TIOCSBRK", TIOCSBRK, "tIOC", tIOC);
	IOCTL_VAR("TIOCCBRK", TIOCCBRK, "tIOC", tIOC);
	IOCTL_VAR("TIOCSDTR", TIOCSDTR, "tIOC", tIOC);
	IOCTL_VAR("TIOCCDTR", TIOCCDTR, "tIOC", tIOC);
	IOCTL_VAR("TIOCSLTC", TIOCSLTC, "tIOC", tIOC);
	IOCTL_VAR("TIOCGLTC", TIOCGLTC, "tIOC", tIOC);
	IOCTL_VAR("TIOCOUTQ", TIOCOUTQ, "tIOC", tIOC);
	IOCTL_VAR("TIOCNOTTY", TIOCNOTTY, "tIOC", tIOC);
	IOCTL_VAR("TIOCSCTTY", TIOCSCTTY, "tIOC", tIOC);
	IOCTL_VAR("TIOCSTOP", TIOCSTOP, "tIOC", tIOC);
	IOCTL_VAR("TIOCSTART", TIOCSTART, "tIOC", tIOC);
	IOCTL_VAR("TIOCSILOOP", TIOCSILOOP, "tIOC", tIOC);
	IOCTL_VAR("TIOCCILOOP", TIOCCILOOP, "tIOC", tIOC);
	IOCTL_VAR("TIOCGPGRP", TIOCGPGRP, "tIOC", tIOC);
	IOCTL_VAR("TIOCSPGRP", TIOCSPGRP, "tIOC", tIOC);
	IOCTL_VAR("TIOCGSID", TIOCGSID, "tIOC", tIOC);
	IOCTL_VAR("TIOCSTI", TIOCSTI, "tIOC", tIOC);
	IOCTL_VAR("TIOCMSET", TIOCMSET, "tIOC", tIOC);
	IOCTL_VAR("TIOCMBIS", TIOCMBIS, "tIOC", tIOC);
	IOCTL_VAR("TIOCMBIC", TIOCMBIC, "tIOC", tIOC);
	IOCTL_VAR("TIOCMGET", TIOCMGET, "tIOC", tIOC);
	IOCTL_VAR("TIOCREMOTE", TIOCREMOTE, "tIOC", tIOC);
	IOCTL_VAR("TIOCSIGNAL", TIOCSIGNAL, "tIOC", tIOC);
	IOCTL_VAR("FIORDCHK", FIORDCHK, "'f'", 'f' << 8 );
	IOCTL_VAR("TCGETX", TCGETX, "XIOC", XIOC);
	IOCTL_VAR("TCSETX", TCSETX, "XIOC", XIOC);
	IOCTL_VAR("TCSETXW", TCSETXW, "XIOC", XIOC);
	IOCTL_VAR("TCSETXF", TCSETXF, "XIOC", XIOC);
	IOCTL_VAR("VT_OPENQRY", VT_OPENQRY, "VTIOC", VTIOC);
	IOCTL_VAR("VT_SETMODE", VT_SETMODE, "VTIOC", VTIOC);
	IOCTL_VAR("VT_GETMODE", VT_GETMODE, "VTIOC", VTIOC);
	IOCTL_VAR("VT_RELDISP", VT_RELDISP, "VTIOC", VTIOC);
	IOCTL_VAR("VT_ACTIVATE", VT_ACTIVATE, "VTIOC", VTIOC);
	IOCTL_VAR("VT_WAITACTIVE", VT_WAITACTIVE, "VTIOC", VTIOC);
	IOCTL_VAR("VT_GETSTATE", VT_GETSTATE, "VTIOC", VTIOC);
	IOCTL_VAR("VT_ENABLED", VT_ENABLED, "VTIOC", VTIOC);
	IOCTL_VAR("VT_GET_CONSUSER", VT_GET_CONSUSER, "VTIOC", VTIOC);
	IOCTL_VAR("VT_SET_CONSUSER", VT_SET_CONSUSER, "VTIOC", VTIOC);
	IOCTL_VAR("VT_CONFIG", VT_CONFIG, "VTIOC", VTIOC);
	IOCTL_VAR("VT_SETDISPINFO", VT_SETDISPINFO, "VTIOC", VTIOC);
	IOCTL_VAR("VT_SETDISPLOGIN", VT_SETDISPLOGIN, "VTIOC", VTIOC);
	IOCTL_VAR("VT_GETDISPINFO", VT_GETDISPINFO, "VTIOC", VTIOC);
	IOCTL_VAR("VT_SET_TARGET", VT_SET_TARGET, "VTIOC", VTIOC);
	IOCTL_VAR("VT_GETACTIVE", VT_GETACTIVE, "VTIOC", VTIOC);
	IOCTL_VAR("VT_RESET_CONSUSER", VT_RESET_CONSUSER, "VTIOC", VTIOC);
}

fbt::spec_write:entry,fbt::spec_read:entry,fbt::spec_ioctl:entry
/ execname != MYNAME && args[0]->v_path == tty && self->trace == 0
	&& (probefunc == fn[0] || probefunc == fn[1] || probefunc == fn[2]) /
{
	self->trace++;
	self->ts = timestamp;
	@rwi[execname, probefunc] = count(); 
}
fbt::spec_write:entry,fbt::spec_read:entry,fbt::spec_ioctl:entry
/ self->trace /
{
	self->stack++;	/* avoid re-print on nested calls */
}
fbt::spec_write:entry,fbt::spec_read:entry
/ self->stack == 1 /
{
	self->uio = args[1];	/* remember to calc, how many was written */
	self->uio_sz = args[1]->uio_resid;	/* how many bytes to write/read */
	self->io_base = args[1]->uio_iov->iov_base; /* uspace addr of bytes */
}
fbt::spec_ioctl:entry
/ self->stack == 1 /
{
	self->cmd = args[1];
	self->mod = args[3];
}

fbt::spec_write:return,fbt::spec_read:return
/ self->stack == 1 /
{
	this->len = self->uio_sz - self->uio->uio_resid;
	this->what = probefunc == "spec_read" ? "READ" : "WRITE";
	printf("%d %s %d %s  %d B  last dump pos 0x%02x\n", self->ts,
		execname, pid, this->what, this->len, this->len - 1);
	this->p = copyin((uintptr_t) self->io_base, 32);
	tracemem(this->p, 32);
	printf("\n");
	self->trace = self->stack = self->ts = self->cmd = self->mode = 0;
	self->uio_sz = 0; self->io_base = 0; self->uio = 0;
}
fbt::spec_ioctl:return
/ self->stack == 1 /
{
	this->iname = ioctl2name[self->cmd];
	printf("%d %s %d %s  cmd=0x%x (%s)  mode=0x%x  result=%d\n", self->ts,
		execname, pid, "IOCTL", self->cmd, this->iname, self->mode, args[1]);
	self->trace = self->stack = self->ts = self->cmd = self->mode = 0;
}
fbt::spec_write:return,fbt::spec_read:return,fbt::spec_ioctl:return
/ self->trace /
{
	self->stack--;
}

END {
	printa("%16s  %16s %@8d\n", @rwi);
}

/* vim: ts=4 sw=4 ft=dtrace */