workbench/c/LeakWatch.c

   1 /*
   2     Copyright © 2002-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: show deltas of resources usage
   6     Lang: english
   7 */
   8
   9 /******************************************************************************
  10
  11
  12     NAME
  13
  14         LeakWatch
  15
  16     SYNOPSIS
  17
  18         (N/A)
  19
  20     LOCATION
  21
  22         C:
  23
  24     FUNCTION
  25
  26         It's like doing avail flush before and after executing a program to detect
  27         memleaks, excepted that this program tries to detect much more leaks.
  28
  29         Press CRTL-f whenever you want to check for leak.
  30
  31     INPUTS
  32
  33     RESULT
  34
  35     NOTES
  36
  37     EXAMPLE
  38
  39     BUGS
  40
  41     SEE ALSO
  42
  43     INTERNALS
  44
  45         It has to not leak itself, and not even allocate memory between checks.
  46         That's why lists and nodes are statically allocated (in a system that could
  47         be improved to allow reuse of nodes. (like using an Allocate-based own
  48         memory allocator using a huge static array as heap)
  49
  50     HISTORY
  51
  52 ******************************************************************************/
  53
  54 #include <exec/memory.h>
  55 #include <exec/tasks.h>
  56 #ifndef EXEC_SEMAPHORES
  57 #   include <exec/semaphores.h>
  58 #endif
  59 #include <exec/execbase.h>
  60 #include <graphics/gfxbase.h>
  61 #include <graphics/text.h>
  62 #include <intuition/classes.h>
  63 #include <proto/exec.h>
  64 #include <proto/graphics.h>
  65 #include <dos/dosextens.h>
  66 #include <proto/dos.h>
  67 #include <clib/alib_protos.h>
  68
  69 #include <string.h>
  70
  71 #define DEBUG 1
  72 #include <aros/debug.h>
  73
  74 const TEXT version[] = "$VER: LeakWatch 0.2 (10.03.2013)\n";
  75
  76 static struct Library *GadToolsBase;
  77
  78 struct GadToolsBase_intern
  79 {
  80     struct Library                lib;
  81
  82     Class                       * buttonclass;
  83     Class                       * textclass;
  84     Class                       * sliderclass;
  85     Class                       * scrollerclass;
  86     Class                       * arrowclass;
  87     Class                       * stringclass;
  88     Class                       * listviewclass;
  89     Class                       * checkboxclass;
  90     Class                       * cycleclass;
  91     Class                       * mxclass;
  92     Class                       * paletteclass;
  93
  94     /* Semaphore to protect the bevel object. */
  95     struct SignalSemaphore      bevelsema;
  96     /* Actually an Object *. The image used for bevel boxes. */
  97     struct Image                * bevel;
  98
  99     /* RenderHook for GTListView class */
 100     struct Hook                 lv_RenderHook;
 101
 102     /* Seglist pointer */
 103     BPTR                        gt_SegList;
 104
 105     /* Required libraies */
 106     APTR                        gt_IntuitionBase;
 107     APTR                        gt_UtilityBase;
 108     APTR                        gt_GfxBase;
 109     APTR                        gt_LayersBase;
 110 };
 111
 112
 113
 114 /* struct arrays : ORN = OpenedResourceNode, TR = TrackedResources, RD = ResourceDiff
 115    MR = ModifiedResource STR=stringbuf
 116  */
 117 #define MAX_ORN  30000
 118 #define MAX_TR    3000
 119 #define MAX_RD     300
 120 #define MAX_STR 300000
 121 #define MAX_MR    2000
 122
 123 /* All resources that have an opencount, eg. libs, devs, fonts */
 124 struct OpenedResourceNode {
 125     struct Node  node;
 126     CONST_STRPTR type;
 127     CONST_STRPTR name;
 128     APTR         addr;
 129     ULONG        count;
 130 };
 131
 132 /* All resources that LeakWatch handles. */
 133 struct TrackedResources {
 134     struct List opened;   /* List of OpenedResourceNode */
 135     IPTR        freeMem;  /* total free memory */
 136 };
 137
 138 struct ModifiedResource {
 139     struct Node  node;
 140     CONST_STRPTR type;
 141     CONST_STRPTR name;
 142     APTR         addr;
 143     ULONG        before_count;
 144     ULONG        after_count;
 145 };
 146
 147 /* store eg. new libraries, or libraries with modified opencount
 148  *
 149  */
 150 struct ResourceDiff {
 151     LONG memLost;
 152     struct List modifiedOpened;  /* contains ModifiedResource */
 153 };
 154
 155 /* static storage to avoid interfering with memleaks debugging */
 156 static struct OpenedResourceNode _ornbuf[MAX_ORN];
 157 static struct TrackedResources _trbuf[MAX_TR];
 158 static struct ResourceDiff _rdbuf[MAX_RD];
 159 static UBYTE _strbuf[MAX_STR];
 160 static struct ModifiedResource _mrbuf[MAX_MR];
 161
 162 static int next_orn = 0;
 163 static int next_tr = 0;
 164 static int next_rd = 0;
 165 static int next_str = 0;
 166 static int next_mr = 0;
 167
 168 static struct OpenedResourceNode *get_orn()
 169 {
 170     if (next_orn == MAX_ORN)
 171         return NULL;
 172     return &_ornbuf[next_orn++];
 173 }
 174
 175 static void release_orn (struct OpenedResourceNode *orn)
 176 {
 177 }
 178
 179 static struct TrackedResources *get_tr()
 180 {
 181     if (next_tr == MAX_TR)
 182         return NULL;
 183     return &_trbuf[next_tr++];
 184 }
 185
 186 static void release_tr (struct TrackedResources *tr)
 187 {
 188 }
 189
 190 static struct ResourceDiff *get_rd()
 191 {
 192     if (next_rd == MAX_RD)
 193         return NULL;
 194     return &_rdbuf[next_rd++];
 195 }
 196
 197 static void release_rd (struct ResourceDiff *rd)
 198 {
 199 }
 200
 201 static struct ModifiedResource *get_mr()
 202 {
 203     if (next_mr == MAX_MR)
 204         return NULL;
 205     return &_mrbuf[next_mr++];
 206 }
 207
 208 static void release_mr (struct ModifiedResource *mr)
 209 {
 210 }
 211
 212 CONST_STRPTR StaticStrDup (CONST_STRPTR str)
 213 {
 214     UBYTE *start = &_strbuf[next_str];
 215     UBYTE *t = start;
 216     int len;
 217
 218     if (NULL == str)
 219         str = "<unnamed>";
 220
 221     len = strlen(str);
 222     if (len + next_str + 1 > MAX_STR)
 223         return NULL;
 224
 225     while ((*t++ = *str++))
 226         ;
 227     next_str += t - start;
 228     return (CONST_STRPTR)start;
 229 }
 230
 231 void StrFree (CONST_STRPTR str)
 232 {
 233 }
 234
 235 /***********************************************************************/
 236
 237 static struct TrackedResources *NewResourcesState(void);
 238 static void DeleteResourcesState(struct TrackedResources *rs);
 239 static struct ResourceDiff *NewStateDiff(const struct TrackedResources *old,
 240                                           const struct TrackedResources *new);
 241 static void DisplayStateDiff(const struct ResourceDiff *rd, int pagelines);
 242 static void DeleteStateDiff(struct ResourceDiff *rd);
 243 static struct TrackedResources * CopyResourcesState(const struct TrackedResources *src);
 244
 245 static BOOL AddLibs(struct List *opened)
 246 {
 247     struct Library *lib;
 248
 249     Forbid();
 250     for(lib=(struct Library *)SysBase->LibList.lh_Head;
 251         lib->lib_Node.ln_Succ!=NULL;
 252         lib=(struct Library *)lib->lib_Node.ln_Succ)
 253     {
 254         struct OpenedResourceNode *orn = get_orn();
 255         if (!orn)
 256         {
 257             Permit();
 258             return FALSE;
 259         }
 260         orn->type = "Library";
 261         orn->name = StaticStrDup(lib->lib_Node.ln_Name);
 262         orn->addr = lib;
 263         orn->count = lib->lib_OpenCnt;
 264         Enqueue(opened, (struct Node *)orn);
 265     }
 266     Permit();
 267     return TRUE;
 268 }
 269
 270 static BOOL AddDevs(struct List *opened)
 271 {
 272     struct Device *dev;
 273
 274     Forbid();
 275     for(dev=(struct Device *)SysBase->DeviceList.lh_Head;
 276         dev->dd_Library.lib_Node.ln_Succ!=NULL;
 277         dev=(struct Device *)dev->dd_Library.lib_Node.ln_Succ)
 278     {
 279         struct OpenedResourceNode *orn = get_orn();
 280         if (!orn)
 281         {
 282             Permit();
 283             return FALSE;
 284         }
 285         orn->type = "Device";
 286         orn->name = StaticStrDup(dev->dd_Library.lib_Node.ln_Name);
 287         orn->addr = dev;
 288         orn->count = dev->dd_Library.lib_OpenCnt;
 289         Enqueue(opened, (struct Node *)orn);
 290     }
 291     Permit();
 292     return TRUE;
 293 }
 294
 295 static BOOL AddFonts(struct List *opened)
 296 {
 297     struct TextFont *tf;
 298
 299     Forbid();
 300     for(tf=(struct TextFont *)GfxBase->TextFonts.lh_Head;
 301         tf->tf_Message.mn_Node.ln_Succ!=NULL;
 302         tf=(struct TextFont *)tf->tf_Message.mn_Node.ln_Succ)
 303     {
 304         struct OpenedResourceNode *orn = get_orn();
 305         if (!orn)
 306         {
 307             Permit();
 308             return FALSE;
 309         }
 310         orn->type = "Font";
 311         orn->name = StaticStrDup(tf->tf_Message.mn_Node.ln_Name);
 312         orn->addr = tf;
 313         orn->count = tf->tf_Accessors;
 314         Enqueue(opened, (struct Node *)orn);
 315     }
 316     Permit();
 317     return TRUE;
 318 }
 319
 320 static BOOL AddNodeNames(struct List *opened, struct List *list, CONST_STRPTR type)
 321 {
 322     struct Node *lib;
 323
 324     Forbid();
 325     for(lib=(struct Node *)list->lh_Head;
 326         lib->ln_Succ!=NULL;
 327         lib=(struct Node *)lib->ln_Succ)
 328     {
 329         struct OpenedResourceNode *orn = get_orn();
 330         if (!orn)
 331         {
 332             Permit();
 333             return FALSE;
 334         }
 335         orn->type = type;
 336         orn->name = StaticStrDup(lib->ln_Name);
 337         orn->addr = lib;
 338         orn->count = 0;
 339         Enqueue(opened, (struct Node *)orn);
 340     }
 341     Permit();
 342     return TRUE;
 343 }
 344
 345 static BOOL AddASemaphore(struct List *opened,
 346                           struct SignalSemaphore *ss,
 347                           CONST_STRPTR name)
 348 {
 349     struct OpenedResourceNode *orn = get_orn();
 350
 351     if (!orn)
 352     {
 353         return FALSE;
 354     }
 355
 356     Forbid();
 357     orn->type = "Semaphore";
 358     orn->name = StaticStrDup(name);
 359     orn->addr = ss;
 360     orn->count = ss->ss_NestCount;
 361     Permit();
 362
 363     Enqueue(opened, (struct Node *)orn);
 364     return TRUE;
 365 }
 366
 367
 368 static BOOL AddAClass(struct List *opened,
 369                       Class *cl, CONST_STRPTR name)
 370 {
 371     struct OpenedResourceNode *orn;
 372
 373     if (NULL == cl)
 374         return TRUE;
 375
 376     orn = get_orn();
 377     if (!orn)
 378     {
 379         return FALSE;
 380     }
 381
 382     Forbid();
 383     orn->type = "Class";
 384     if (NULL == name)
 385         name = cl->cl_ID;
 386     orn->name = StaticStrDup(name);
 387     orn->addr = cl;
 388     orn->count = cl->cl_ObjectCount;
 389     Permit();
 390
 391     Enqueue(opened, (struct Node *)orn);
 392     return TRUE;
 393 }
 394
 395
 396 /* Add opencount-based resources to the tracking list. */
 397 static BOOL AddOpenedResources(struct List *opened)
 398 {
 399     struct DosInfo *di = BADDR(DOSBase->dl_Root->rn_Info);
 400
 401     if (!AddLibs(opened))
 402         return FALSE;
 403     if (!AddDevs(opened))
 404         return FALSE;
 405     if (!AddFonts(opened))
 406         return FALSE;
 407     if (!AddNodeNames(opened, &SysBase->ResourceList, "Resource"))
 408         return FALSE;
 409     if (!AddNodeNames(opened, &SysBase->IntrList, "Interrupt"))
 410         return FALSE;
 411     if (!AddNodeNames(opened, &SysBase->PortList, "Port"))
 412         return FALSE;
 413     if (!AddNodeNames(opened, &SysBase->SemaphoreList, "Semaphore"))
 414         return FALSE;
 415     if (!AddASemaphore(opened, &di->di_DevLock, "di_DevLock"))
 416         return FALSE;
 417     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->buttonclass, "button"))
 418         return FALSE;
 419     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->textclass, "text"))
 420         return FALSE;
 421     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->sliderclass, "slider"))
 422         return FALSE;
 423     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->scrollerclass, "scroller"))
 424         return FALSE;
 425     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->arrowclass, "arrow"))
 426         return FALSE;
 427     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->stringclass, "string"))
 428         return FALSE;
 429     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->listviewclass, "listview"))
 430         return FALSE;
 431     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->checkboxclass, "checkbox"))
 432         return FALSE;
 433     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->cycleclass, "cycle"))
 434         return FALSE;
 435     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->mxclass, "mx"))
 436         return FALSE;
 437     if (!AddAClass(opened, ((struct GadToolsBase_intern *)GadToolsBase)->paletteclass, "palette"))
 438         return FALSE;
 439     return TRUE;
 440 }
 441
 442 /* Get a snapshot of current resources */
 443 static struct TrackedResources *NewResourcesState(void)
 444 {
 445     struct TrackedResources *tr;
 446
 447     tr = get_tr();
 448     if (!tr)
 449         return NULL;
 450
 451     /* flush */
 452     FreeVec(AllocVec((ULONG)(~0ul/2), MEMF_ANY));
 453
 454     /* opencount-based stuff */
 455     NEWLIST(&tr->opened);
 456     if (!AddOpenedResources(&tr->opened))
 457         return NULL;
 458
 459     /* memory */
 460     tr->freeMem = AvailMem(MEMF_ANY);
 461
 462     return tr;
 463 }
 464
 465 static void DeleteResourceNode(struct OpenedResourceNode *orn)
 466 {
 467     if (!orn)
 468         return;
 469     StrFree((APTR)orn->name);
 470     orn->name = NULL;
 471     release_orn(orn);
 472 }
 473
 474 /* Free snapshot of current resources */
 475 static void DeleteResourcesState(struct TrackedResources *rs)
 476 {
 477     struct OpenedResourceNode *orn;
 478     struct OpenedResourceNode *tmp;
 479
 480     if (!rs)
 481         return;
 482
 483     for(orn=(struct OpenedResourceNode *)rs->opened.lh_Head;
 484         orn->node.ln_Succ!=NULL;
 485         orn=tmp)
 486     {
 487         tmp = (struct OpenedResourceNode *)orn->node.ln_Succ;
 488         Remove((struct Node *)orn);
 489         DeleteResourceNode(orn);
 490     }
 491     release_tr(rs);
 492 }
 493
 494 void DisplayResourcesState(const struct TrackedResources *rs, int pagelines)
 495 {
 496     struct OpenedResourceNode *orn;
 497     int currentlines;
 498
 499     if (!rs)
 500         return;
 501
 502     FPuts(Output(), "LeakWatch snapshot:\n");
 503
 504     FPrintf(Output(), " Free memory : %id bytes\n", rs->freeMem);
 505
 506     FPuts(Output(), " Opened resources:\n");
 507     currentlines = 3;
 508     for(orn=(struct OpenedResourceNode *)rs->opened.lh_Head;
 509         orn->node.ln_Succ!=NULL;
 510         orn=(struct OpenedResourceNode *)orn->node.ln_Succ)
 511     {
 512         if (currentlines >= (pagelines - 2))
 513         {
 514             ULONG buf;
 515             currentlines = 0;
 516             FPuts(Output(), "--- Press a key to continue ---\n");
 517             Flush(Input());
 518             Read(Input(), &buf, 1);
 519             Flush(Input());
 520         }
 521         FPrintf(Output(), " %s: %s (0x%ix) : %lu\n",
 522                 orn->type, orn->name, orn->addr, orn->count);
 523         currentlines++;
 524     }
 525     FPuts(Output(), "-- end of state\n");
 526 }
 527
 528 /* Compute the delta between 2 resources snapshots.
 529  * the ResourceDiff can have dangling pointers in old and nu, so dont clear
 530  * them before being done with rd in the processing loop
 531  */
 532 static struct ResourceDiff *NewStateDiff(const struct TrackedResources *old,
 533                                           const struct TrackedResources *nu)
 534 {
 535     /* FIXME */
 536     struct OpenedResourceNode *orn;
 537     struct ResourceDiff *rd;
 538
 539     rd = get_rd();
 540     if (!rd)
 541         return NULL;
 542
 543     NEWLIST(&rd->modifiedOpened);
 544
 545     for(orn=(struct OpenedResourceNode *)nu->opened.lh_Head;
 546         orn->node.ln_Succ!=NULL;
 547         orn=(struct OpenedResourceNode *)orn->node.ln_Succ)
 548     {
 549         struct OpenedResourceNode *other;
 550         BOOL seen = FALSE;
 551
 552         for(other=(struct OpenedResourceNode *)old->opened.lh_Head;
 553             other->node.ln_Succ!=NULL;
 554             other=(struct OpenedResourceNode *)other->node.ln_Succ)
 555         {
 556             if (orn->addr == other->addr)
 557             {
 558                 if (!strcmp(orn->name, other->name))
 559                 {
 560                     seen = TRUE;
 561                     if (orn->count != other->count)
 562                     {
 563                         struct ModifiedResource *mr = get_mr();
 564                         if (!mr)
 565                             return NULL;
 566                         mr->type = other->type;
 567                         mr->name = other->name;
 568                         mr->addr = other->addr;
 569                         mr->before_count = other->count;
 570                         mr->after_count = orn->count;
 571                         Enqueue(&rd->modifiedOpened, (struct Node *)mr);
 572                     }
 573                 }
 574             }
 575         }
 576         if (!seen)
 577         {
 578             struct ModifiedResource *mr = get_mr();
 579             if (!mr)
 580                 return NULL;
 581
 582             mr->type = orn->type;
 583             mr->name = orn->name;
 584             mr->addr = orn->addr;
 585             mr->before_count = 0;
 586             mr->after_count = orn->count;
 587
 588             Enqueue(&rd->modifiedOpened, (struct Node *)mr);
 589         }
 590     }
 591
 592
 593     rd->memLost = old->freeMem - nu->freeMem;
 594
 595     return rd;
 596 }
 597
 598 static void DisplayStateDiff(const struct ResourceDiff *rd, int pagelines)
 599 {
 600     struct ModifiedResource *mr;
 601     int currentlines;
 602
 603     FPuts(Output(), "LeakWatch report:\n");
 604     FPrintf(Output(), " Memory lost : %ld byte%s\n", rd->memLost, (rd->memLost > 1) ? "s" : "");
 605
 606     FPuts(Output(), " Open count:\n");
 607     currentlines = 3;
 608     for(mr=(struct ModifiedResource *)rd->modifiedOpened.lh_Head;
 609         mr->node.ln_Succ!=NULL;
 610         mr=(struct ModifiedResource *)mr->node.ln_Succ)
 611     {
 612         if (currentlines >= (pagelines - 2))
 613         {
 614             ULONG buf;
 615             currentlines = 0;
 616             FPuts(Output(), "--- Press a key to continue ---\n");
 617             Flush(Input());
 618             Read(Input(), &buf, 1);
 619             Flush(Input());
 620         }
 621         FPrintf(Output(), " %s: %s (0x%ix) : %lu -> %lu\n",
 622                 mr->type, mr->name, mr->addr, mr->before_count,
 623                 mr->after_count);
 624         currentlines++;
 625     }
 626
 627     FPuts(Output(), "-- end of diff\n");
 628
 629 }
 630
 631 static void DeleteStateDiff(struct ResourceDiff *rd)
 632 {
 633     /* FIXME */
 634     struct ModifiedResource *mr;
 635     struct ModifiedResource *tmpmr;
 636
 637     if (!rd)
 638         return;
 639
 640     for(mr=(struct ModifiedResource *)rd->modifiedOpened.lh_Head;
 641         mr->node.ln_Succ!=NULL;
 642         mr=tmpmr)
 643     {
 644         tmpmr = (struct ModifiedResource *)mr->node.ln_Succ;
 645         Remove((struct Node *)mr);
 646
 647         release_mr(mr);
 648     }
 649
 650     release_rd(rd);
 651 }
 652
 653 static struct OpenedResourceNode * CopyResourcesNode(const struct OpenedResourceNode *src)
 654 {
 655     struct OpenedResourceNode *orn = get_orn();
 656     if (!orn)
 657         return NULL;
 658     orn->name = StaticStrDup(src->name);
 659     orn->addr = src->addr;
 660     orn->count = src->count;
 661     return orn;
 662 }
 663
 664 static struct TrackedResources * CopyResourcesState(const struct TrackedResources *src)
 665 {
 666     struct TrackedResources *tr;
 667     struct OpenedResourceNode *orn;
 668
 669     tr = get_tr();
 670     if (!tr)
 671         return NULL;
 672
 673     /* opencount-based stuff */
 674     NEWLIST(&tr->opened);
 675
 676     for(orn=(struct OpenedResourceNode *)src->opened.lh_Head;
 677         orn->node.ln_Succ!=NULL;
 678         orn=(struct OpenedResourceNode *)orn->node.ln_Succ)
 679     {
 680         struct OpenedResourceNode *nc;
 681
 682         nc = CopyResourcesNode(orn);
 683         Enqueue(&tr->opened, (struct Node *)nc);
 684     }
 685
 686     /* memory */
 687     tr->freeMem = src->freeMem;
 688
 689     return tr;
 690 }
 691
 692 int __nocommandline;
 693
 694 void open_libs()
 695 {
 696     GadToolsBase = OpenLibrary ( "gadtools.library", 0L );
 697 }
 698
 699 void close_libs()
 700 {
 701     CloseLibrary ( GadToolsBase );
 702 }
 703
 704 int main(void)
 705 {
 706     struct TrackedResources *crs = NULL;
 707     struct TrackedResources *start_rs = NULL;
 708     BOOL quitme = FALSE;
 709     int numlines = 30;
 710     ULONG  portsig;
 711     struct MsgPort *port;
 712
 713     port = CreateMsgPort();
 714     if (!port)
 715         return 2;
 716     port->mp_Node.ln_Name = "LeakWatch";
 717     port->mp_Node.ln_Pri  = 0;
 718     AddPort(port);
 719
 720     portsig = 1L << port->mp_SigBit;
 721
 722     open_libs();
 723
 724     FPuts(Output(), "LeakWatch running, CTRL-C to exit, CTRL-E to watch for leaks since beginning, CTRL-F to watch for leaks since last CTRL-F, CTRL-D for an usage snapshot\n");
 725
 726     crs = NewResourcesState();
 727     if (NULL == crs)
 728         quitme = TRUE;
 729     else
 730         start_rs = CopyResourcesState(crs);
 731
 732     while(!quitme)
 733     {
 734         ULONG signals;
 735
 736         signals = Wait(portsig | SIGBREAKF_CTRL_F | SIGBREAKF_CTRL_E | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_C);
 737
 738         if (signals & SIGBREAKF_CTRL_D)
 739         {
 740             struct TrackedResources *tr;
 741
 742             tr = NewResourcesState();
 743             if (NULL == tr)
 744             {
 745                 quitme = TRUE;
 746                 break;
 747             }
 748             DisplayResourcesState(tr, numlines);
 749             DeleteResourcesState(tr);
 750         }
 751         if (signals & SIGBREAKF_CTRL_E)
 752         {
 753             struct ResourceDiff *rd = NULL;
 754
 755             DeleteResourcesState(crs);
 756             crs = NewResourcesState();
 757             if (NULL == crs)
 758             {
 759                 quitme = TRUE;
 760                 break;
 761             }
 762             /*  DisplayResourcesState(crs); */ /* only for debug */
 763             rd = NewStateDiff(start_rs, crs);
 764             DisplayStateDiff(rd, numlines);
 765             DeleteStateDiff(rd);
 766         }
 767         if (signals & SIGBREAKF_CTRL_F)
 768         {
 769             struct TrackedResources *ors = crs;
 770             struct ResourceDiff *rd = NULL;
 771
 772             crs = NewResourcesState();
 773             if (NULL == crs)
 774             {
 775                 quitme = TRUE;
 776                 break;
 777             }
 778             rd = NewStateDiff(ors, crs);
 779             DisplayStateDiff(rd, numlines);
 780             DeleteStateDiff(rd);
 781             DeleteResourcesState(ors);
 782         }
 783         if (signals & SIGBREAKF_CTRL_C)
 784         {
 785             quitme = TRUE;
 786         }
 787         if (signals & portsig)
 788         {
 789             struct Message *msg;
 790
 791             while((msg = (struct Message *)GetMsg(port)))
 792             {
 793                 D(bug("Received watch message.\n"));
 794
 795                 ReplyMsg(msg);
 796             }
 797
 798         }
 799     } /* while(!quitme) */
 800
 801     DeleteResourcesState(crs);
 802     DeleteResourcesState(start_rs);
 803
 804     close_libs();
 805
 806     if (port)
 807     {
 808         RemPort(port);
 809         DeleteMsgPort(port);
 810     }
 811     return 0;
 812 }
 813