rom/exec/availmem.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Tell how much memory is available.
   6     Lang: english
   7 */
   8 #include <exec/alerts.h>
   9 #include <exec/execbase.h>
  10 #include <aros/libcall.h>
  11 #include <aros/macros.h>
  12 #include <exec/memory.h>
  13 #include <exec/memheaderext.h>
  14 #include <proto/exec.h>
  15
  16 #include "memory.h"
  17
  18 #define MDEBUG 1
  19 #include <aros/debug.h>
  20
  21 /*****************************************************************************
  22
  23     NAME */
  24
  25         AROS_LH1(ULONG, AvailMem,
  26
  27 /*  SYNOPSIS */
  28         AROS_LHA(ULONG, attributes, D1),
  29
  30 /*  LOCATION */
  31         struct ExecBase *, SysBase, 36, Exec)
  32
  33 /*  FUNCTION
  34         Return either the total available memory or the largest available
  35         chunk of a given type of memory.
  36
  37     INPUTS
  38         attributes - The same attributes you would give to AllocMem().
  39
  40     RESULT
  41         Either the total of the available memory or the largest chunk if
  42         MEMF_LARGEST ist set in the attributes.
  43
  44     NOTES
  45         Due to the nature of multitasking the returned value may already
  46         be obsolete if this function returns.
  47
  48     EXAMPLE
  49         Print the total available memory.
  50
  51         printf("Free memory: %lu bytes\n",AvailMem(0));
  52
  53         Print the size of the largest chunk of chip memory.
  54
  55         printf("Largest chipmem chunk: %lu bytes\n",
  56                AvailMem(MEMF_CHIP|MEMF_LARGEST));
  57
  58     BUGS
  59
  60     SEE ALSO
  61
  62     INTERNALS
  63
  64 ******************************************************************************/
  65 {
  66     AROS_LIBFUNC_INIT
  67
  68     ULONG ret = 0;
  69     struct MemHeader *mh;
  70
  71     /* Nobody else should access the memory lists now. */
  72     Forbid();
  73
  74     ForeachNode(&SysBase->MemList, mh)
  75     {
  76         /*
  77             The current memheader is OK if there's no bit in the
  78             'attributes' that isn't set in the 'mh->mh_Attributes'.
  79             MEMF_CLEAR, MEMF_REVERSE, MEMF_NO_EXPUNGE, MEMF_TOTAL and
  80             MEMF_LARGEST are treated as if they were always set in
  81             the memheader.
  82         */
  83         if((attributes &~ (MEMF_CLEAR|MEMF_REVERSE|MEMF_NO_EXPUNGE|
  84                            MEMF_TOTAL|MEMF_LARGEST|mh->mh_Attributes)))
  85             continue;
  86
  87         if (mh->mh_Attributes & MEMF_MANAGED)
  88         {
  89             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
  90
  91             if (mhe->mhe_Avail)
  92             {
  93                 ret += mhe->mhe_Avail(mhe, attributes);
  94                 continue;
  95             }
  96             /* fall through */
  97         }
  98
  99         /* Find largest chunk? */
 100         if(attributes & MEMF_LARGEST)
 101         {
 102             /*
 103                 Yes. Follow the list of MemChunks and set 'ret' to
 104                 each value that is bigger than all previous ones.
 105             */
 106             struct MemChunk *mc=mh->mh_First;
 107             while(mc!=NULL)
 108             {
 109                 #if !defined(NO_CONSISTENCY_CHECKS)
 110                 /*
 111                     Do some constistency checks:
 112                     1. All MemChunks must be aligned to
 113                        sizeof(struct MemChunk).
 114                     2. The end (+1) of the current MemChunk
 115                        must be lower than the start of the next one.
 116                 */
 117                 if(  ((IPTR)mc|mc->mc_Bytes)&(sizeof(struct MemChunk)-1)
 118                    ||(  (UBYTE *)mc+mc->mc_Bytes>=(UBYTE *)mc->mc_Next
 119                       &&mc->mc_Next!=NULL))
 120                     Alert(AT_DeadEnd|AN_MemoryInsane);
 121                 #endif
 122                 if(mc->mc_Bytes>ret)
 123                     ret=mc->mc_Bytes;
 124                 mc=mc->mc_Next;
 125             }
 126         }
 127         else if(attributes & MEMF_TOTAL)
 128             /* Determine total size. */
 129             ret += (IPTR)mh->mh_Upper - (IPTR)mh->mh_Lower;
 130         else
 131             /* Sum up free memory. */
 132             ret += mh->mh_Free;
 133     }
 134     /* All done. Permit dispatches and return. */
 135
 136 #if AROS_MUNGWALL_DEBUG
 137     if (attributes & MEMF_CLEAR)
 138     {
 139         struct List             *allocmemlist;
 140         struct MungwallHeader   *allocnode;
 141         ULONG                    alloccount = 0;
 142         ULONG                    allocsize = 0;
 143
 144         allocmemlist = (struct List *)&((struct AROSSupportBase *)SysBase->DebugAROSBase)->AllocMemList;
 145
 146         kprintf("\n=== MUNGWALL MEMORY CHECK ============\n");
 147         ForeachNode(allocmemlist, allocnode)
 148         {
 149             if (allocnode->mwh_magicid != MUNGWALL_HEADER_ID)
 150             {
 151                 kprintf(" #%05x BAD MUNGWALL_HEADER_ID\n", alloccount);
 152             }
 153
 154             CHECK_WALL((UBYTE *)allocnode + MUNGWALLHEADER_SIZE, 0xDB, MUNGWALL_SIZE);
 155             CHECK_WALL((UBYTE *)allocnode + MUNGWALLHEADER_SIZE + MUNGWALL_SIZE + allocnode->mwh_allocsize, 0xDB,
 156                 MUNGWALL_SIZE + AROS_ROUNDUP2(allocnode->mwh_allocsize, MEMCHUNK_TOTAL) - allocnode->mwh_allocsize);
 157
 158             allocsize += allocnode->mwh_allocsize;
 159             alloccount++;
 160         }
 161         kprintf("\n Num allocations: %d   Memory allocated %d\n", alloccount, allocsize);
 162     }
 163 #endif
 164     Permit();
 165     return ret;
 166     AROS_LIBFUNC_EXIT
 167 } /* AvailMem */
 168