compiler/arossupport/rt_exec.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
   9 #include "rt.h"
  10 #if 0
  11 #define ENABLE_RT 0     /* no RT inside this file */
  12 #define RT_INTERNAL 1
  13 #include <aros/rt.h>
  14
  15 #include <exec/lists.h>
  16 #include <aros/system.h>
  17 #include <exec/execbase.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include "etask.h"
  21 #endif
  22 #include <exec/tasks.h>
  23 #include <exec/ports.h>
  24 #include <exec/memory.h>
  25 #include <stdarg.h>
  26 #include <proto/exec.h>
  27 #include <proto/arossupport.h>
  28 #include <proto/alib.h>
  29
  30 typedef struct
  31 {
  32     RTNode Node;
  33     APTR   Memory;
  34     ULONG  Size;
  35     ULONG  Flags;
  36 }
  37 MemoryResource;
  38
  39 typedef struct
  40 {
  41     RTNode           Node;
  42     struct MsgPort * Port;
  43 }
  44 PortResource;
  45
  46 typedef struct
  47 {
  48     RTNode           Node;
  49     struct Library * Lib;
  50     STRPTR           Name;
  51     ULONG            Version;
  52 }
  53 LibraryResource;
  54
  55 static IPTR RT_AllocMem (RTData * rtd, MemoryResource * rt, va_list args, BOOL * success);
  56 static IPTR RT_FreeMem (RTData * rtd, MemoryResource * rt);
  57 static IPTR RT_SearchMem (RTData * rtd, int rtt, MemoryResource ** rtptr, va_list args);
  58 static IPTR RT_ShowErrorMem (RTData * rtd, int rtt, MemoryResource *, IPTR, int, const char * file, ULONG line, va_list);
  59
  60 static IPTR RT_AllocVec (RTData * rtd, MemoryResource * rt, va_list args, BOOL * success);
  61 static IPTR RT_FreeVec (RTData * rtd, MemoryResource * rt);
  62 static IPTR RT_SearchVec (RTData * rtd, int rtt, MemoryResource ** rtptr, va_list args);
  63 static IPTR RT_ShowErrorVec (RTData * rtd, int, MemoryResource *, IPTR, int, const char * file, ULONG line, va_list);
  64
  65 static IPTR RT_CreatePort (RTData * rtd, PortResource * rt, va_list args, BOOL * success);
  66 static IPTR RT_DeletePort (RTData * rtd, PortResource * rt);
  67 static IPTR RT_ShowErrorPort (RTData * rtd, int, PortResource *, IPTR, int, const char * file, ULONG line, va_list);
  68 static IPTR RT_CheckPort (RTData * rtd, int desc, const char * file, ULONG line, ULONG op, va_list args);
  69
  70 static IPTR RT_OpenLibrary (RTData * rtd, LibraryResource * rt, va_list args, BOOL * success);
  71 static IPTR RT_CloseLibrary (RTData * rtd, LibraryResource * rt);
  72 static IPTR RT_ShowErrorLib (RTData * rtd, int, LibraryResource *, IPTR, int, const char * file, ULONG line, va_list);
  73
  74 static const RTDesc RT_ExecResources[] =
  75 {
  76     { /* RTT_ALLOCMEM */
  77         sizeof (MemoryResource),
  78         (RT_AllocFunc) RT_AllocMem,
  79         (RT_FreeFunc)  RT_FreeMem,
  80         (RT_SearchFunc)RT_SearchMem,
  81         (RT_ShowError) RT_ShowErrorMem,
  82         NULL, /* Check */
  83     },
  84     { /* RTT_ALLOCVEC */
  85         sizeof (MemoryResource),
  86         (RT_AllocFunc) RT_AllocVec,
  87         (RT_FreeFunc)  RT_FreeVec,
  88         (RT_SearchFunc)RT_SearchVec,
  89         (RT_ShowError) RT_ShowErrorVec,
  90         NULL, /* Check */
  91     },
  92     { /* RTT_PORT */
  93         sizeof (PortResource),
  94         (RT_AllocFunc) RT_CreatePort,
  95         (RT_FreeFunc)  RT_DeletePort,
  96         RT_Search,
  97         (RT_ShowError) RT_ShowErrorPort,
  98         (RT_CheckFunc) RT_CheckPort,
  99     },
 100     { /* RTT_LIBRARY */
 101         sizeof (LibraryResource),
 102         (RT_AllocFunc) RT_OpenLibrary,
 103         (RT_FreeFunc)  RT_CloseLibrary,
 104         RT_Search,
 105         (RT_ShowError) RT_ShowErrorLib,
 106         NULL, /* Check */
 107     },
 108 };
 109
 110 void RT_InitExec (void)
 111 {
 112     RT_Resources[RTT_ALLOCMEM] = &RT_ExecResources[0];
 113     RT_Resources[RTT_ALLOCVEC] = &RT_ExecResources[1];
 114     RT_Resources[RTT_PORT]     = &RT_ExecResources[2];
 115     RT_Resources[RTT_LIBRARY]  = &RT_ExecResources[3];
 116 }
 117
 118 void RT_ExitExec (void)
 119 {
 120 }
 121
 122 /**************************************
 123            RT Memory
 124 **************************************/
 125
 126 static IPTR RT_AllocMem (RTData * rtd, MemoryResource * rt, va_list args, BOOL * success)
 127 {
 128     AROS_GET_SYSBASE_OK
 129     rt->Size = va_arg (args, ULONG);
 130     rt->Flags = va_arg (args, ULONG);
 131
 132     rt->Memory = AllocMem (rt->Size, rt->Flags);
 133
 134     if (rt->Memory)
 135         *success = TRUE;
 136
 137     return (IPTR)(rt->Memory);
 138 } /* RT_AllocMem */
 139
 140 static IPTR RT_FreeMem (RTData * rtd, MemoryResource * rt)
 141 {
 142     AROS_GET_SYSBASE_OK
 143     FreeMem (rt->Memory, rt->Size);
 144
 145     return TRUE;
 146 } /* RT_FreeMem */
 147
 148 static IPTR RT_SearchMem (RTData * rtd, int rtt, MemoryResource ** rtptr,
 149         va_list args)
 150 {
 151     MemoryResource * rt;
 152     APTR    memory;
 153     ULONG   size;
 154
 155     memory = va_arg (args, APTR);
 156     size   = va_arg (args, ULONG);
 157
 158     ForeachNode (&rtd->rtd_ResHash[rtt][CALCHASH(memory)], rt)
 159     {
 160         if (rt->Memory == memory)
 161         {
 162             *rtptr = rt;
 163
 164             if (rt->Size != size)
 165                 return RT_SEARCH_SIZE_MISMATCH;
 166
 167             return RT_SEARCH_FOUND;
 168         }
 169     }
 170
 171     return RT_SEARCH_NOT_FOUND;
 172 } /* RT_SearchMem */
 173
 174 static IPTR RT_ShowErrorMem (RTData * rtd, int rtt, MemoryResource * rt,
 175         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 176 {
 177     const char * modestr = (mode == RT_FREE) ? "Free" : "Check";
 178     APTR         memory;
 179     ULONG        size;
 180
 181     if (mode != RT_EXIT)
 182     {
 183         memory = va_arg (args, APTR);
 184         size   = va_arg (args, ULONG);
 185
 186         switch (ret)
 187         {
 188         case RT_SEARCH_FOUND:
 189             if (rt->Node.Flags & RTNF_DONT_FREE)
 190             {
 191                 kprintf ("RT%s: Try to free read-only resource: Memory\n"
 192                         "    %s at %s:%d\n"
 193                         "    Added at %s:%d\n"
 194                         "    MemPtr=%p\n"
 195                     , modestr
 196                     , modestr
 197                     , file, line
 198                     , rt->Node.File, rt->Node.Line
 199                     , rt->Memory
 200                 );
 201             }
 202             break;
 203
 204         case RT_SEARCH_NOT_FOUND:
 205             kprintf ("RT%s: Memory not found\n"
 206                     "    %s at %s:%d\n"
 207                     "    MemPtr=%p Size=%ld\n"
 208                 , modestr
 209                 , modestr
 210                 , file, line
 211                 , memory, size
 212             );
 213             break;
 214
 215         case RT_SEARCH_SIZE_MISMATCH:
 216             kprintf ("RT%s: Size mismatch (Allocated=%ld, Check=%ld)\n"
 217                     "    %s at %s:%d\n"
 218                     "    AllocMem()'d at %s:%d\n"
 219                     "    MemPtr=%p Size=%ld Flags=%08lx\n"
 220                 , modestr
 221                 , rt->Size, size
 222                 , modestr
 223                 , file, line
 224                 , rt->Node.File, rt->Node.Line
 225                 , rt->Memory, rt->Size, rt->Flags
 226             );
 227             break;
 228
 229         } /* switch */
 230     }
 231     else
 232     {
 233         kprintf ("RTExit: Memory was not freed\n"
 234                 "    AllocMem()'d at %s:%d\n"
 235                 "    MemPtr=%p Size=%ld Flags=%08lx\n"
 236             , rt->Node.File, rt->Node.Line
 237             , rt->Memory, rt->Size, rt->Flags
 238         );
 239     }
 240
 241     return ret;
 242 } /* RT_ShowErrorMem */
 243
 244 static IPTR RT_AllocVec (RTData * rtd, MemoryResource * rt, va_list args, BOOL * success)
 245 {
 246     AROS_GET_SYSBASE_OK
 247     rt->Size = va_arg (args, ULONG);
 248     rt->Flags = va_arg (args, ULONG);
 249
 250     rt->Memory = AllocVec (rt->Size, rt->Flags);
 251
 252     if (rt->Memory)
 253         *success = TRUE;
 254
 255     return (IPTR)(rt->Memory);
 256 } /* RT_AllocVec */
 257
 258 static IPTR RT_FreeVec (RTData * rtd, MemoryResource * rt)
 259 {
 260     AROS_GET_SYSBASE_OK
 261     if (rt)
 262         FreeVec (rt->Memory);
 263
 264     return TRUE;
 265 } /* RT_FreeVec */
 266
 267 static IPTR RT_SearchVec (RTData * rtd, int rtt, MemoryResource ** rtptr,
 268         va_list args)
 269 {
 270     MemoryResource * rt;
 271     APTR    memory;
 272
 273     memory = va_arg (args, APTR);
 274
 275     if (!memory)
 276     {
 277         *rtptr = NULL;
 278         return RT_SEARCH_FOUND;
 279     }
 280
 281     ForeachNode (&rtd->rtd_ResHash[rtt][CALCHASH(memory)], rt)
 282     {
 283         if (rt->Memory == memory)
 284         {
 285             *rtptr = rt;
 286
 287             return RT_SEARCH_FOUND;
 288         }
 289     }
 290
 291     return RT_SEARCH_NOT_FOUND;
 292 }
 293
 294 static IPTR RT_ShowErrorVec (RTData * rtd, int rtt, MemoryResource * rt,
 295         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 296 {
 297     const char * modestr = (mode == RT_FREE) ? "Free" : "Check";
 298     APTR         memory;
 299     ULONG        size;
 300
 301     if (mode != RT_EXIT)
 302     {
 303         memory = va_arg (args, APTR);
 304         size   = va_arg (args, ULONG);
 305
 306         switch (ret)
 307         {
 308         case RT_SEARCH_FOUND:
 309             if (rt && rt->Node.Flags & RTNF_DONT_FREE)
 310             {
 311                 kprintf ("RT%s: Try to free read-only resource: Vec-Memory\n"
 312                         "    %s at %s:%d\n"
 313                         "    Added at %s:%d\n"
 314                         "    MemPtr=%p\n"
 315                     , modestr
 316                     , modestr
 317                     , file, line
 318                     , rt->Node.File, rt->Node.Line
 319                     , rt->Memory
 320                 );
 321             }
 322             break;
 323
 324
 325         case RT_SEARCH_NOT_FOUND:
 326             kprintf ("RT%s: Memory not found\n"
 327                     "    %s at %s:%d\n"
 328                     "    MemPtr=%p Size=%ld\n"
 329                 , modestr
 330                 , modestr
 331                 , file, line
 332                 , memory, size
 333             );
 334             break;
 335
 336         } /* switch */
 337     }
 338     else
 339     {
 340         kprintf ("RTExit: Memory was not freed\n"
 341                 "    AllocVec()'d at %s:%d\n"
 342                 "    MemPtr=%p Size=%ld Flags=%08lx\n"
 343             , rt->Node.File, rt->Node.Line
 344             , rt->Memory, rt->Size, rt->Flags
 345         );
 346     }
 347
 348     return ret;
 349 } /* RT_ShowErrorVec */
 350
 351
 352 /**************************************
 353                RT Ports
 354 **************************************/
 355
 356 static IPTR RT_CreatePort (RTData * rtd, PortResource * rt, va_list args, BOOL * success)
 357 {
 358     AROS_GET_SYSBASE_OK
 359     STRPTR name;
 360     LONG   pri;
 361
 362     name = va_arg (args, STRPTR);
 363     pri  = va_arg (args, LONG);
 364
 365     if (!CheckPtr (name, NULL_PTR))
 366     {
 367         kprintf ("CreatePort(): Illegal name pointer\n"
 368                 "    name=%p at %s:%d\n"
 369             , name
 370             , rt->Node.File, rt->Node.Line
 371         );
 372         return 0ul;
 373     }
 374
 375     rt->Port = CreatePort (name, pri);
 376
 377     if (rt->Port)
 378         *success = TRUE;
 379
 380     return (IPTR)(rt->Port);
 381 } /* RT_CreatePort */
 382
 383 static IPTR RT_DeletePort (RTData * rtd, PortResource * rt)
 384 {
 385     DeletePort (rt->Port);
 386
 387     return TRUE;
 388 } /* RT_ClosePort */
 389
 390 static IPTR RT_ShowErrorPort (RTData * rtd, int rtt, PortResource * rt,
 391         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 392 {
 393     if (mode != RT_EXIT)
 394     {
 395         const char     * modestr = (mode == RT_FREE) ? "Close" : "Check";
 396         struct MsgPort * port;
 397
 398         port = va_arg (args, struct MsgPort *);
 399
 400         switch (ret)
 401         {
 402         case RT_SEARCH_FOUND:
 403             if (rt->Node.Flags & RTNF_DONT_FREE)
 404             {
 405                 kprintf ("RT%s: Try to free read-only resource: MsgPort\n"
 406                         "    %s at %s:%d\n"
 407                         "    Added at %s:%d\n"
 408                         "    Port=%p (Name=%s Pri=%d)\n"
 409                     , modestr
 410                     , modestr
 411                     , file, line
 412                     , rt->Node.File, rt->Node.Line
 413                     , rt->Port
 414                     , rt->Port->mp_Node.ln_Name
 415                         ? rt->Port->mp_Node.ln_Name
 416                         : NULL
 417                     , rt->Port->mp_Node.ln_Pri
 418                 );
 419             }
 420             break;
 421
 422         case RT_SEARCH_NOT_FOUND:
 423             kprintf ("RT%s: Port not found\n"
 424                     "    %s at %s:%d\n"
 425                     "    Port=%p\n"
 426                 , modestr
 427                 , modestr
 428                 , file, line
 429                 , port
 430             );
 431             break;
 432
 433         } /* switch */
 434     }
 435     else
 436     {
 437         kprintf ("RTExit: Port was not closed\n"
 438                 "    Opened at %s:%d\n"
 439                 "    Port=%p (Name=%s Pri=%d)\n"
 440             , rt->Node.File, rt->Node.Line
 441             , rt->Port
 442             , rt->Port->mp_Node.ln_Name
 443                 ? rt->Port->mp_Node.ln_Name
 444                 : NULL
 445             , rt->Port->mp_Node.ln_Pri
 446         );
 447     }
 448
 449     return ret;
 450 } /* RT_ShowErrorPort */
 451
 452 static IPTR RT_CheckPort (RTData * rtd, int rtt,
 453                         const char * file, ULONG line,
 454                         ULONG op, va_list args)
 455 {
 456     PortResource * rt;
 457     APTR prt = &rt;
 458
 459     if (RT_Search (rtd, rtt, (RTNode **)prt, args) != RT_SEARCH_FOUND)
 460         rt = NULL;
 461
 462     switch (op)
 463     {
 464     case RTTO_PutMsg:
 465         {
 466             struct MsgPort * port;
 467             struct Message * message;
 468
 469             port    = va_arg (args, struct MsgPort *);
 470             message = va_arg (args, struct Message *);
 471
 472             if (!rt)
 473             {
 474                 kprintf ("PutMsg(): Illegal port pointer\n"
 475                         "    Port=%p Message=%p at %s:%d\n"
 476                     , port, message
 477                     , file, line
 478                 );
 479
 480                 return -1;
 481             }
 482             else if (CheckPtr (message, 0))
 483             {
 484                 kprintf ("PutMsg(): Illegal message pointer\n"
 485                         "    Port=%p Message=%p at %s:%d\n"
 486                     , port, message
 487                     , file, line
 488                 );
 489
 490                 return -1;
 491             }
 492
 493             PutMsg (port, message);
 494
 495             return 0;
 496         }
 497
 498     case RTTO_GetMsg:
 499         {
 500             struct MsgPort * port;
 501
 502             port = va_arg (args, struct MsgPort *);
 503
 504             if (!rt)
 505             {
 506                 kprintf ("GetMsg(): Illegal port pointer\n"
 507                         "    Port=%p at %s:%d\n"
 508                     , port
 509                     , file, line
 510                 );
 511
 512                 return 0L;
 513             }
 514
 515             return (IPTR) GetMsg (port);
 516         }
 517
 518     } /* switch (op) */
 519
 520     return 0L;
 521 } /* RT_CheckPort */
 522
 523
 524 /**************************************
 525             RT Libraries
 526 **************************************/
 527
 528 static IPTR RT_OpenLibrary (RTData * rtd, LibraryResource * rt, va_list args, BOOL * success)
 529 {
 530     AROS_GET_SYSBASE_OK
 531     rt->Name    = va_arg (args, STRPTR);
 532     rt->Version = va_arg (args, ULONG);
 533
 534     rt->Lib = OpenLibrary (rt->Name, rt->Version);
 535
 536     if (rt->Lib)
 537         *success = TRUE;
 538
 539     return (IPTR)(rt->Lib);
 540 } /* RT_OpenLibrary */
 541
 542 static IPTR RT_CloseLibrary (RTData * rtd, LibraryResource * rt)
 543 {
 544     AROS_GET_SYSBASE_OK
 545     CloseLibrary (rt->Lib);
 546
 547     return TRUE;
 548 } /* RT_CloseLibrary */
 549
 550 static IPTR RT_ShowErrorLib (RTData * rtd, int rtt, LibraryResource * rt,
 551         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 552 {
 553
 554     if (mode != RT_EXIT)
 555     {
 556         const char     * modestr = (mode == RT_FREE) ? "Free" : "Check";
 557         struct Library * base;
 558
 559         base = va_arg (args, struct Library *);
 560
 561         switch (ret)
 562         {
 563         case RT_SEARCH_FOUND:
 564             if (rt->Node.Flags & RTNF_DONT_FREE)
 565             {
 566                 kprintf ("RT%s: Try to free read-only resource: Library\n"
 567                         "    %s at %s:%d\n"
 568                         "    Added at %s:%d\n"
 569                         "    LibBase=%p\n"
 570                     , modestr
 571                     , modestr
 572                     , file, line
 573                     , rt->Node.File, rt->Node.Line
 574                     , rt->Lib
 575                 );
 576             }
 577             break;
 578
 579         case RT_SEARCH_NOT_FOUND:
 580             kprintf ("RT%s: Library not found\n"
 581                     "    %s at %s:%d\n"
 582                     "    Base=%p\n"
 583                 , modestr
 584                 , modestr
 585                 , file, line
 586                 , base
 587             );
 588             break;
 589
 590         } /* switch */
 591     }
 592     else
 593     {
 594         kprintf ("RTExit: Library was not closed\n"
 595                 "    Opened at %s:%d\n"
 596                 "    Base=%p Name=%s Version=%ld\n"
 597             , rt->Node.File, rt->Node.Line
 598             , rt->Lib, rt->Name, rt->Version
 599         );
 600     }
 601
 602     return ret;
 603 } /* RT_ShowErrorLib */