usr.bin/doscmd/mem.c

   1 /*
   2  * Copyright (c) 1992, 1993, 1996
   3  *      Berkeley Software Design, Inc.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Berkeley Software
  16  *      Design, Inc.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  *      BSDI mem.c,v 2.2 1996/04/08 19:32:57 bostic Exp
  31  *
  32  * $FreeBSD$
  33  */
  34
  35 #include <stdio.h>
  36 #include "doscmd.h"
  37
  38 #define Mark(x) (*(char *) (x))
  39 #define Owner(x) (*(u_short *) ((char *)(x)+1))
  40 #define Size(x) (*(u_short *) ((char *)(x)+3))
  41 #define Next(x) ((char *)(x) + (Size(x)+1)*16)
  42
  43 /* exports */
  44 char    *dosmem;
  45
  46 /* locals */
  47 static int      dosmem_size;
  48
  49 static char     *next_p = (char *)0;
  50 static char     *end_p  = (char *)0xB0000L;
  51
  52 static char *
  53 core_alloc(int *size)
  54 {
  55     char *ret;
  56     if (*size) {
  57         if (*size & 0xfff) {
  58             *size = (*size & ~0xfff) + 0x1000;
  59         }
  60     } else {
  61         *size = end_p - next_p;
  62     }
  63
  64     if (next_p + *size > end_p) {
  65         return NULL;
  66     }
  67
  68     ret = next_p;
  69     next_p += *size;
  70     return ret;
  71 }
  72
  73 void
  74 mem_free_owner(int owner)
  75 {
  76     char *mp;
  77
  78     debug(D_MEMORY, "    : freeow(%04x)\n", owner);
  79
  80     for (mp = dosmem; ; mp = Next(mp)) {
  81         if (Owner(mp) == owner)
  82             Owner(mp) = 0;
  83
  84         if (Mark(mp) != 'M')
  85             break;
  86     }
  87 }
  88
  89 static void
  90 mem_print(void)
  91 {
  92     char *mp;
  93
  94     for (mp = dosmem; ; mp = Next(mp)) {
  95         debug(D_ALWAYS, "%8p: mark %c owner %04x size %04x\n",
  96               mp, Mark(mp), Owner(mp), Size(mp));
  97
  98         if (Mark(mp) != 'M')
  99             break;
 100     }
 101 }
 102
 103 void
 104 mem_change_owner(int addr, int owner)
 105 {
 106     char *mp;
 107
 108     debug(D_MEMORY, "%04x: owner (%04x)\n", addr, owner);
 109     addr <<= 4;
 110
 111     for (mp = dosmem; ; mp = Next(mp)) {
 112         if ((int)(mp + 16) == addr)
 113             goto found;
 114
 115         if (Mark(mp) != 'M')
 116             break;
 117     }
 118
 119     debug(D_ALWAYS, "%05x: illegal block in change owner\n", addr);
 120     mem_print();
 121     return;
 122
 123 found:
 124     Owner(mp) = owner;
 125 }
 126
 127 void
 128 mem_init(void)
 129 {
 130     int base, avail_memory;
 131
 132     base = 0x600;
 133     core_alloc(&base);
 134
 135     avail_memory = MAX_AVAIL_SEG * 16 - base;
 136     dosmem = core_alloc(&avail_memory);
 137
 138     if (!dosmem || dosmem != (char *)base)
 139         fatal("internal memory error\n");
 140
 141     dosmem_size = avail_memory / 16;
 142
 143     debug(D_MEMORY, "dosmem = %p base = 0x%x avail = 0x%x (%dK)\n",
 144           dosmem, base, dosmem_size, avail_memory / 1024);
 145
 146     Mark(dosmem) = 'Z';
 147     Owner(dosmem) = 0;
 148     Size(dosmem) = dosmem_size - 1;
 149 }
 150
 151 static void
 152 mem_unsplit(char *mp, int size)
 153 {
 154     char *nmp;
 155
 156     while (Mark(mp) == 'M' && Size(mp) < size) {
 157         nmp = Next(mp);
 158
 159         if (Owner(nmp) != 0)
 160             break;
 161
 162         Size(mp) += Size(nmp) + 1;
 163         Mark(mp) = Mark(nmp);
 164     }
 165 }
 166
 167 static void
 168 mem_split(char *mp, int size)
 169 {
 170     char *nmp;
 171     int rest;
 172
 173     rest = Size(mp) - size;
 174     Size(mp) = size;
 175     nmp = Next(mp);
 176     Mark(nmp) = Mark(mp);
 177     Mark(mp) = 'M';
 178     Owner(nmp) = 0;
 179     Size(nmp) = rest - 1;
 180 }
 181
 182 int
 183 mem_alloc(int size, int owner, int *biggestp)
 184 {
 185     char *mp;
 186     int biggest;
 187
 188     biggest = 0;
 189     for (mp = dosmem; ; mp = Next(mp)) {
 190         if (Owner(mp) == 0) {
 191             if (Size(mp) < size)
 192                 mem_unsplit(mp, size);
 193             if (Size(mp) >= size)
 194                 goto got;
 195
 196             if (Size(mp) > biggest)
 197                 biggest = Size(mp);
 198         }
 199
 200         if (Mark(mp) != 'M')
 201             break;
 202     }
 203
 204     debug(D_MEMORY, "%04x: alloc(%04x, owner %04x) failed -> %d\n",
 205           0, size, owner, biggest);
 206
 207     if (biggestp)
 208         *biggestp = biggest;
 209     return 0;
 210
 211 got:
 212     if (Size(mp) > size)
 213         mem_split(mp, size);
 214     Owner(mp) = owner;
 215     debug(D_MEMORY, "%04x: alloc(%04x, owner %04x)\n",
 216           (int)mp/16 + 1, size, owner);
 217
 218     if (biggestp)
 219         *biggestp = size;
 220     return (int)mp/16 + 1;
 221 }
 222
 223 int
 224 mem_adjust(int addr, int size, int *availp)
 225 {
 226     char *mp;
 227
 228     debug(D_MEMORY, "%04x: adjust(%05x)\n", addr, size);
 229     addr <<= 4;
 230
 231     for (mp = dosmem; ; mp = Next(mp)) {
 232         if ((int)(mp + 16) == addr)
 233             goto found;
 234
 235         if (Mark(mp) != 'M')
 236             break;
 237     }
 238
 239     debug(D_ALWAYS, "%05x: illegal block in adjust\n", addr);
 240     mem_print();
 241     return -2;
 242
 243 found:
 244     if (Size(mp) < size)
 245         mem_unsplit(mp, size);
 246     if (Size(mp) >= size)
 247         goto got;
 248
 249     debug(D_MEMORY, "%04x: adjust(%04x) failed -> %d\n",
 250           (int)mp/16 + 1, size, Size(mp));
 251
 252     if (availp)
 253         *availp = Size(mp);
 254     return -1;
 255
 256 got:
 257     if (Size(mp) > size)
 258         mem_split(mp, size);
 259     debug(D_MEMORY, "%04x: adjust(%04x)\n",
 260           (int)mp/16 + 1, size);
 261
 262     if (availp)
 263         *availp = size;
 264     return 0;
 265 }
 266
 267
 268
 269 #ifdef  MEM_TEST
 270 mem_check ()
 271 {
 272     struct mem_block *mp;
 273     for (mp = mem_blocks.next; mp != &mem_blocks; mp = mp->next) {
 274         if (mp->addr + mp->size != mp->next->addr)
 275             break;
 276         if (mp->inuse && mp->size == 0)
 277             return (-1);
 278     }
 279
 280     if (mp->next != &mem_blocks)
 281         return (-1);
 282     return (0);
 283 }
 284
 285 char *blocks[10];
 286
 287 main ()
 288 {
 289     int i;
 290     int n;
 291     int newsize;
 292
 293     mem_init (0, 300);
 294
 295     for (i = 0; i < 100000; i++) {
 296         n = random () % 10;
 297
 298         if (blocks[n]) {
 299             newsize = random () % 20;
 300             if ((newsize & 1) == 0)
 301                 newsize = 0;
 302
 303             if (0)
 304                 printf ("adjust %d %x %d\n",
 305                         n, blocks[n], newsize);
 306             mem_adjust (blocks[n], newsize, NULL);
 307             if (newsize == 0)
 308                 blocks[n] = NULL;
 309         } else {
 310             while ((newsize = random () % 20) == 0)
 311                 ;
 312             if (0)
 313                 printf ("alloc %d %d\n", n, newsize);
 314             blocks[n] = mem_alloc (newsize, NULL);
 315         }
 316         if (mem_check () < 0) {
 317             printf ("==== %d\n", i);
 318             mem_print ();
 319         }
 320     }
 321
 322     mem_print ();
 323 }
 324 #endif /* MEM_TEST */