v86_mem.c

   1 #include <fcntl.h>
   2 #include <string.h>
   3 #include <sys/mman.h>
   4 #include "v86.h"
   5
   6 #define REAL_MEM_BLOCKS 0x100
   7
   8 u8 *real_mem = NULL;
   9
  10 struct mem_block {
  11         unsigned int size : 20;
  12         unsigned int free : 1;
  13 };
  14
  15 static struct {
  16         int ready;
  17         int count;
  18         struct mem_block blocks[REAL_MEM_BLOCKS];
  19 } mem_info = { 0 };
  20
  21 static int read_file(char *name, void *p, size_t n)
  22 {
  23         int fd;
  24
  25         fd = open(name, O_RDONLY);
  26
  27         if (fd == -1) {
  28                 perror("open");
  29                 return 0;
  30         }
  31
  32         if (read(fd, p, n) != n) {
  33                 perror("read");
  34                 close(fd);
  35                 return 0;
  36         }
  37
  38         close(fd);
  39
  40         return 1;
  41 }
  42
  43 static int map_file(void *start, size_t length, int prot, int flags, char *name, long offset)
  44 {
  45         void *m;
  46         int fd;
  47
  48         fd = open(name, (flags & MAP_SHARED) ? O_RDWR : O_RDONLY);
  49
  50         if (fd == -1) {
  51                 perror("open");
  52                 return 0;
  53         }
  54
  55         m = mmap(start, length, prot, flags, fd, offset);
  56
  57         if (m == (void *)-1) {
  58                 perror("mmap");
  59                 close(fd);
  60                 return 0;
  61         }
  62
  63         close(fd);
  64         return 1;
  65 }
  66
  67 static int real_mem_init(void)
  68 {
  69         if (mem_info.ready)
  70                 return 0;
  71
  72         if (!map_file((void *)REAL_MEM_BASE, REAL_MEM_SIZE,
  73                  PROT_READ | PROT_WRITE | PROT_EXEC,
  74                  MAP_FIXED | MAP_PRIVATE, "/dev/zero", 0))
  75                 return 0;
  76
  77         real_mem = (u8*)0;
  78
  79         mem_info.ready = 1;
  80         mem_info.count = 1;
  81         mem_info.blocks[0].size = REAL_MEM_SIZE;
  82         mem_info.blocks[0].free = 1;
  83
  84         return 0;
  85 }
  86
  87 static void real_mem_deinit(void)
  88 {
  89         if (mem_info.ready) {
  90                 munmap((void *)REAL_MEM_BASE, REAL_MEM_SIZE);
  91                 mem_info.ready = 0;
  92         }
  93 }
  94
  95 static void insert_block(int i)
  96 {
  97         memmove(mem_info.blocks + i + 1, mem_info.blocks + i,
  98                         (mem_info.count - i) * sizeof(struct mem_block));
  99         mem_info.count++;
 100 }
 101
 102 static void delete_block(int i)
 103 {
 104         mem_info.count--;
 105         memmove(mem_info.blocks + i, mem_info.blocks + i + 1,
 106                  (mem_info.count - i) * sizeof(struct mem_block));
 107 }
 108
 109 void *v86_mem_alloc(int size)
 110 {
 111         int i;
 112         char *r = (char *)REAL_MEM_BASE;
 113
 114         if (!mem_info.ready)
 115                 return NULL;
 116
 117         if (mem_info.count == REAL_MEM_BLOCKS)
 118                 return NULL;
 119
 120         size = (size + 15) & ~15;
 121
 122         for (i = 0; i < mem_info.count; i++) {
 123                 if (mem_info.blocks[i].free && size < mem_info.blocks[i].size) {
 124                         insert_block(i);
 125
 126                         mem_info.blocks[i].size = size;
 127                         mem_info.blocks[i].free = 0;
 128                         mem_info.blocks[i + 1].size -= size;
 129
 130                         return (void *)r;
 131                 }
 132
 133                 r += mem_info.blocks[i].size;
 134         }
 135
 136         return NULL;
 137 }
 138
 139 void v86_mem_free(void *m)
 140 {
 141         int i;
 142         char *r = (char *)REAL_MEM_BASE;
 143
 144         if (!mem_info.ready)
 145                 return;
 146
 147         i = 0;
 148         while (m != (void *)r) {
 149                 r += mem_info.blocks[i].size;
 150                 i++;
 151                 if (i == mem_info.count)
 152                         return;
 153         }
 154
 155         mem_info.blocks[i].free = 1;
 156
 157         if (i + 1 < mem_info.count && mem_info.blocks[i + 1].free) {
 158                 mem_info.blocks[i].size += mem_info.blocks[i + 1].size;
 159                 delete_block(i + 1);
 160         }
 161
 162         if (i - 1 >= 0 && mem_info.blocks[i - 1].free) {
 163                 mem_info.blocks[i - 1].size += mem_info.blocks[i].size;
 164                 delete_block(i);
 165         }
 166 }
 167
 168 static inline void set_bit(unsigned int bit, void *array)
 169 {
 170         unsigned char *a = array;
 171         a[bit / 8] |= (1 << (bit % 8));
 172 }
 173
 174 inline u16 get_int_seg(int i)
 175 {
 176         return *(u16 *)(i * 4 + 2);
 177 }
 178
 179 inline u16 get_int_off(int i)
 180 {
 181         return *(u16 *)(i * 4);
 182 }
 183
 184 int v86_mem_init(void)
 185 {
 186         void *m;
 187         int fd_mem;
 188
 189         if (real_mem_init())
 190                 return 1;
 191
 192         if (!map_file((void *)IVTBDA_BASE, IVTBDA_SIZE,
 193                 PROT_READ | PROT_WRITE | PROT_EXEC,
 194                 MAP_FIXED | MAP_PRIVATE, "/dev/zero", 0))
 195         {
 196                 real_mem_deinit();
 197                 return 1;
 198         }
 199
 200         if (!read_file("/dev/mem", (void *)IVTBDA_BASE, IVTBDA_SIZE)) {
 201                 munmap((void *)IVTBDA_BASE, IVTBDA_SIZE);
 202                 real_mem_deinit();
 203                 return 1;
 204         }
 205
 206         if (!map_file((void *)0xa0000, 0x100000 - 0xa0000,
 207                 PROT_READ | PROT_WRITE,
 208                 MAP_FIXED | MAP_SHARED, "/dev/mem", 0xa0000))
 209         {
 210                 munmap((void *)IVTBDA_BASE, IVTBDA_SIZE);
 211                 real_mem_deinit();
 212                 return 1;
 213         }
 214
 215         return 0;
 216 }
 217
 218 void v86_mem_cleanup(void)
 219 {
 220         munmap((void *)IVTBDA_BASE, IVTBDA_SIZE);
 221         munmap((void *)0xa0000, 0x100000 - 0xa0000);
 222
 223         real_mem_deinit();
 224 }
 225
 226