compiler/arossupport/rt.c

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