compiler/arossupport/rt_exec.c

   1 /*
   2     Copyright © 1995-2007, 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     rt->Size = va_arg (args, ULONG);
 129     rt->Flags = va_arg (args, ULONG);
 130
 131     rt->Memory = AllocMem (rt->Size, rt->Flags);
 132
 133     if (rt->Memory)
 134         *success = TRUE;
 135
 136     return (IPTR)(rt->Memory);
 137 } /* RT_AllocMem */
 138
 139 static IPTR RT_FreeMem (RTData * rtd, MemoryResource * rt)
 140 {
 141     FreeMem (rt->Memory, rt->Size);
 142
 143     return TRUE;
 144 } /* RT_FreeMem */
 145
 146 static IPTR RT_SearchMem (RTData * rtd, int rtt, MemoryResource ** rtptr,
 147         va_list args)
 148 {
 149     MemoryResource * rt;
 150     APTR    memory;
 151     ULONG   size;
 152
 153     memory = va_arg (args, APTR);
 154     size   = va_arg (args, ULONG);
 155
 156     ForeachNode (&rtd->rtd_ResHash[rtt][CALCHASH(memory)], rt)
 157     {
 158         if (rt->Memory == memory)
 159         {
 160             *rtptr = rt;
 161
 162             if (rt->Size != size)
 163                 return RT_SEARCH_SIZE_MISMATCH;
 164
 165             return RT_SEARCH_FOUND;
 166         }
 167     }
 168
 169     return RT_SEARCH_NOT_FOUND;
 170 } /* RT_SearchMem */
 171
 172 static IPTR RT_ShowErrorMem (RTData * rtd, int rtt, MemoryResource * rt,
 173         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 174 {
 175     const char * modestr = (mode == RT_FREE) ? "Free" : "Check";
 176     APTR         memory;
 177     ULONG        size;
 178
 179     if (mode != RT_EXIT)
 180     {
 181         memory = va_arg (args, APTR);
 182         size   = va_arg (args, ULONG);
 183
 184         switch (ret)
 185         {
 186         case RT_SEARCH_FOUND:
 187             if (rt->Node.Flags & RTNF_DONT_FREE)
 188             {
 189                 kprintf ("RT%s: Try to free read-only resource: Memory\n"
 190                         "    %s at %s:%d\n"
 191                         "    Added at %s:%d\n"
 192                         "    MemPtr=%p\n"
 193                     , modestr
 194                     , modestr
 195                     , file, line
 196                     , rt->Node.File, rt->Node.Line
 197                     , rt->Memory
 198                 );
 199             }
 200             break;
 201
 202         case RT_SEARCH_NOT_FOUND:
 203             kprintf ("RT%s: Memory not found\n"
 204                     "    %s at %s:%d\n"
 205                     "    MemPtr=%p Size=%ld\n"
 206                 , modestr
 207                 , modestr
 208                 , file, line
 209                 , memory, size
 210             );
 211             break;
 212
 213         case RT_SEARCH_SIZE_MISMATCH:
 214             kprintf ("RT%s: Size mismatch (Allocated=%ld, Check=%ld)\n"
 215                     "    %s at %s:%d\n"
 216                     "    AllocMem()'d at %s:%d\n"
 217                     "    MemPtr=%p Size=%ld Flags=%08lx\n"
 218                 , modestr
 219                 , rt->Size, size
 220                 , modestr
 221                 , file, line
 222                 , rt->Node.File, rt->Node.Line
 223                 , rt->Memory, rt->Size, rt->Flags
 224             );
 225             break;
 226
 227         } /* switch */
 228     }
 229     else
 230     {
 231         kprintf ("RTExit: Memory was not freed\n"
 232                 "    AllocMem()'d at %s:%d\n"
 233                 "    MemPtr=%p Size=%ld Flags=%08lx\n"
 234             , rt->Node.File, rt->Node.Line
 235             , rt->Memory, rt->Size, rt->Flags
 236         );
 237     }
 238
 239     return ret;
 240 } /* RT_ShowErrorMem */
 241
 242 static IPTR RT_AllocVec (RTData * rtd, MemoryResource * rt, va_list args, BOOL * success)
 243 {
 244     rt->Size = va_arg (args, ULONG);
 245     rt->Flags = va_arg (args, ULONG);
 246
 247     rt->Memory = AllocVec (rt->Size, rt->Flags);
 248
 249     if (rt->Memory)
 250         *success = TRUE;
 251
 252     return (IPTR)(rt->Memory);
 253 } /* RT_AllocVec */
 254
 255 static IPTR RT_FreeVec (RTData * rtd, MemoryResource * rt)
 256 {
 257     if (rt)
 258         FreeVec (rt->Memory);
 259
 260     return TRUE;
 261 } /* RT_FreeVec */
 262
 263 static IPTR RT_SearchVec (RTData * rtd, int rtt, MemoryResource ** rtptr,
 264         va_list args)
 265 {
 266     MemoryResource * rt;
 267     APTR    memory;
 268
 269     memory = va_arg (args, APTR);
 270
 271     if (!memory)
 272     {
 273         *rtptr = NULL;
 274         return RT_SEARCH_FOUND;
 275     }
 276
 277     ForeachNode (&rtd->rtd_ResHash[rtt][CALCHASH(memory)], rt)
 278     {
 279         if (rt->Memory == memory)
 280         {
 281             *rtptr = rt;
 282
 283             return RT_SEARCH_FOUND;
 284         }
 285     }
 286
 287     return RT_SEARCH_NOT_FOUND;
 288 }
 289
 290 static IPTR RT_ShowErrorVec (RTData * rtd, int rtt, MemoryResource * rt,
 291         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 292 {
 293     const char * modestr = (mode == RT_FREE) ? "Free" : "Check";
 294     APTR         memory;
 295     ULONG        size;
 296
 297     if (mode != RT_EXIT)
 298     {
 299         memory = va_arg (args, APTR);
 300         size   = va_arg (args, ULONG);
 301
 302         switch (ret)
 303         {
 304         case RT_SEARCH_FOUND:
 305             if (rt && rt->Node.Flags & RTNF_DONT_FREE)
 306             {
 307                 kprintf ("RT%s: Try to free read-only resource: Vec-Memory\n"
 308                         "    %s at %s:%d\n"
 309                         "    Added at %s:%d\n"
 310                         "    MemPtr=%p\n"
 311                     , modestr
 312                     , modestr
 313                     , file, line
 314                     , rt->Node.File, rt->Node.Line
 315                     , rt->Memory
 316                 );
 317             }
 318             break;
 319
 320
 321         case RT_SEARCH_NOT_FOUND:
 322             kprintf ("RT%s: Memory not found\n"
 323                     "    %s at %s:%d\n"
 324                     "    MemPtr=%p Size=%ld\n"
 325                 , modestr
 326                 , modestr
 327                 , file, line
 328                 , memory, size
 329             );
 330             break;
 331
 332         } /* switch */
 333     }
 334     else
 335     {
 336         kprintf ("RTExit: Memory was not freed\n"
 337                 "    AllocVec()'d at %s:%d\n"
 338                 "    MemPtr=%p Size=%ld Flags=%08lx\n"
 339             , rt->Node.File, rt->Node.Line
 340             , rt->Memory, rt->Size, rt->Flags
 341         );
 342     }
 343
 344     return ret;
 345 } /* RT_ShowErrorVec */
 346
 347
 348 /**************************************
 349                RT Ports
 350 **************************************/
 351
 352 static IPTR RT_CreatePort (RTData * rtd, PortResource * rt, va_list args, BOOL * success)
 353 {
 354     STRPTR name;
 355     LONG   pri;
 356
 357     name = va_arg (args, STRPTR);
 358     pri  = va_arg (args, LONG);
 359
 360     if (!CheckPtr (name, NULL_PTR))
 361     {
 362         kprintf ("CreatePort(): Illegal name pointer\n"
 363                 "    name=%p at %s:%d\n"
 364             , name
 365             , rt->Node.File, rt->Node.Line
 366         );
 367         return 0ul;
 368     }
 369
 370     rt->Port = CreatePort (name, pri);
 371
 372     if (rt->Port)
 373         *success = TRUE;
 374
 375     return (IPTR)(rt->Port);
 376 } /* RT_CreatePort */
 377
 378 static IPTR RT_DeletePort (RTData * rtd, PortResource * rt)
 379 {
 380     DeletePort (rt->Port);
 381
 382     return TRUE;
 383 } /* RT_ClosePort */
 384
 385 static IPTR RT_ShowErrorPort (RTData * rtd, int rtt, PortResource * rt,
 386         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 387 {
 388     if (mode != RT_EXIT)
 389     {
 390         const char     * modestr = (mode == RT_FREE) ? "Close" : "Check";
 391         struct MsgPort * port;
 392
 393         port = va_arg (args, struct MsgPort *);
 394
 395         switch (ret)
 396         {
 397         case RT_SEARCH_FOUND:
 398             if (rt->Node.Flags & RTNF_DONT_FREE)
 399             {
 400                 kprintf ("RT%s: Try to free read-only resource: MsgPort\n"
 401                         "    %s at %s:%d\n"
 402                         "    Added at %s:%d\n"
 403                         "    Port=%p (Name=%s Pri=%d)\n"
 404                     , modestr
 405                     , modestr
 406                     , file, line
 407                     , rt->Node.File, rt->Node.Line
 408                     , rt->Port
 409                     , rt->Port->mp_Node.ln_Name
 410                         ? rt->Port->mp_Node.ln_Name
 411                         : NULL
 412                     , rt->Port->mp_Node.ln_Pri
 413                 );
 414             }
 415             break;
 416
 417         case RT_SEARCH_NOT_FOUND:
 418             kprintf ("RT%s: Port not found\n"
 419                     "    %s at %s:%d\n"
 420                     "    Port=%p\n"
 421                 , modestr
 422                 , modestr
 423                 , file, line
 424                 , port
 425             );
 426             break;
 427
 428         } /* switch */
 429     }
 430     else
 431     {
 432         kprintf ("RTExit: Port was not closed\n"
 433                 "    Opened at %s:%d\n"
 434                 "    Port=%p (Name=%s Pri=%d)\n"
 435             , rt->Node.File, rt->Node.Line
 436             , rt->Port
 437             , rt->Port->mp_Node.ln_Name
 438                 ? rt->Port->mp_Node.ln_Name
 439                 : NULL
 440             , rt->Port->mp_Node.ln_Pri
 441         );
 442     }
 443
 444     return ret;
 445 } /* RT_ShowErrorPort */
 446
 447 static IPTR RT_CheckPort (RTData * rtd, int rtt,
 448                         const char * file, ULONG line,
 449                         ULONG op, va_list args)
 450 {
 451     PortResource * rt;
 452     APTR prt = &rt;
 453
 454     if (RT_Search (rtd, rtt, (RTNode **)prt, args) != RT_SEARCH_FOUND)
 455         rt = NULL;
 456
 457     switch (op)
 458     {
 459     case RTTO_PutMsg:
 460         {
 461             struct MsgPort * port;
 462             struct Message * message;
 463
 464             port    = va_arg (args, struct MsgPort *);
 465             message = va_arg (args, struct Message *);
 466
 467             if (!rt)
 468             {
 469                 kprintf ("PutMsg(): Illegal port pointer\n"
 470                         "    Port=%p Message=%p at %s:%d\n"
 471                     , port, message
 472                     , file, line
 473                 );
 474
 475                 return -1;
 476             }
 477             else if (CheckPtr (message, 0))
 478             {
 479                 kprintf ("PutMsg(): Illegal message pointer\n"
 480                         "    Port=%p Message=%p at %s:%d\n"
 481                     , port, message
 482                     , file, line
 483                 );
 484
 485                 return -1;
 486             }
 487
 488             PutMsg (port, message);
 489
 490             return 0;
 491         }
 492
 493     case RTTO_GetMsg:
 494         {
 495             struct MsgPort * port;
 496
 497             port = va_arg (args, struct MsgPort *);
 498
 499             if (!rt)
 500             {
 501                 kprintf ("GetMsg(): Illegal port pointer\n"
 502                         "    Port=%p at %s:%d\n"
 503                     , port
 504                     , file, line
 505                 );
 506
 507                 return 0L;
 508             }
 509
 510             return (IPTR) GetMsg (port);
 511         }
 512
 513     } /* switch (op) */
 514
 515     return 0L;
 516 } /* RT_CheckPort */
 517
 518
 519 /**************************************
 520             RT Libraries
 521 **************************************/
 522
 523 static IPTR RT_OpenLibrary (RTData * rtd, LibraryResource * rt, va_list args, BOOL * success)
 524 {
 525     rt->Name    = va_arg (args, STRPTR);
 526     rt->Version = va_arg (args, ULONG);
 527
 528     rt->Lib = OpenLibrary (rt->Name, rt->Version);
 529
 530     if (rt->Lib)
 531         *success = TRUE;
 532
 533     return (IPTR)(rt->Lib);
 534 } /* RT_OpenLibrary */
 535
 536 static IPTR RT_CloseLibrary (RTData * rtd, LibraryResource * rt)
 537 {
 538     CloseLibrary (rt->Lib);
 539
 540     return TRUE;
 541 } /* RT_CloseLibrary */
 542
 543 static IPTR RT_ShowErrorLib (RTData * rtd, int rtt, LibraryResource * rt,
 544         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 545 {
 546
 547     if (mode != RT_EXIT)
 548     {
 549         const char     * modestr = (mode == RT_FREE) ? "Free" : "Check";
 550         struct Library * base;
 551
 552         base = va_arg (args, struct Library *);
 553
 554         switch (ret)
 555         {
 556         case RT_SEARCH_FOUND:
 557             if (rt->Node.Flags & RTNF_DONT_FREE)
 558             {
 559                 kprintf ("RT%s: Try to free read-only resource: Library\n"
 560                         "    %s at %s:%d\n"
 561                         "    Added at %s:%d\n"
 562                         "    LibBase=%p\n"
 563                     , modestr
 564                     , modestr
 565                     , file, line
 566                     , rt->Node.File, rt->Node.Line
 567                     , rt->Lib
 568                 );
 569             }
 570             break;
 571
 572         case RT_SEARCH_NOT_FOUND:
 573             kprintf ("RT%s: Library not found\n"
 574                     "    %s at %s:%d\n"
 575                     "    Base=%p\n"
 576                 , modestr
 577                 , modestr
 578                 , file, line
 579                 , base
 580             );
 581             break;
 582
 583         } /* switch */
 584     }
 585     else
 586     {
 587         kprintf ("RTExit: Library was not closed\n"
 588                 "    Opened at %s:%d\n"
 589                 "    Base=%p Name=%s Version=%ld\n"
 590             , rt->Node.File, rt->Node.Line
 591             , rt->Lib, rt->Name, rt->Version
 592         );
 593     }
 594
 595     return ret;
 596 } /* RT_ShowErrorLib */