/*
 *  TDEBUG.C
 *
 *  (C)Copyright 1987 Matthew Dillon, All Rights Reserved
 *  FreeWare.  May be distributed for non-profit only.
 *
 *  Debug any device .. usually trackdisk.device
 *
 *  AZTEC USERS:   MUST COMPILE  +CDL and LINK WITH THE LARGE EVERYTHING
 *  LIBRARY!!!! (cl32.lib).  NOTE: This source expects all the amiga
 *  symbols to be preloaded.  NOTE: There are some function calls in this
 *  source which you don't have... the functions should be obvious and
 *  easy to implement.
 *
 *  Sorry, no support for lattice.  A smart programmable will be able to
 *  split the assembly file and do all the right #includes.
 *
 */

#define FIFO	struct _FIFO

typedef struct ExecBase EB;
typedef struct List	LIST;
typedef struct Node	NODE;
typedef struct IOStdReq STD;
typedef struct Task	TASK;

FIFO {
    FIFO    *next;	    /* next element */
    STD     std;	    /* IO request   */
};

extern EB *SysBase;
extern NODE *findlist();
extern TASK *FindTask();
extern char *AllocMem();

FIFO *Base, **Lnext = &Base;

NODE *Nodearray[64];

NODE *Ntrack;
NODE *Nasdg;

TASK *Mastertask;
long Operations;	    /* # operations monitored	*/
long Mask, Signum;

char *Stdname[] = {
    "INVALID", "RESET", "READ", "WRITE", "UPDATE", "CLEAR", "STOP",
    "START", "FLUSH"
};

main(ac, av)
char *av[];
{
    register FIFO *fifo;
    register long result;

    disablebreak();
    Mastertask = FindTask(0);
    Signum = AllocSignal(-1);
    Mask = 1 << Signum;
    loadnodearray(ac, av);	/* which devices to intercept?	*/

    overidevector(1);
    puts ("Now intercepting all DoIO() and SendIO() operations");
    puts ("");
    puts ("Device__         Cmd_ Len_____");
    SetSignal(0, SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D);
    for (;;) {
	result = Wait(SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D|Mask);
	if (result & (SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D))
	    break;
	while (Base) {
	    long block, cmd;
	    char ext;

	    Forbid();
	    fifo = Base;
	    Base = Base->next;
	    if (Base == NULL)
		Lnext = &Base;
	    Permit();
	    printf ("%16s ", fifo->std.io_Device->dd_Library.lib_Node.ln_Name);
	    cmd = fifo->std.io_Command;
	    ext = ' ';
	    if (cmd & TDF_EXTCOM) {
		cmd &= ~TDF_EXTCOM;
		ext = 'E';
	    }
	    if (fifo->std.io_Command < CMD_NONSTD)
		printf ("%lc%-7s ", ext, Stdname[fifo->std.io_Command]);
	    else
		printf (" NON+%lc%-2ld ", ext, fifo->std.io_Command - CMD_NONSTD);
	    printf ("%-8ld %-8ld ", fifo->std.io_Length, fifo->std.io_Offset);
	    if (fifo->std.io_Device == Ntrack || fifo->std.io_Device == Nasdg) {
		block = fifo->std.io_Offset / 512;
		printf ("Blk#: %-5ld ", block);
		printf ("(Trk %2ld  Cyl %2ld) ", block/22, (block/11)&1);
	    }
	    puts("");
	    FreeMem(fifo, sizeof(*fifo));
	}
    }
    puts ("Restoring intercept vector");
    overidevector(0);
    Delay(50);
    while (Base) {
	fifo = Base->next;
	FreeMem(Base, sizeof(*Base));
	Base = fifo;
    }
    FreeSignal(Signum);
    printf ("%ld operations monitored\n", Operations);
}


loadnodearray(ac, av)
char *av[];
{
    register int i;
    register int j;
    register NODE *node;
    register LIST *list = &SysBase->DeviceList;

    Ntrack = findlist(list, "trackdisk.device");
    Nasdg  = findlist(list, "asdg.vdisk.device");
    if (ac == 1) {
	puts ("TDEBUG V1.00  By Matthew Dillon");
	puts ("(C)Copyright 1987 Mathew Dillon, All Rights Reserved");
	puts ("CTRL-C, CTRL-D, or BREAK to terminate");
	puts ("");
	puts ("tdebug device device...");
	puts ("tdebug trackdisk.device");
	puts ("");
	showlist(list);
	puts ("");
	exit(1);
    }
    for (i = 1, j = 0; av[i]; ++i) {
	node = findlist(list, av[i]);
	if (!node)
	    printf ("Unable to find: %s\n", av[i]);
	else
	    Nodearray[j++] = node;
    }
}


NODE *
findlist(list, name)
LIST *list;
char *name;
{
    register NODE *node;

    for (node = list->lh_Head; node != &list->lh_Tail; node = node->ln_Succ) {
	if (strcmp(name, node->ln_Name) == 0)
	    return(node);
    }
    return(NULL);
}

showlist(list)
LIST *list;
{
    register NODE *node;

    for (node=list->lh_Head; node != &list->lh_Tail; node=node->ln_Succ) {
	puts(node->ln_Name);
    }
}



static long oldsendvec;
static long olddovec;

overidevector(n)
{
    extern char LVODoIO;
    extern char LVOSendIO;
    extern int newsendio(), newdoio();

    Forbid();
    if (n) {
	oldsendvec = SetFunction(SysBase, &LVOSendIO, newsendio);
	olddovec =   SetFunction(SysBase, &LVODoIO,   newdoio);
    } else {
	SetFunction(SysBase, &LVOSendIO, oldsendvec);
	SetFunction(SysBase, &LVODoIO,	 olddovec);
    }
    Permit();
}

/*
 *  NOTE!!! Since BeginIO is the basis for the entire operating system,
 *  we cannot do anything inside this routine that would ever use it.
 */

myio(ioreq)
register STD *ioreq;
{
    register FIFO *fifo;
    register int i;

    Forbid();
    for (i = 0; Nodearray[i]; ++i) {
	if (Nodearray[i] == ioreq->io_Device)
	    break;
    }
    if (Nodearray[i]) {
	if (fifo = (FIFO *)AllocMem(sizeof(*fifo), 0)) {
	    *Lnext = fifo;
	    Lnext = &fifo->next;
	    fifo->next = NULL;
	    fifo->std = *ioreq;
	}
	++Operations;
	Signal(Mastertask, Mask);
    }
    Permit();
}

#asm

_newsendio:
		movem.l D0-D7/A0-A6,-(sp)   ;save regs
		move.l	A1,-(sp)	    ;the io request
		jsr	_myio		    ;call my intercept routine
		addq.l	#4,sp
		movem.l (sp)+,D0-D7/A0-A6   ;restore regs
		move.l	_oldsendvec,A0	    ;A0 not used by SendIO
		jsr (A0)
		rts

_newdoio:
		movem.l D0-D7/A0-A6,-(sp)   ;save regs
		move.l	A1,-(sp)	    ;the io request
		jsr	_myio		    ;call my intercept routine
		addq.l	#4,sp
		movem.l (sp)+,D0-D7/A0-A6   ;restore regs
		move.l	_olddovec,A0	  ;A0 not used by SendIO
		jsr (A0)
		rts

#endasm