rom/kernel/kernel_romtags.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     ROMTag scanner.
   6 */
   7
   8 #include <aros/asmcall.h>
   9 #include <exec/execbase.h>
  10 #include <exec/lists.h>
  11 #include <exec/nodes.h>
  12 #include <exec/memory.h>
  13 #include <exec/resident.h>
  14 #include <proto/alib.h>
  15 #include <proto/exec.h>
  16
  17 #include <string.h>
  18
  19 #include <kernel_base.h>
  20 #include <kernel_debug.h>
  21 #include <kernel_romtags.h>
  22
  23 #define D(x)
  24
  25 static LONG findname(struct Resident **list, ULONG len, CONST_STRPTR name)
  26 {
  27     ULONG i;
  28
  29     for (i = 0; i < len; i++)
  30     {
  31         if (!strcmp(name, list[i]->rt_Name))
  32             return i;
  33     }
  34
  35     return -1;
  36 }
  37
  38 /*
  39  * Allocate memory space for boot-time usage. Returns address and size of the usable area.
  40  * It's strongly adviced to return enough space to store resident list of sane length.
  41  */
  42 static APTR krnGetSysMem(struct MemHeader *mh, IPTR *size)
  43 {
  44     if (mh->mh_Attributes & MEMF_MANAGED)
  45     {
  46         struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
  47
  48         if (mhe->mhe_Alloc)
  49         {
  50             *size = 1024*1024;
  51             return mhe->mhe_Alloc(mhe, *size, NULL);
  52         }
  53     }
  54     else
  55     {
  56         /* Just dequeue the first MemChunk. It's assumed that it has the required space for sure. */
  57         struct MemChunk *mc = mh->mh_First;
  58
  59         mh->mh_First = mc->mc_Next;
  60         mh->mh_Free -= mc->mc_Bytes;
  61
  62         D(bug("[RomTagScanner] Using chunk 0x%p of %lu bytes\n", mc, mc->mc_Bytes));
  63
  64         *size = mc->mc_Bytes;
  65         return mc;
  66     }
  67 }
  68
  69 /* Release unused boot-time memory */
  70 static void krnReleaseSysMem(struct MemHeader *mh, APTR addr, IPTR chunkSize, IPTR allocSize)
  71 {
  72     if (mh->mh_Attributes & MEMF_MANAGED)
  73     {
  74         struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
  75
  76         if (mhe->mhe_Realloc)
  77             mhe->mhe_Realloc(mhe, addr, allocSize);
  78     }
  79     else
  80     {
  81         struct MemChunk *mc;
  82
  83         allocSize = AROS_ROUNDUP2(allocSize, MEMCHUNK_TOTAL);
  84         chunkSize -= allocSize;
  85
  86         D(bug("[RomTagScanner] Chunk 0x%p, %lu of %lu bytes used\n", addr, allocSize, chunkSize));
  87
  88         if (chunkSize < MEMCHUNK_TOTAL)
  89             return;
  90
  91         mc = addr + allocSize;
  92
  93         mc->mc_Next  = mh->mh_First;
  94         mc->mc_Bytes = chunkSize - allocSize;
  95
  96         mh->mh_First = mc;
  97         mh->mh_Free += mc->mc_Bytes;
  98     }
  99 }
 100
 101 /*
 102  * RomTag scanner.
 103  *
 104  * This function scans kernel for existing Resident modules. If two modules
 105  * with the same name are found, the one with higher version or priority
 106  * wins.
 107  *
 108  * After building list of kernel modules, the KickTagPtr and KickMemPtr are
 109  * checksummed. If checksum is proper and all memory pointed in KickMemPtr
 110  * may be allocated, then all modules from KickTagPtr are added to RT list
 111  *
 112  * Afterwards the proper RomTagList is created (see InitCode() for details)
 113  * and memory after list and nodes is freed.
 114  *
 115  * The array ranges gives a [ start, end ] pair to scan, with an entry of
 116  * -1 used to break the loop.
 117  */
 118
 119 APTR krnRomTagScanner(struct MemHeader *mh, UWORD *ranges[])
 120 {
 121     UWORD           *end;
 122     UWORD           *ptr;               /* Start looking here */
 123     struct Resident *res;               /* module found */
 124     ULONG           i;
 125     BOOL            sorted;
 126     /*
 127      * We don't know resident list size until it's created. Because of this, we use two-step memory allocation
 128      * for this purpose.
 129      * First we dequeue some space from the MemHeader, and remember its starting address and size. Then we
 130      * construct resident list in this area. After it's done, we return part of the used space to the system.
 131      */
 132     IPTR chunkSize;
 133     struct Resident **RomTag = krnGetSysMem(mh, &chunkSize);
 134     IPTR  limit = chunkSize / sizeof(APTR);
 135     ULONG num = 0;
 136
 137     if (!RomTag)
 138         return NULL;
 139
 140     /* Look in whole kickstart for resident modules */
 141     while (*ranges != (UWORD *)~0)
 142     {
 143         ptr = *ranges++;
 144         end = *ranges++;
 145
 146         /* Make sure that addresses are UWORD-aligned. In some circumstances they can be not. */
 147         ptr = (UWORD *)(((IPTR)ptr + 1) & ~1);
 148         end = (UWORD *)((IPTR)end & ~1);
 149
 150         D(bug("RomTagScanner: Start = %p, End = %p\n", ptr, end));
 151         do
 152         {
 153             res = (struct Resident *)ptr;
 154
 155             /* Do we have RTC_MATCHWORD and rt_MatchTag*/
 156             if (res->rt_MatchWord == RTC_MATCHWORD && res->rt_MatchTag == res)
 157             {
 158                 /* Yes, it is Resident module. Check if there is module with such name already */
 159                 i = findname(RomTag, num, res->rt_Name);
 160                 if (i != -1)
 161                 {
 162                     struct Resident *old = RomTag[i];
 163                     /*
 164                         Rules for replacing modules:
 165                         1. Higher version always wins.
 166                         2. If the versions are equal, then lower priority
 167                             looses.
 168                     */
 169                     if ((old->rt_Version < res->rt_Version) ||
 170                         (old->rt_Version == res->rt_Version && old->rt_Pri <= res->rt_Pri))
 171                     {
 172                         RomTag[i] = res;
 173                     }
 174                 }
 175                 else
 176                 {
 177                     /* New module */
 178                     RomTag[num++] = res;
 179                     /*
 180                      * 'limit' holds a length of our MemChunk in pointers.
 181                      * Actually it's a number or pointers we can safely store in it (including NULL terminator).
 182                      * If it's exceeded, return NULL.
 183                      * TODO: If ever needed, this routine can be made smarter. There can be
 184                      * the following approaches:
 185                      * a) Move the data to a next MemChunk which is bigger than the current one
 186                      *    and continue.
 187                      * b) In the beginning of this routine, find the largest available MemChunk and use it.
 188                      * Note that we exit with destroyed MemChunk here. Anyway, failure here means the system
 189                      * is completely unable to boot up.
 190                      */
 191                     if (num == limit)
 192                         return NULL;
 193                 }
 194
 195                 /* Get address of EndOfResident from RomTag but only when
 196                  * it's higher then present one - this avoids strange locks
 197                  * when not all modules have Resident structure in .text
 198                  * section */
 199                 ptr = ((IPTR)res->rt_EndSkip > (IPTR)ptr)
 200                         ?   (UWORD *)res->rt_EndSkip - 2
 201                         :   ptr;
 202
 203                 if ((IPTR)ptr & 0x01)
 204                    ptr = (UWORD *)((IPTR)ptr+1);
 205             }
 206
 207             /* Get next address... */
 208             ptr++;
 209         } while (ptr < (UWORD*)end);
 210     }
 211
 212     /* Terminate the list */
 213     RomTag[num] = NULL;
 214
 215     /* Seal our used memory as allocated */
 216     krnReleaseSysMem(mh, RomTag, chunkSize, (num + 1) * sizeof(struct Resident *));
 217
 218     /*
 219      * Building list is complete, sort RomTags according to their priority.
 220      * I use BubbleSort algorithm.
 221      */
 222     do
 223     {
 224         sorted = TRUE;
 225
 226         for (i = 0; i < num - 1; i++)
 227         {
 228             if (RomTag[i]->rt_Pri < RomTag[i+1]->rt_Pri)
 229             {
 230                 struct Resident *tmp;
 231
 232                 tmp = RomTag[i+1];
 233                 RomTag[i+1] = RomTag[i];
 234                 RomTag[i] = tmp;
 235
 236                 sorted = FALSE;
 237             }
 238         }
 239     } while (!sorted);
 240
 241     return RomTag;
 242 }
 243
 244 struct Resident *krnFindResident(struct Resident **resList, const char *name)
 245 {
 246     ULONG i;
 247
 248     for (i = 0; resList[i]; i++)
 249     {
 250         if (!strcmp(resList[i]->rt_Name, name))
 251             return resList[i];
 252     }
 253     return NULL;
 254 }