?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated PCI IDs to latest snapshot.
[tangerine.git] / workbench / tools / debug / sashimi / sashimi.c
bloba64b0e7eb02af815b5df88843fe65b621553f0c3
1 /*
2 * $Id$
3 *
4 * Sashimi -- intercepts raw serial debugging output on your own machine
5 *
6 * Written by Olaf `Olsen' Barthel <olsen@sourcery.han.de>
7 * Public Domain
8 *
9 * :ts=4
10 */
11
12 /****************************************************************************/
13
14 #define __TIMER_NOLIBBASE__
15
16 #include <exec/execbase.h>
17 #include <exec/memory.h>
18
19 #include <devices/timer.h>
20
21 #include <dos/dosextens.h>
22 #include <dos/rdargs.h>
23
24 #include <proto/timer.h>
25 #include <proto/exec.h>
26 #include <proto/dos.h>
27
28 #include <aros/libcall.h>
29
30 #include <string.h>
31 #include <stddef.h>
32 #include <stdio.h>
33
34 /****************************************************************************/
35
36 STRPTR Version = "$VER: Sashimi 1.6 (20.6.1999)\r\n";
37
38 /****************************************************************************/
39
40 #define OK (0)
41 #define NOT !
42 #define BUSY NULL
43 #define ZERO ((BPTR)0UL)
44
45 #define min(a,b) (((a) < (b)) ? (a) : (b))
46
47 #define NO_ALLOCABS 1
48
49 /****************************************************************************/
50
51 enum
52 {
53 MODE_Regular,
54 MODE_Recovery
55 };
56
57 /****************************************************************************/
58
59 #define MILLION 1000000
60
61 /****************************************************************************/
62
63 STATIC struct Device * TimerBase;
64
65 /****************************************************************************/
66
67 typedef LONG SWITCH;
68 typedef LONG * NUMBER;
69 typedef STRPTR KEY;
70
71 STATIC struct
72 {
73 /* Startup options */
74 KEY Recover; /* Recover any old Sashimi buffer still in memory */
75 SWITCH On; /* Ignored */
76 NUMBER BufferK; /* Buffer size, to the power of two */
77 NUMBER BufferSize; /* Buffer size in bytes */
78 SWITCH NoPrompt; /* Do not show the initial prompt message */
79 SWITCH Quiet; /* Do not produce any output at all */
80 SWITCH AskExit; /* Ask whether to exit the program */
81 SWITCH AskSave; /* Ask for a file to save the buffer to when exiting */
82 SWITCH TimerOn; /* Check the circular buffer every 1/10 of a second */
83 SWITCH Console; /* Open a console window for I/O */
84 KEY Window; /* Console window specifier */
85
86 /* Runtime options */
87 SWITCH Off; /* Turn Sashimi off */
88 SWITCH Save; /* Save the circular buffer contents */
89 KEY SaveAs; /* Save the circular buffer contents under a specific name */
90 SWITCH Empty; /* Empty the circular buffer */
91 } ShellArguments;
92
93 STATIC const STRPTR ShellTemplate =
94 "RECOVER/K,"
95 "ON/S,"
96 "BUFK/N,"
97 "BUFFERSIZE/N,"
98 "NOPROMPT/S,"
99 "QUIET/S,"
100 "ASKEXIT/S,"
101 "ASKSAVE/S,"
102 "TIMERON/S,"
103 "CONSOLE/S,"
104 "WINDOW/K,"
105 "OFF/S,"
106 "SAVE/S,"
107 "SAVEAS/K,"
108 "EMPTY/S";
109
110 /****************************************************************************/
111
112 /* Eat me */
113 #define COOKIE 0x08021999
114
115 struct SashimiResource
116 {
117 struct Library sr_Library; /* Global link */
118 UWORD sr_Pad; /* Long word alignment */
119
120 ULONG sr_Cookie; /* Magic marker */
121 APTR sr_PointsToCookie; /* Points back to cookie */
122 ULONG sr_CreatedWhen; /* When exactly was this data structure created? */
123
124 struct Task * sr_Owner; /* Current owner of the patches */
125 LONG sr_OwnerSigBit;
126 ULONG sr_OwnerSigMask; /* Signal mask to send when a new line is in the buffer. */
127
128 ULONG sr_FIFOTotalSize; /* Number of bytes allocated for the buffer */
129 ULONG sr_FIFOReadIndex; /* Read index counter */
130 ULONG sr_FIFOWriteIndex; /* Write index counter */
131 ULONG sr_FIFOBytesStored; /* Number of bytes in the FIFO */
132 BOOL sr_FIFOOverrun; /* TRUE if the write index counter has
133 * overrun the read index counter.
134 */
135 BOOL sr_FIFOWrapped; /* TRUE if the write index counter has
136 * wrapped around the circular buffer.
137 */
138 UBYTE sr_FIFO[1]; /* The message buffer */
139 };
140
141 STATIC const STRPTR SashimiResourceName = "sashimi.resource";
142 STATIC struct SashimiResource * GlobalSashimiResource;
143
144 /****************************************************************************/
145
146 #define LVORawIOInit (-84 * LIB_VECTSIZE)
147 #define LVORawMayGetChar (-85 * LIB_VECTSIZE)
148 #define LVORawPutChar (-86 * LIB_VECTSIZE)
149
150 /****************************************************************************/
151
152 STATIC APTR OldRawIOInit;
153 STATIC APTR OldRawMayGetChar;
154 STATIC APTR OldRawPutChar;
155
156 /****************************************************************************/
157
158 AROS_LH0(void, NewRawIOInit,
159 struct ExecBase *, SysBase, 84, Exec)
160 {
161 AROS_LIBFUNC_INIT
162
163 /* Nothing happens here */
164
165 AROS_LIBFUNC_EXIT
166 }
167
168 AROS_LH0(LONG, NewRawMayGetChar,
169 struct ExecBase *, SysBase, 85, Exec)
170 {
171 AROS_LIBFUNC_INIT
172
173 /* We always return sort of a confirmation. */
174 return('y');
175
176 AROS_LIBFUNC_EXIT
177 }
178
179 /****************************************************************************/
180
181 STATIC LONG
182 GetCharsInFIFO(struct SashimiResource * sr)
183 {
184 LONG result;
185
186 Disable();
187
188 if(sr->sr_FIFOWrapped)
189 result = sr->sr_FIFOTotalSize;
190 else
191 result = sr->sr_FIFOWriteIndex;
192
193 Enable();
194
195 return(result);
196 }
197
198 STATIC VOID
199 EmptyFIFO(struct SashimiResource * sr)
200 {
201 Disable();
202
203 sr->sr_FIFOReadIndex = 0;
204 sr->sr_FIFOWriteIndex = 0;
205 sr->sr_FIFOBytesStored = 0;
206 sr->sr_FIFOOverrun = FALSE;
207 sr->sr_FIFOWrapped = FALSE;
208
209 Enable();
210 }
211
212 STATIC LONG
213 ReadFIFOChars(struct SashimiResource * sr,UBYTE * buffer,LONG maxChars)
214 {
215 LONG result = 0;
216
217 Disable();
218
219 if(sr->sr_FIFOBytesStored > 0)
220 {
221 LONG howMany;
222
223 if(maxChars > sr->sr_FIFOBytesStored)
224 maxChars = sr->sr_FIFOBytesStored;
225
226 do
227 {
228 /* Find out how many characters can be read
229 * from the FIFO without overrunning the
230 * end of it. We don't read more than these
231 * few characters in one go.
232 */
233 howMany = min(maxChars,sr->sr_FIFOTotalSize - sr->sr_FIFOReadIndex);
234
235 memcpy(buffer,&sr->sr_FIFO[sr->sr_FIFOReadIndex],howMany);
236
237 result += howMany;
238 buffer += howMany;
239 maxChars -= howMany;
240
241 sr->sr_FIFOReadIndex = (sr->sr_FIFOReadIndex + howMany) % sr->sr_FIFOTotalSize;
242 }
243 while(maxChars > 0);
244
245 /* Subtract the number of characters we
246 * read in the loop.
247 */
248 sr->sr_FIFOBytesStored -= result;
249 }
250
251 Enable();
252
253 return(result);
254 }
255
256 STATIC VOID
257 StoreFIFOChar(struct SashimiResource * sr,UBYTE c)
258 {
259 sr->sr_FIFO[sr->sr_FIFOWriteIndex] = c;
260 sr->sr_FIFOWriteIndex = (sr->sr_FIFOWriteIndex + 1) % sr->sr_FIFOTotalSize;
261
262 /* If the buffer wraps around, remember it. */
263 if(sr->sr_FIFOWriteIndex == 0)
264 sr->sr_FIFOWrapped = TRUE;
265
266 /* Check if the circular buffer was overrun */
267 sr->sr_FIFOBytesStored++;
268 if(sr->sr_FIFOBytesStored > sr->sr_FIFOTotalSize)
269 {
270 sr->sr_FIFOOverrun = TRUE;
271
272 /* Move the read index to the same position as
273 * the write index and retain only as many
274 * bytes as would fit into the FIFO.
275 */
276 sr->sr_FIFOReadIndex = sr->sr_FIFOWriteIndex;
277 sr->sr_FIFOBytesStored = sr->sr_FIFOTotalSize;
278 }
279 }
280
281 /****************************************************************************/
282
283 AROS_LH1(void, NewRawPutChar,
284 AROS_LHA(UBYTE, c, D0),
285 struct ExecBase *, SysBase, 86, Exec)
286 {
287 AROS_LIBFUNC_INIT
288
289 /* Do not store NUL bytes. */
290 if(c != '\0')
291 {
292 STATIC ULONG Position = 0;
293
294 Disable();
295
296 /* Filter out extra <cr> characters. */
297 if(c != '\r' || Position > 0)
298 {
299 struct SashimiResource * sr = GlobalSashimiResource;
300
301 /* Store another byte in the buffer */
302 StoreFIFOChar(sr,c);
303
304 /* Notify Sashimi every time there is an end of line
305 * character in the stream.
306 */
307 if(c == '\n' || c == '\r')
308 Signal(sr->sr_Owner,sr->sr_OwnerSigMask);
309 }
310
311 if(c == '\r' || c == '\n')
312 Position = 0;
313 else
314 Position++;
315
316 Enable();
317 }
318
319 AROS_LIBFUNC_EXIT
320 }
321
322 /****************************************************************************/
323
324 STATIC VOID
325 RemovePatches(VOID)
326 {
327 APTR res;
328
329 /* We disable the interrupts because the raw I/O routines can
330 * be called from within interrupt code.
331 */
332 Disable();
333
334 /* For every patch planted, remove it and check whether the code
335 * had been patched before. If it has, restore the patch. Note that
336 * this is not bullet proof :(
337 */
338 res = SetFunction(&SysBase->LibNode,LVORawIOInit,OldRawIOInit);
339 if(res != AROS_SLIB_ENTRY(NewRawIOInit,Exec))
340 SetFunction(&SysBase->LibNode,LVORawIOInit,res);
341
342 res = SetFunction(&SysBase->LibNode,LVORawMayGetChar,OldRawMayGetChar);
343 if(res != AROS_SLIB_ENTRY(NewRawMayGetChar,Exec))
344 SetFunction(&SysBase->LibNode,LVORawMayGetChar,res);
345
346 res = SetFunction(&SysBase->LibNode,LVORawPutChar,OldRawPutChar);
347 if(res != AROS_SLIB_ENTRY(NewRawPutChar,Exec))
348 SetFunction(&SysBase->LibNode,LVORawPutChar,res);
349
350 Enable();
351 }
352
353 STATIC VOID
354 InstallPatches(VOID)
355 {
356 /* We disable the interrupts because the raw I/O routines can
357 * be called from within interrupt code.
358 */
359 Disable();
360
361 OldRawIOInit = SetFunction(&SysBase->LibNode,LVORawIOInit, AROS_SLIB_ENTRY(NewRawIOInit,Exec));
362 OldRawMayGetChar = SetFunction(&SysBase->LibNode,LVORawMayGetChar, AROS_SLIB_ENTRY(NewRawMayGetChar,Exec));
363 OldRawPutChar = SetFunction(&SysBase->LibNode,LVORawPutChar, AROS_SLIB_ENTRY(NewRawPutChar,Exec));
364
365 Enable();
366 }
367
368 /****************************************************************************/
369
370 STATIC VOID
371 FreeSashimiResource(struct SashimiResource * sr)
372 {
373 if(sr != NULL)
374 {
375 FreeSignal(sr->sr_OwnerSigBit);
376
377 /* Destroy the markers */
378 sr->sr_Cookie = 0;
379 sr->sr_PointsToCookie = NULL;
380
381 #if NO_ALLOCABS
382 FreeMem(sr,sizeof(*sr) + sr->sr_FIFOTotalSize-1 + sizeof(struct MemChunk));
383 #else
384 FreeMem(sr,sizeof(*sr) + sr->sr_FIFOTotalSize-1);
385 #endif
386 }
387 }
388
389 STATIC LONG
390 RemoveSashimiResource(struct SashimiResource * sr)
391 {
392 LONG error = OK;
393
394 if(sr != NULL)
395 {
396 Forbid();
397
398 /* Allow the resource to be removed only if
399 * there are no customers using it.
400 */
401 if(sr->sr_Library.lib_OpenCnt == 0)
402 RemResource(sr);
403 else
404 error = ERROR_OBJECT_IN_USE;
405
406 Permit();
407 }
408
409 return(error);
410 }
411
412 STATIC LONG
413 AddSashimiResource(ULONG bufferSize,struct SashimiResource ** resourcePtr)
414 {
415 struct SashimiResource * sr;
416 LONG error = OK;
417
418 /* We will do something really tricky; to increase our chances of
419 * allocating an old Sashimi buffer to be recovered, we allocate
420 * the amount of memory needed plus the size of a memory chunk.
421 * Then we release that buffer again and reallocate it with the
422 * size of the memory chunk trailing behind it.
423 */
424
425 Forbid();
426
427 sr = AllocMem(sizeof(struct MemChunk) + sizeof(*sr) + bufferSize-1,MEMF_ANY|MEMF_PUBLIC);
428 #if !NO_ALLOCABS
429 if(sr != NULL)
430 {
431 FreeMem(sr,sizeof(struct MemChunk) + sizeof(*sr) + bufferSize-1);
432 sr = AllocAbs(sizeof(*sr) + bufferSize-1,(BYTE *)sr + sizeof(struct MemChunk));
433 }
434 #endif
435 Permit();
436
437 if(sr != NULL)
438 {
439 struct timeval now;
440
441 GetSysTime(&now);
442
443 memset(sr,0,sizeof(*sr)-1);
444
445 sr->sr_Library.lib_Node.ln_Name = (char *)SashimiResourceName;
446 sr->sr_Library.lib_Node.ln_Type = NT_RESOURCE;
447 sr->sr_Owner = FindTask(NULL);
448 sr->sr_FIFOTotalSize = bufferSize;
449 sr->sr_Cookie = COOKIE;
450 sr->sr_PointsToCookie = &sr->sr_Cookie;
451 sr->sr_CreatedWhen = now.tv_secs;
452
453 sr->sr_OwnerSigBit = AllocSignal(-1);
454 if(sr->sr_OwnerSigBit != -1)
455 {
456 sr->sr_OwnerSigMask = (1UL << sr->sr_OwnerSigBit);
457
458 Forbid();
459
460 /* Do not add the resource if it has already been installed. */
461 if(OpenResource((STRPTR)SashimiResourceName) == NULL)
462 AddResource(sr);
463 else
464 error = ERROR_OBJECT_EXISTS;
465
466 Permit();
467 }
468 else
469 {
470 error = ERROR_NO_FREE_STORE;
471 }
472 }
473 else
474 {
475 error = ERROR_NO_FREE_STORE;
476 }
477
478 if(error != OK)
479 {
480 FreeSashimiResource(sr);
481 sr = NULL;
482 }
483
484 (*resourcePtr) = sr;
485
486 return(error);
487 }
488
489 /****************************************************************************/
490
491 STATIC VOID
492 CloseSashimiResource(struct SashimiResource * sr)
493 {
494 if(sr != NULL)
495 {
496 Forbid();
497
498 sr->sr_Library.lib_OpenCnt--;
499
500 Permit();
501 }
502 }
503
504 STATIC struct SashimiResource *
505 OpenSashimiResource(VOID)
506 {
507 struct SashimiResource * sr;
508
509 Forbid();
510
511 sr = OpenResource((STRPTR)SashimiResourceName);
512 if(sr != NULL)
513 sr->sr_Library.lib_OpenCnt++;
514
515 Permit();
516
517 return(sr);
518 }
519
520 /****************************************************************************/
521
522 STATIC LONG
523 SaveBuffer(const STRPTR name,struct SashimiResource * sr,LONG mode)
524 {
525 LONG error = OK;
526 STRPTR buffer;
527
528 /* We allocate a temporary buffer to store the circular
529 * buffer data in.
530 */
531 buffer = AllocVec(sr->sr_FIFOTotalSize,MEMF_ANY|MEMF_PUBLIC);
532 if(buffer != NULL)
533 {
534 LONG bytesInBuffer;
535 BOOL wrapped;
536 BOOL overrun;
537 BPTR file;
538
539 if(mode == MODE_Regular)
540 {
541 /* Stop interrupts and multitasking for a tick. */
542 Disable();
543 }
544
545 wrapped = sr->sr_FIFOWrapped;
546 overrun = sr->sr_FIFOOverrun;
547
548 if(wrapped)
549 {
550 LONG oldBytes = sr->sr_FIFOTotalSize - sr->sr_FIFOWriteIndex;
551
552 /* Unwrap the buffer; first copy the old data (following the
553 * write index) then the newer data.
554 */
555 memcpy(buffer,&sr->sr_FIFO[sr->sr_FIFOWriteIndex],oldBytes);
556 memcpy(&buffer[oldBytes],sr->sr_FIFO,sr->sr_FIFOWriteIndex);
557
558 bytesInBuffer = sr->sr_FIFOTotalSize;
559 }
560 else
561 {
562 memcpy(buffer,sr->sr_FIFO,sr->sr_FIFOWriteIndex);
563
564 bytesInBuffer = sr->sr_FIFOWriteIndex;
565 }
566
567 if(mode == MODE_Regular)
568 {
569 /* Start interrupts and multitasking again. */
570 Enable();
571 }
572
573 /* Write the buffer contents. */
574 file = Open((STRPTR)name,MODE_NEWFILE);
575 if(file != ZERO)
576 {
577 if(mode == MODE_Recovery)
578 {
579 if(FPrintf(file,"RECOVERY WARNING - Data may have been damaged\n") < 0)
580 error = IoErr();
581 }
582
583 if(error == OK && overrun)
584 {
585 if(FPrintf(file,"BUFFER WAS OVERRUN - Data may have been lost\n") < 0)
586 error = IoErr();
587 }
588
589 if(error == OK && wrapped)
590 {
591 if(FPrintf(file,"BUFFER WRAPPED - This is the most recent captured data\n\n") < 0)
592 error = IoErr();
593 }
594
595 /* FPrintf() is a buffered I/O routine, this is why we need to flush the
596 * output buffer here. Otherwise, it would be flushed after the Write()
597 * command below is finished and the file is closed. This is not what
598 * we want as that would have the effect of adding the messages above
599 * to the end of the file.
600 */
601 if(error == OK)
602 Flush(file);
603
604 if(error == OK)
605 {
606 if(Write(file,buffer,bytesInBuffer) != bytesInBuffer)
607 error = IoErr();
608 }
609
610 Close(file);
611 }
612 else
613 {
614 error = IoErr();
615 }
616
617 FreeVec(buffer);
618 }
619 else
620 {
621 error = ERROR_NO_FREE_STORE;
622 }
623
624 return(error);
625 }
626
627 /****************************************************************************/
628
629 STATIC BOOL
630 Recover(const STRPTR fileName)
631 {
632 struct SashimiResource * sr = NULL;
633 APTR allocated = NULL;
634 struct MemHeader * mh;
635 ULONG * start;
636 ULONG * end;
637 BOOL success;
638
639 Printf("Trying to recover old Sashimi buffer... ");
640 Flush(Output());
641
642 Forbid();
643
644 /* Scan the system memory list. */
645 for(mh = (struct MemHeader *)SysBase->MemList.lh_Head ;
646 mh->mh_Node.ln_Succ != NULL ;
647 mh = (struct MemHeader *)mh->mh_Node.ln_Succ)
648 {
649 start = (ULONG *)mh->mh_Lower;
650 end = (ULONG *)mh->mh_Upper;
651
652 do
653 {
654 /* First look for the cookie... */
655 if(start[0] == COOKIE)
656 {
657 /* Then look for the pointer back to it. */
658 if(start[1] == (ULONG)start)
659 {
660 /* Unless we don't have a resource pointer
661 * yet, compare the creation times and take
662 * only the latest buffer.
663 */
664 if(sr == NULL || start[2] > sr->sr_CreatedWhen)
665 sr = (struct SashimiResource *)((ULONG)start - offsetof(struct SashimiResource,sr_Cookie));
666 }
667 }
668 }
669 while(++start != end);
670 }
671
672 /* Try to allocate the memory the old buffer occupies. */
673 if(sr != NULL)
674 allocated = AllocAbs(sizeof(*sr) + sr->sr_FIFOTotalSize-1 + sizeof(struct MemChunk),(BYTE *)sr - sizeof(struct MemChunk));
675
676 Permit();
677
678 if(sr != NULL)
679 {
680 LONG error = OK;
681 LONG numBytes;
682
683 if(sr->sr_FIFOWrapped)
684 numBytes = sr->sr_FIFOTotalSize;
685 else
686 numBytes = sr->sr_FIFOWriteIndex;
687
688 Printf("found something (%ld bytes).\n",numBytes);
689
690 /* If there is anything worth saving, save it. */
691 if(numBytes > 0)
692 {
693 error = SaveBuffer(fileName,sr,MODE_Recovery);
694 if(error == OK)
695 Printf("Recovered Sashimi buffer saved as \"%s\".\n",fileName);
696 else
697 PrintFault(error,fileName);
698 }
699 else
700 {
701 Printf("This is not worth saving.\n");
702 }
703
704 /* If everything went fine so far and
705 * if we are the owner of the buffer,
706 * mark it as invalid.
707 */
708 if(error == OK && allocated != NULL)
709 {
710 sr->sr_Cookie = 0;
711 sr->sr_PointsToCookie = NULL;
712 }
713
714 success = TRUE;
715 }
716 else
717 {
718 Printf("sorry.\n");
719
720 success = FALSE;
721 }
722
723 /* Release the buffer... */
724 if(allocated != NULL)
725 FreeMem(allocated,sizeof(*sr) + sr->sr_FIFOTotalSize-1 + sizeof(struct MemChunk));
726
727 return(success);
728 }
729
730 /****************************************************************************/
731
732 int
733 main(int argc,char **argv)
734 {
735 int result = RETURN_FAIL;
736
737 /* Kickstart 2.04 and a Shell window are required. */
738 if(argc > 0)
739 {
740 struct RDArgs * rdargs;
741
742 rdargs = ReadArgs((STRPTR)ShellTemplate,(IPTR *)&ShellArguments,NULL);
743 if(rdargs != NULL)
744 {
745 /* Before anything else happens, check if
746 * we should recover any old data.
747 */
748 if(ShellArguments.Recover != NULL)
749 {
750 if(Recover(ShellArguments.Recover))
751 result = RETURN_OK;
752 else
753 result = RETURN_WARN;
754 }
755 else
756 {
757 struct SashimiResource * sr = NULL;
758 struct MsgPort * timePort;
759 struct timerequest * timeRequest = NULL;
760 BOOL added = FALSE;
761 BOOL opened = FALSE;
762 LONG error = OK;
763 BPTR oldOutput = ZERO;
764 BPTR newOutput = ZERO;
765 BPTR oldInput = ZERO;
766 BPTR newInput = ZERO;
767 struct MsgPort * oldConsoleTask = NULL;
768 STRPTR saveFile;
769
770 /* Fill in the save file name, we might need it later. */
771 if(ShellArguments.SaveAs != NULL)
772 saveFile = ShellArguments.SaveAs;
773 else
774 saveFile = "T:sashimi.out";
775
776 /* Set up the timer.device interface. */
777 timePort = CreateMsgPort();
778 if(timePort != NULL)
779 {
780 timeRequest = (struct timerequest *)CreateIORequest(timePort,sizeof(*timeRequest));
781 if(timeRequest != NULL)
782 {
783 if(OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *)timeRequest,0) == OK)
784 TimerBase = timeRequest->tr_node.io_Device;
785 else
786 error = ERROR_NO_FREE_STORE; /* Misleading? */
787 }
788 else
789 {
790 error = ERROR_NO_FREE_STORE;
791 }
792 }
793 else
794 {
795 error = ERROR_NO_FREE_STORE;
796 }
797
798 if(error == OK)
799 {
800 /* Try to open the resource, and if that fails, create one. */
801 sr = OpenSashimiResource();
802 if(sr != NULL)
803 {
804 opened = TRUE;
805 }
806 else
807 {
808 ULONG bufferSize;
809
810 /* The default buffer size is 32K. */
811 bufferSize = 32 * 1024;
812
813 /* Check for a specific buffer size (power of two). */
814 if(ShellArguments.BufferK != NULL)
815 bufferSize = 1024 * (*ShellArguments.BufferK);
816
817 /* Check for a specific buffer size. */
818 if(ShellArguments.BufferSize != NULL)
819 bufferSize = (ULONG)(*ShellArguments.BufferSize);
820
821 /* Don't make the buffer too small. */
822 if(bufferSize < 4096)
823 bufferSize = 4096;
824
825 /* Add the resource to the public list. Note that
826 * the patches are not installed yet.
827 */
828 error = AddSashimiResource(bufferSize,&sr);
829 if(error == OK)
830 added = TRUE;
831 }
832 }
833
834 /* Did we get everything we wanted? */
835 if(error != OK)
836 {
837 PrintFault(error,"Sashimi");
838 result = RETURN_ERROR;
839 }
840 else
841 {
842 if(opened)
843 {
844 /* Save the current circular buffer contents? */
845 if(ShellArguments.SaveAs != NULL || ShellArguments.Save)
846 {
847 LONG error;
848
849 error = SaveBuffer(saveFile,sr,MODE_Regular);
850 if(error == OK)
851 Printf("Sashimi buffer saved as \"%s\".\n",saveFile);
852 else
853 PrintFault(error,saveFile);
854 }
855
856 /* Empty the circular buffer? */
857 if(ShellArguments.Empty)
858 {
859 EmptyFIFO(sr);
860
861 Printf("Sashimi buffer cleared.\n");
862 }
863
864 /* Turn off Sashimi? */
865 if(ShellArguments.Off)
866 {
867 struct Task * owner;
868
869 Forbid();
870
871 /* We cannot tell Sashimi to quit
872 * if there is a single customer
873 * left, such as us. This is why
874 * we close the resource and
875 * signal Sashimi to quit.
876 */
877 owner = sr->sr_Owner;
878 CloseSashimiResource(sr);
879 sr = NULL;
880
881 Signal(owner,SIGBREAKF_CTRL_C);
882
883 Permit();
884 }
885 }
886
887 if(added && NOT ShellArguments.Off)
888 {
889 ULONG signalsReceived,signalsToWaitFor;
890 BOOL done;
891
892 /* Open a console window? */
893 if(ShellArguments.Console)
894 {
895 STRPTR consoleWindow;
896 LONG error = OK;
897
898 if(ShellArguments.Window != NULL)
899 consoleWindow = ShellArguments.Window;
900 else
901 consoleWindow = "CON:0/20/640/100/Sashimi [Ctrl]+E=Empty [Ctrl]+F=File [Ctrl]+D=Reset console/AUTO/CLOSE/WAIT/INACTIVE";
902
903 /* Open the window and make it the default
904 * I/O stream.
905 */
906 #if 1
907 newInput = Open(consoleWindow,MODE_READWRITE);
908 #else
909 newInput = Open(consoleWindow,MODE_NEWFILE);
910 #endif
911 if(newInput != ZERO)
912 {
913 #if 1
914 oldInput = SelectInput(newInput);
915 oldOutput = SelectOutput(newInput);
916 #else
917 oldConsoleTask = SetConsoleTask(((struct FileHandle *)BADDR(newInput))->fh_Type);
918 newOutput = Open("CONSOLE:",MODE_OLDFILE);
919 if(newOutput != ZERO)
920 {
921 oldInput = SelectInput(newInput);
922 oldOutput = SelectOutput(newOutput);
923 }
924 else
925 {
926 error = IoErr();
927
928 /* Return to the original console task. */
929 SetConsoleTask(oldConsoleTask);
930 oldConsoleTask = NULL;
931 }
932 #endif
933 }
934 else
935 {
936 error = IoErr();
937 }
938
939 if(error != OK)
940 PrintFault(error,consoleWindow);
941 }
942
943 /* Show the banner message. */
944 if(NOT ShellArguments.NoPrompt && NOT ShellArguments.Quiet)
945 {
946 struct Process * cli = (struct Process *)FindTask(NULL);
947 LONG maxCli,thisCli = 1,i;
948
949 /* Find our current CLI process number. */
950 maxCli = MaxCli();
951 for(i = 1 ; i <= maxCli ; i++)
952 {
953 if(FindCliProc(i) == cli)
954 {
955 thisCli = i;
956 break;
957 }
958 }
959
960 Printf("Sashimi installed ([Ctrl]+C or \"Break %ld\" to remove)\n",thisCli);
961 }
962
963 GlobalSashimiResource = sr;
964 InstallPatches();
965
966 signalsToWaitFor = SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D |
967 SIGBREAKF_CTRL_E | SIGBREAKF_CTRL_F |
968 sr->sr_OwnerSigMask;
969
970 /* Start the timer. */
971 if(ShellArguments.TimerOn)
972 {
973 signalsToWaitFor |= (1UL << timePort->mp_SigBit);
974
975 timeRequest->tr_node.io_Command = TR_ADDREQUEST;
976 timeRequest->tr_time.tv_secs = 0;
977 timeRequest->tr_time.tv_micro = MILLION / 10;
978
979 SendIO((struct IORequest *)timeRequest);
980 }
981
982 done = FALSE;
983 do
984 {
985 signalsReceived = Wait(signalsToWaitFor);
986
987 /* Check if we should test the buffer. */
988 if(ShellArguments.TimerOn)
989 {
990 if(signalsReceived & (1UL << timePort->mp_SigBit))
991 {
992 signalsReceived |= sr->sr_OwnerSigMask;
993
994 WaitIO((struct IORequest *)timeRequest);
995
996 /* Restart the timer. */
997 timeRequest->tr_node.io_Command = TR_ADDREQUEST;
998 timeRequest->tr_time.tv_secs = 0;
999 timeRequest->tr_time.tv_micro = MILLION / 10;
1000
1001 SendIO((struct IORequest *)timeRequest);
1002 }
1003 }
1004
1005 /* Check if we should test the buffer. */
1006 if(signalsReceived & sr->sr_OwnerSigMask)
1007 {
1008 if(NOT ShellArguments.Quiet)
1009 {
1010 UBYTE localBuffer[256];
1011 ULONG moreSignals;
1012 LONG filled;
1013
1014 /* Try to empty the circular buffer. */
1015 while((filled = ReadFIFOChars(sr,localBuffer,sizeof(localBuffer))) > 0)
1016 {
1017 /* Check if there is a message for us. */
1018 moreSignals = SetSignal(0,SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_E|SIGBREAKF_CTRL_F);
1019
1020 /* Save the circular buffer to a file? */
1021 if(moreSignals & SIGBREAKF_CTRL_F)
1022 {
1023 LONG error;
1024
1025 error = SaveBuffer(saveFile,sr,MODE_Regular);
1026 if(error == OK)
1027 Printf("Sashimi buffer saved as \"%s\".\n",saveFile);
1028 else
1029 PrintFault(error,saveFile);
1030 }
1031
1032 /* Empty the circular buffer? */
1033 if(moreSignals & SIGBREAKF_CTRL_E)
1034 {
1035 EmptyFIFO(sr);
1036
1037 Printf("Sashimi buffer cleared.\n");
1038 filled = 0;
1039 }
1040
1041 /* Stop Sashimi? */
1042 if(moreSignals & SIGBREAKF_CTRL_C)
1043 {
1044 signalsReceived |= SIGBREAKF_CTRL_C;
1045 break;
1046 }
1047
1048 /* Write the buffer to the file. */
1049 if(filled > 0)
1050 Write(Output(),localBuffer,filled);
1051 }
1052 }
1053 }
1054
1055 /* Save current buffer to file. */
1056 if(signalsReceived & SIGBREAKF_CTRL_F)
1057 {
1058 LONG error;
1059
1060 error = SaveBuffer(saveFile,sr,MODE_Regular);
1061 if(error == OK)
1062 Printf("Sashimi buffer saved as \"%s\".\n",saveFile);
1063 else
1064 PrintFault(error,saveFile);
1065 }
1066
1067 /* Empty the buffer. */
1068 if(signalsReceived & SIGBREAKF_CTRL_E)
1069 {
1070 EmptyFIFO(sr);
1071
1072 Printf("Sashimi buffer cleared.\n");
1073 }
1074
1075 /* Reset the terminal. */
1076 if(signalsReceived & SIGBREAKF_CTRL_D)
1077 {
1078 Printf("\033c");
1079 Flush(Output());
1080 }
1081
1082 /* Terminate the program. */
1083 if(signalsReceived & SIGBREAKF_CTRL_C)
1084 {
1085 BOOL terminate = FALSE;
1086
1087 if(ShellArguments.AskExit)
1088 {
1089 UBYTE buffer[4];
1090
1091 Printf("\nSashimi: stop signal received -- really exit (y or n)? ");
1092 Flush(Output());
1093
1094 buffer[0] = '\0';
1095
1096 if(FGets(Input(),buffer,sizeof(buffer)-1) != NULL)
1097 {
1098 if(buffer[0] == 'y' || buffer[0] == 'Y')
1099 terminate = TRUE;
1100 }
1101 }
1102 else
1103 {
1104 terminate = TRUE;
1105 }
1106
1107 if(terminate)
1108 {
1109 if(RemoveSashimiResource(sr) == OK)
1110 {
1111 Printf("Sashimi removed.\n");
1112 done = TRUE;
1113 }
1114 }
1115 }
1116 }
1117 while(NOT done);
1118
1119 RemovePatches();
1120
1121 /* Stop the timer. */
1122 if(ShellArguments.TimerOn)
1123 {
1124 if(CheckIO((struct IORequest *)timeRequest) == BUSY)
1125 AbortIO((struct IORequest *)timeRequest);
1126
1127 WaitIO((struct IORequest *)timeRequest);
1128 }
1129
1130 /* Check if we should and could save the circular buffer. */
1131 if(ShellArguments.AskSave && GetCharsInFIFO(sr) > 0)
1132 {
1133 UBYTE name[256];
1134
1135 Printf("Enter name to save the buffer, or hit [Return] to cancel: ");
1136 Flush(Output());
1137
1138 name[0] = '\0';
1139
1140 if(FGets(Input(),name,sizeof(name)-1) != NULL)
1141 {
1142 LONG error;
1143 int i;
1144
1145 for(i = strlen(name)-1 ; i >= 0 ; i--)
1146 {
1147 if(name[i] == '\n')
1148 name[i] = '\0';
1149 }
1150
1151 error = SaveBuffer(name,sr,MODE_Regular);
1152 if(error == OK)
1153 Printf("Sashimi buffer saved as \"%s\".\n",name);
1154 else
1155 PrintFault(error,name);
1156 }
1157 }
1158
1159 FreeSashimiResource(sr);
1160 sr = NULL;
1161 }
1162
1163 result = RETURN_OK;
1164 }
1165
1166 /* Close the resource, if we opened it. */
1167 if(opened)
1168 CloseSashimiResource(sr);
1169
1170 /* Remove and free the resource if we added it. */
1171 if(added)
1172 {
1173 RemoveSashimiResource(sr);
1174 FreeSashimiResource(sr);
1175 }
1176
1177 /* Clean up the timer.device interface. */
1178 if(timeRequest != NULL)
1179 {
1180 if(timeRequest->tr_node.io_Device != NULL)
1181 CloseDevice((struct IORequest *)timeRequest);
1182
1183 DeleteIORequest((struct IORequest *)timeRequest);
1184 }
1185
1186 DeleteMsgPort(timePort);
1187
1188 /* Reset and clean up the console I/O streams. */
1189 if(oldOutput != ZERO)
1190 SelectOutput(oldOutput);
1191
1192 if(oldInput != ZERO)
1193 SelectInput(oldInput);
1194
1195 if(newOutput != ZERO)
1196 Close(newOutput);
1197
1198 if(oldConsoleTask != NULL)
1199 SetConsoleTask(oldConsoleTask);
1200
1201 if(newInput != ZERO)
1202 Close(newInput);
1203 }
1204
1205 FreeArgs(rdargs);
1206 }
1207 else
1208 {
1209 PrintFault(IoErr(),"Sashimi");
1210
1211 result = RETURN_ERROR;
1212 }
1213 }
1214
1215 return(result);
1216 }
A totally sweet operating system