compiler/arossupport/rt.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Basic functions for ressource tracking
   6     Lang: english
   7 */
   8 #include "rt.h"
   9 #if 0
  10 #define ENABLE_RT 0     /* no RT inside this file */
  11 #define RT_INTERNAL 1
  12 #include <aros/rt.h>
  13
  14 #include <exec/lists.h>
  15 #include <aros/system.h>
  16 #include <exec/tasks.h>
  17 #include <exec/ports.h>
  18 #include <exec/execbase.h>
  19 #include <stdarg.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <proto/dos.h>
  23 #include <proto/intuition.h>
  24 #include <proto/alib.h>
  25 #include "etask.h"
  26 #endif
  27 #include <string.h>
  28 #include <exec/memory.h>
  29 #include <proto/arossupport.h>
  30 #include <proto/exec.h>
  31
  32 /* iaint: Use the debugging macros from now on. */
  33 #include <aros/debug.h>
  34
  35 RTData * intRTD = NULL; /* Internal pointer in case no ETask is available */
  36 RTDesc const * RT_Resources[RTT_MAX];
  37
  38 /*****************************************************************************
  39
  40     NAME */
  41         #include <aros/rt.h>
  42
  43         void RT_IntInitB (
  44
  45 /*  SYNOPSIS */
  46         void)
  47
  48 /*  FUNCTION
  49         Begin initialization of resource tracking.
  50
  51     INPUTS
  52         none
  53
  54     RESULT
  55         none
  56
  57     NOTES
  58
  59     EXAMPLE
  60
  61     BUGS
  62
  63     SEE ALSO
  64
  65     INTERNALS
  66
  67     HISTORY
  68         24-12-95    digulla created
  69
  70 ******************************************************************************/
  71 {
  72     AROS_GET_SYSBASE_OK
  73     RTData * rtd;
  74
  75     if ((rtd = GetRTData ()))
  76     {
  77         D(bug ("RT_Init() called twice %p\n", rtd) );
  78         return;
  79     }
  80
  81     if (!(rtd = AllocMem (sizeof (RTData), MEMF_ANY)) )
  82     {
  83         D(bug ("RT_Init(): No memory\n") );
  84         return;
  85     }
  86
  87     SetRTData (rtd);
  88
  89     rtd->rtd_Version  = RT_VERSION;
  90     rtd->rtd_StackPtr = STACKDEPTH;
  91 } /* RT_IntInitB */
  92
  93 /*****************************************************************************
  94
  95     NAME */
  96         #include <aros/rt.h>
  97
  98         void RT_IntInitE (
  99
 100 /*  SYNOPSIS */
 101         void)
 102
 103 /*  FUNCTION
 104         End initialization of resource tracking.
 105
 106     INPUTS
 107         none
 108
 109     RESULT
 110         none
 111
 112     NOTES
 113
 114     EXAMPLE
 115
 116     BUGS
 117
 118     SEE ALSO
 119
 120     INTERNALS
 121
 122     HISTORY
 123         24-12-95    digulla created
 124
 125 ******************************************************************************/
 126 {
 127     RTData * rtd;
 128     int      t, i;
 129
 130     rtd = GetRTData ();
 131
 132     for (t=0; t<RTT_MAX; t++)
 133     {
 134         for (i=0; i<HASH_SIZE; i++)
 135         {
 136             NEWLIST(&rtd->rtd_ResHash[t][i]);
 137         }
 138     }
 139
 140     D(bug ("RT_Init(): RT up and kicking in %s mode\n"
 141         , intRTD ? "internal" : "ETask"
 142     ) );
 143 } /* RT_IntInitE */
 144
 145 /*****************************************************************************
 146
 147     NAME */
 148         #include <aros/rt.h>
 149
 150         void RT_IntExitB (
 151
 152 /*  SYNOPSIS */
 153         void)
 154
 155 /*  FUNCTION
 156         Stops the resource tracking. All resources which are still allocated
 157         are printed and then released.
 158
 159     INPUTS
 160         none
 161
 162     RESULT
 163         none
 164
 165     NOTES
 166
 167     EXAMPLE
 168
 169     BUGS
 170
 171     SEE ALSO
 172
 173     INTERNALS
 174         Free the resources from back to front. This allows to sort the
 175         resources (ie. windows on a screen are closed before the screen,
 176         etc).
 177
 178     HISTORY
 179         24-12-95    digulla created
 180
 181 ******************************************************************************/
 182 {
 183     RTData * rtd;
 184     RTNode * rt, * next;
 185     int      t, i;
 186
 187     if (!(rtd = GetRTData ()) )
 188         return;
 189
 190     for (t=RTT_MAX-1; t>=0; t--)
 191     {
 192         for (i=0; i<HASH_SIZE; i++)
 193         {
 194             for (next=(RTNode *)GetHead(&rtd->rtd_ResHash[t][i]); (rt=next); )
 195             {
 196                 next = (RTNode *)GetSucc (rt);
 197
 198                 RT_FreeResource (rtd, t, rt);
 199             }
 200         }
 201     }
 202 } /* RT_IntExitB */
 203
 204 /*****************************************************************************
 205
 206     NAME */
 207         #include <aros/rt.h>
 208
 209         void RT_IntExitE (
 210
 211 /*  SYNOPSIS */
 212         void)
 213
 214 /*  FUNCTION
 215         Stops the resource tracking. All resources which are still allocated
 216         are printed and then released.
 217
 218     INPUTS
 219         none
 220
 221     RESULT
 222         none
 223
 224     NOTES
 225
 226     EXAMPLE
 227
 228     BUGS
 229
 230     SEE ALSO
 231
 232     INTERNALS
 233         Free the resources from back to front. This allows to sort the
 234         resources (ie. windows on a screen are closed before the screen,
 235         etc).
 236
 237     HISTORY
 238         24-12-95    digulla created
 239
 240 ******************************************************************************/
 241 {
 242     AROS_GET_SYSBASE_OK
 243     RTData * rtd;
 244
 245     if (!(rtd = GetRTData ()) )
 246         return;
 247
 248     FreeMem (rtd, sizeof (RTData));
 249
 250     SetRTData (NULL);
 251 } /* RT_IntExitE */
 252
 253 /*****************************************************************************
 254
 255     NAME */
 256         #include <aros/rt.h>
 257
 258         IPTR RT_IntAdd (
 259
 260 /*  SYNOPSIS */
 261         int          rtt,
 262         const char * file,
 263         int          line,
 264         ...)
 265
 266 /*  FUNCTION
 267         Adds a resource to be tracked. The arguments after
 268         line depend on the type of resource to be traced:
 269
 270         RTT_ALLOCMEM:     APTR          memPtr,
 271                           ULONG         size)
 272
 273     INPUTS
 274         rtt - Type of the resource
 275         file - The file RT_IntAdd was called it
 276         line - The line of the file
 277         task - The task to be added
 278         memPtr - Pointer to a piece of memory to be tracked
 279         size - The size of the memory beginning at memPtr
 280
 281     RESULT
 282         none
 283
 284     NOTES
 285
 286     EXAMPLE
 287
 288     BUGS
 289
 290     SEE ALSO
 291
 292     INTERNALS
 293
 294     HISTORY
 295         24-12-95    digulla created
 296
 297 ******************************************************************************/
 298 {
 299     AROS_GET_SYSBASE_OK
 300     RTData * rtd;
 301     IPTR     ret;
 302     va_list  args;
 303     RTNode * rtnew;
 304     BOOL     success;
 305
 306     if (!(rtd = GetRTData ()) )
 307         return FALSE;
 308
 309     if (!(rtnew = AllocMem (GetRTSize(rtt), MEMF_ANY)) )
 310     {
 311         D(bug ("RT_IntAdd: Out of memory\n") );
 312         return FALSE;
 313     }
 314
 315     rtnew->File = file;
 316     rtnew->Line = line;
 317     rtnew->Flags = 0;
 318
 319     va_start (args, line);
 320
 321     success = FALSE;
 322
 323     ret = (*GetRTAllocFunc(rtt))
 324     (
 325         rtd,
 326         rtnew,
 327         args,
 328         &success
 329     );
 330
 331     va_end (args);
 332
 333     if (success)
 334     {
 335         AddTail ((struct List *)&rtd->rtd_ResHash[rtt][CALCHASH(HASH_BASE(rtnew))]
 336             ,(struct Node *)rtnew
 337         );
 338     }
 339     else
 340     {
 341         FreeMem (rtnew, GetRTSize(rtt));
 342     }
 343
 344     return ret;
 345 } /* RT_IntAdd */
 346
 347 /*****************************************************************************
 348
 349     NAME */
 350         #include <aros/rt.h>
 351
 352         void RT_IntTrack (
 353
 354 /*  SYNOPSIS */
 355         int          rtt,
 356         const char * file,
 357         int          line,
 358         APTR         res,
 359         ...)
 360
 361 /*  FUNCTION
 362         Adds a resource to be tracked. The arguments after
 363         line depend on the type of resource to be traced.
 364         The resource›is marked as "must not be freed by the
 365         user".
 366
 367     INPUTS
 368         rtt - Type of the resource
 369         file - The file RT_IntAdd was called it
 370         line - The line of the file
 371         res - Pointer to the resouce
 372
 373     RESULT
 374         none
 375
 376     NOTES
 377
 378     EXAMPLE
 379
 380     BUGS
 381
 382     SEE ALSO
 383
 384     INTERNALS
 385
 386     HISTORY
 387         24-12-95    digulla created
 388
 389 ******************************************************************************/
 390 {
 391     AROS_GET_SYSBASE_OK
 392     RTData   * rtd;
 393     va_list    args;
 394     Resource * rtnew;
 395
 396     if (!(rtd = GetRTData ()) )
 397         return;
 398
 399     if (!(rtnew = AllocMem (GetRTSize(rtt), MEMF_ANY|MEMF_CLEAR)) )
 400     {
 401         D(bug("RT_IntAdd: Out of memory\n"));
 402     }
 403     else
 404     {
 405         rtnew->Node.File  = file;
 406         rtnew->Node.Line  = line;
 407         rtnew->Node.Flags = RTNF_DONT_FREE;
 408         rtnew->Resource   = res;
 409
 410         va_start (args, res);
 411
 412         va_end (args);
 413
 414         AddTail ((struct List *)&rtd->rtd_ResHash[rtt][CALCHASH(HASH_BASE(rtnew))]
 415             , (struct Node *)rtnew
 416         );
 417     }
 418 } /* RT_IntTrack */
 419
 420 /*****************************************************************************
 421
 422     NAME */
 423         #include <aros/rt.h>
 424
 425         IPTR RT_IntCheck (
 426
 427 /*  SYNOPSIS */
 428         int          rtt,
 429         const char * file,
 430         int          line,
 431         int          op,
 432         ...)
 433
 434 /*  FUNCTION
 435         Checks a resource. Will print an error if the resource is not found
 436         or has already been freed or if the type of the resource doesn't
 437         match. The arguments after line depend on the type of resource to
 438         be traced:
 439
 440         RTT_ALLOCMEM:     APTR          memPtr,
 441                         ULONG         size)
 442
 443     INPUTS
 444         rtt - Type of the resource
 445         file - The file RT_IntCheck was called it
 446         line - The line of the file
 447         task - The task to be added
 448         memPtr - Pointer to a piece of memory to be tracked
 449         size - The size of the memory beginning at memPtr
 450
 451     RESULT
 452         none
 453
 454     NOTES
 455         All strings must be static.
 456
 457     EXAMPLE
 458
 459     BUGS
 460
 461     SEE ALSO
 462
 463     INTERNALS
 464
 465     HISTORY
 466         24-12-95    digulla created
 467
 468 ******************************************************************************/
 469 {
 470     RTData * rtd;
 471     RTNode * rt;
 472     va_list  args;
 473     IPTR     ret;
 474
 475     if (!(rtd = GetRTData ()) )
 476         return FALSE;
 477
 478     va_start (args, op);
 479
 480     if (GetRTCheckFunc(rtt))
 481     {
 482         ret = (*(GetRTCheckFunc(rtt)))
 483         (
 484             rtd,
 485             rtt,
 486             file,
 487             line,
 488             op,
 489             args
 490         );
 491     }
 492     else
 493     {
 494         ret = (*(GetRTSearchFunc(rtt)))
 495         (
 496             rtd,
 497             rtt,
 498             &rt,
 499             args
 500         );
 501
 502         if (ret != RT_SEARCH_FOUND)
 503         {
 504             ret = (*(GetRTShowError(rtt)))
 505             (
 506                 rtd,
 507                 rtt,
 508                 rt,
 509                 ret,
 510                 RT_CHECK,
 511                 file,
 512                 line,
 513                 args
 514             );
 515         }
 516     }
 517
 518     va_end (args);
 519
 520     return ret;
 521 } /* RT_IntCheck */
 522
 523 /*****************************************************************************
 524
 525     NAME */
 526         #include <aros/rt.h>
 527
 528         IPTR RT_IntFree (
 529
 530 /*  SYNOPSIS */
 531         int          rtt,
 532         const char * file,
 533         int          line,
 534         ...)
 535
 536 /*  FUNCTION
 537         Stops tracing of a resource. The arguments after
 538         line depend on the type of resource to be traced.
 539
 540     INPUTS
 541         rtt - Type of the resource
 542         file - The file RT_IntAdd was called it
 543         line - The line of the file
 544
 545     RESULT
 546         none
 547
 548     NOTES
 549         All strings must be static.
 550
 551     EXAMPLE
 552
 553     BUGS
 554
 555     SEE ALSO
 556
 557     INTERNALS
 558
 559     HISTORY
 560         24-12-95    digulla created
 561
 562 ******************************************************************************/
 563 {
 564     RTData * rtd;
 565     IPTR     ret;
 566     va_list  args;
 567     RTNode * rt;
 568
 569     if (!(rtd = GetRTData ()) )
 570         return FALSE;
 571
 572     va_start (args, line);
 573
 574     ret = (*(GetRTSearchFunc(rtt)))
 575     (
 576         rtd,
 577         rtt,
 578         &rt,
 579         args
 580     );
 581
 582     if (ret == RT_SEARCH_FOUND && rt && !(rt->Flags & RTNF_DONT_FREE))
 583     {
 584         ret = (*(GetRTFreeFunc(rtt))) (rtd, rt);
 585
 586         Remove ((struct Node *)rt);
 587         FreeMem (rt, GetRTSize(rtt));
 588     }
 589     else
 590     {
 591         ret = (*(GetRTShowError(rtt)))
 592         (
 593             rtd,
 594             rtt,
 595             rt,
 596             ret,
 597             RT_FREE,
 598             file,
 599             line,
 600             args
 601         );
 602     }
 603
 604     va_end (args);
 605
 606     return ret;
 607 } /* RT_IntFree */
 608
 609
 610 /*****************************************************************************
 611
 612     NAME */
 613         #include <aros/rt.h>
 614
 615         void RT_IntEnter (
 616
 617 /*  SYNOPSIS */
 618         const char * function,
 619         const char * file,
 620         int          line)
 621
 622 /*  FUNCTION
 623         Tells the RT that a new function is about to be entered. This is used
 624         to make it easier to track an error.
 625
 626     INPUTS
 627         function - name of the function to be entered
 628         file - file with the call of the function
 629         line - Line-number of the call
 630
 631     RESULT
 632         none
 633
 634     NOTES
 635         All strings must be static.
 636
 637     EXAMPLE
 638
 639     BUGS
 640
 641     SEE ALSO
 642
 643     INTERNALS
 644
 645     HISTORY
 646         24-12-95    digulla created
 647
 648 ******************************************************************************/
 649 {
 650     RTData * rtd;
 651
 652     if (!(rtd = GetRTData ()) )
 653         return;
 654
 655     if (rtd->rtd_StackPtr == 0)
 656         return;
 657
 658     -- rtd->rtd_StackPtr;
 659
 660     rtd->rtd_CallStack[rtd->rtd_StackPtr].Function = function;
 661     rtd->rtd_CallStack[rtd->rtd_StackPtr].File     = file;
 662     rtd->rtd_CallStack[rtd->rtd_StackPtr].Line     = line;
 663 } /* RT_IntEnter */
 664
 665
 666 /*****************************************************************************
 667
 668     NAME */
 669         #include <aros/rt.h>
 670
 671         void RT_IntLeave (
 672
 673 /*  SYNOPSIS */
 674         void)
 675
 676 /*  FUNCTION
 677         Tells the RT that a the function has been left.
 678
 679     INPUTS
 680         none
 681
 682     RESULT
 683         none
 684
 685     NOTES
 686
 687     EXAMPLE
 688
 689     BUGS
 690
 691     SEE ALSO
 692
 693     INTERNALS
 694
 695     HISTORY
 696         24-12-95    digulla created
 697
 698 ******************************************************************************/
 699 {
 700     RTData * rtd;
 701
 702     if (!(rtd = GetRTData ()) )
 703         return;
 704
 705     if (rtd->rtd_StackPtr == STACKDEPTH)
 706         return;
 707
 708     rtd->rtd_CallStack[rtd->rtd_StackPtr].Function = NULL;
 709     rtd->rtd_CallStack[rtd->rtd_StackPtr].File     = NULL;
 710     rtd->rtd_CallStack[rtd->rtd_StackPtr].Line     = 0;
 711
 712     rtd->rtd_StackPtr ++;
 713 } /* RT_IntLeave */
 714
 715
 716 /*****************************************************************************
 717
 718     NAME */
 719         #include <aros/rt.h>
 720
 721         void RT_ShowStack (
 722
 723 /*  SYNOPSIS */
 724         RTNode * node)
 725
 726 /*  FUNCTION
 727         Prints the contents of the callstack stored in the node.
 728
 729     INPUTS
 730         node - The node with the callstack to be printed
 731
 732     RESULT
 733         none
 734
 735     NOTES
 736
 737     EXAMPLE
 738
 739     BUGS
 740
 741     SEE ALSO
 742
 743     INTERNALS
 744
 745     HISTORY
 746         24-12-95    digulla created
 747
 748 ******************************************************************************/
 749 {
 750 #if 0
 751     RTData * rtd;
 752     int      t;
 753
 754     if (!(rtd = GetRTData ()) )
 755         return;
 756
 757     for (t=0; t<KEEPDEPTH && node->Stack[t].Function; t++)
 758         D(bug(("    %s (%s:%d)\n"
 759             , node->Stack[t].Function
 760             , node->Stack[t].File
 761             , node->Stack[t].Line
 762         ));
 763 #endif
 764 } /* RT_ShowStack */
 765
 766
 767 /*****************************************************************************
 768
 769     NAME */
 770         #include <aros/rt.h>
 771
 772         void RT_ShowRTStack (
 773
 774 /*  SYNOPSIS */
 775         void)
 776
 777 /*  FUNCTION
 778         Prints the contents of the callstack built by RT_Enter() and
 779         RT_Leave().
 780
 781     INPUTS
 782         none
 783
 784     RESULT
 785         none
 786
 787     NOTES
 788
 789     EXAMPLE
 790
 791     BUGS
 792
 793     SEE ALSO
 794
 795     INTERNALS
 796
 797     HISTORY
 798         24-12-95    digulla created
 799
 800 ******************************************************************************/
 801 {
 802     RTData * rtd;
 803     int t;
 804
 805     if (!(rtd = GetRTData ()) )
 806         return;
 807
 808     for (t=0; t<=rtd->rtd_StackPtr; t++)
 809     {
 810         D(bug("    %s (%s:%d)\n"
 811             , rtd->rtd_CallStack[t].Function
 812             , rtd->rtd_CallStack[t].File
 813             , rtd->rtd_CallStack[t].Line
 814         ));
 815     }
 816 } /* RT_ShowRTStack */
 817
 818
 819 /*****************************************************************************
 820
 821     NAME */
 822         #include <aros/rt.h>
 823
 824         void RT_FreeResource (
 825
 826 /*  SYNOPSIS */
 827         RTData * rtd,
 828         int      rtt,
 829         RTNode * rtnode)
 830
 831 /*  FUNCTION
 832         Free a resource after the task that allocated it, died. Also
 833         print a nasty message about this.
 834
 835     INPUTS
 836         rt - The node with the resource to be freed.
 837
 838     RESULT
 839         none
 840
 841     NOTES
 842
 843     EXAMPLE
 844
 845     BUGS
 846
 847     SEE ALSO
 848
 849     INTERNALS
 850         Don't free the node or remove it from the list. This is done
 851         elsewhere.
 852
 853     HISTORY
 854         24-12-95    digulla created
 855
 856 ******************************************************************************/
 857 {
 858     AROS_GET_SYSBASE_OK
 859     if (!rtd && !(rtd = GetRTData ()))
 860         return;
 861
 862     if (!(rtnode->Flags & RTNF_DONT_FREE) )
 863     {
 864         /* Print an error */
 865         (void) (*(GetRTShowError(rtt)))
 866         (
 867             rtd,
 868             rtt,
 869             rtnode,
 870             0UL,
 871             RT_EXIT,
 872             NULL,
 873             0L,
 874             NULL
 875         );
 876
 877         /* free the resource */
 878         (void) (*(GetRTFreeFunc(rtt))) (rtd, rtnode);
 879     }
 880
 881     /* Remove resource from list and free it */
 882     Remove ((struct Node *)rtnode);
 883     FreeMem (rtnode, GetRTSize(rtt));
 884
 885 } /* RT_FreeResource */
 886
 887
 888 /**************************************
 889         Utility functions
 890 **************************************/
 891
 892 BOOL CheckPtr (APTR ptr, ULONG flags)
 893 {
 894     if
 895     (
 896         (!ptr && !(flags & NULL_PTR))
 897         || (((IPTR)ptr & 3) && (flags & ALIGNED_PTR))
 898     )
 899     {
 900         return FALSE;
 901     }
 902
 903
 904     return TRUE;
 905 } /* CheckPtr */
 906
 907 BOOL CheckArea (APTR ptr, ULONG size, ULONG flags)
 908 {
 909     if
 910     (
 911         (size & 0x8000000)
 912         || !CheckPtr (ptr+size-1, flags)
 913     )
 914         return FALSE;
 915
 916     return TRUE;
 917 } /* CheckArea */
 918
 919 IPTR RT_Search (RTData * rtd, int rtt, RTNode ** rtptr, va_list args)
 920 {
 921     Resource * rt;
 922     APTR     * res;
 923
 924     res = va_arg (args, APTR);
 925
 926     ForeachNode (&rtd->rtd_ResHash[rtt][CALCHASH(res)], rt)
 927     {
 928         if (rt->Resource == res)
 929         {
 930             *rtptr = (RTNode *)rt;
 931
 932             return RT_SEARCH_FOUND;
 933         }
 934     }
 935
 936     return RT_SEARCH_NOT_FOUND;
 937 } /* RT_Search */