sys/src/cmd/ki/mem.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <bio.h>
   4 #include <mach.h>
   5 #define Extern extern
   6 #include "sparc.h"
   7
   8 extern ulong    textbase;
   9
  10 ulong
  11 ifetch(ulong addr)
  12 {
  13         uchar *va;
  14
  15         if(addr&3) {
  16                 Bprint(bioout, "instruction_address_not_aligned [addr %.8lux]\n", addr);
  17                 longjmp(errjmp, 0);
  18         }
  19
  20         if(icache.on)
  21                 updateicache(addr);
  22
  23         va = vaddr(addr);
  24         iprof[(addr-textbase)/PROFGRAN]++;
  25
  26         va += addr&(BY2PG-1);
  27
  28         return va[0]<<24 | va[1]<<16 | va[2]<<8 | va[3];
  29 }
  30
  31 ulong
  32 getmem_4(ulong addr)
  33 {
  34         ulong val;
  35         int i;
  36
  37         val = 0;
  38         for(i = 0; i < 4; i++)
  39                 val = val<<8 | getmem_b(addr++);
  40         return val;
  41 }
  42
  43 ulong
  44 getmem_2(ulong addr)
  45 {
  46         ulong val;
  47
  48         val = getmem_b(addr);
  49         val = val<<8 | getmem_b(addr+1);
  50
  51         return val;
  52 }
  53
  54 ulong
  55 getmem_w(ulong addr)
  56 {
  57         uchar *va;
  58
  59         if(addr&3) {
  60                 Bprint(bioout, "mem_address_not_aligned [load addr %.8lux]\n", addr);
  61                 longjmp(errjmp, 0);
  62         }
  63         if(membpt)
  64                 brkchk(addr, Read);
  65
  66         va = vaddr(addr);
  67         va += addr&(BY2PG-1);
  68
  69         return va[0]<<24 | va[1]<<16 | va[2]<<8 | va[3];;
  70 }
  71
  72 ushort
  73 getmem_h(ulong addr)
  74 {
  75         uchar *va;
  76
  77         if(addr&1) {
  78                 Bprint(bioout, "mem_address_not_aligned [load addr %.8lux]\n", addr);
  79                 longjmp(errjmp, 0);
  80         }
  81         if(membpt)
  82                 brkchk(addr, Read);
  83
  84         va = vaddr(addr);
  85         va += addr&(BY2PG-1);
  86
  87         return va[0]<<8 | va[1];
  88 }
  89
  90 uchar
  91 getmem_b(ulong addr)
  92 {
  93         uchar *va;
  94
  95         if(membpt)
  96                 brkchk(addr, Read);
  97
  98         va = vaddr(addr);
  99         va += addr&(BY2PG-1);
 100         return va[0];
 101 }
 102
 103 void
 104 putmem_w(ulong addr, ulong data)
 105 {
 106         uchar *va;
 107
 108         if(addr&3) {
 109                 Bprint(bioout, "mem_address_not_aligned [store addr %.8lux]\n", addr);
 110                 longjmp(errjmp, 0);
 111         }
 112
 113         va = vaddr(addr);
 114         va += addr&(BY2PG-1);
 115
 116         va[0] = data>>24;
 117         va[1] = data>>16;
 118         va[2] = data>>8;
 119         va[3] = data;
 120         if(membpt)
 121                 brkchk(addr, Write);
 122 }
 123 void
 124 putmem_b(ulong addr, uchar data)
 125 {
 126         uchar *va;
 127
 128         va = vaddr(addr);
 129         va += addr&(BY2PG-1);
 130         va[0] = data;
 131         if(membpt)
 132                 brkchk(addr, Write);
 133 }
 134
 135 void
 136 putmem_h(ulong addr, short data)
 137 {
 138         uchar *va;
 139
 140         if(addr&1) {
 141                 Bprint(bioout, "mem_address_not_aligned [store addr %.8lux]\n", addr);
 142                 longjmp(errjmp, 0);
 143         }
 144
 145         va = vaddr(addr);
 146         va += addr&(BY2PG-1);
 147         va[0] = data>>8;
 148         va[1] = data;
 149         if(membpt)
 150                 brkchk(addr, Write);
 151 }
 152
 153 char *
 154 memio(char *mb, ulong mem, int size, int dir)
 155 {
 156         int i;
 157         char *buf, c;
 158
 159         if(mb == 0)
 160                 mb = emalloc(size);
 161
 162         buf = mb;
 163         switch(dir) {
 164         default:
 165                 fatal(0, "memio");
 166         case MemRead:
 167                 while(size--)
 168                         *mb++ = getmem_b(mem++);
 169                 break;
 170         case MemReadstring:
 171                 for(;;) {
 172                         if(size-- == 0) {
 173                                 Bprint(bioout, "memio: user/kernel copy too long for mipsim\n");
 174                                 longjmp(errjmp, 0);
 175                         }
 176                         c = getmem_b(mem++);
 177                         *mb++ = c;
 178                         if(c == '\0')
 179                                 break;
 180                 }
 181                 break;
 182         case MemWrite:
 183                 for(i = 0; i < size; i++)
 184                         putmem_b(mem++, *mb++);
 185                 break;
 186         }
 187         return buf;
 188 }
 189
 190 void *
 191 vaddr(ulong addr)
 192 {
 193         Segment *s, *es;
 194         int off, foff, l, n;
 195         uchar **p, *a;
 196
 197         es = &memory.seg[Nseg];
 198         for(s = memory.seg; s < es; s++) {
 199                 if(addr >= s->base && addr < s->end) {
 200                         s->refs++;
 201                         off = (addr-s->base)/BY2PG;
 202                         p = &s->table[off];
 203                         if(*p)
 204                                 return *p;
 205                         s->rss++;
 206                         switch(s->type) {
 207                         default:
 208                                 fatal(0, "vaddr");
 209                         case Text:
 210                                 *p = emalloc(BY2PG);
 211                                 if(seek(text, s->fileoff+(off*BY2PG), 0) < 0)
 212                                         fatal(1, "vaddr text seek");
 213                                 if(read(text, *p, BY2PG) < 0)
 214                                         fatal(1, "vaddr text read");
 215                                 return *p;
 216                         case Data:
 217                                 *p = emalloc(BY2PG);
 218                                 foff = s->fileoff+(off*BY2PG);
 219                                 if(seek(text, foff, 0) < 0)
 220                                         fatal(1, "vaddr text seek");
 221                                 n = read(text, *p, BY2PG);
 222                                 if(n < 0)
 223                                         fatal(1, "vaddr text read");
 224                                 if(foff + n > s->fileend) {
 225                                         l = BY2PG - (s->fileend-foff);
 226                                         a = *p+(s->fileend-foff);
 227                                         memset(a, 0, l);
 228                                 }
 229                                 return *p;
 230                         case Bss:
 231                         case Stack:
 232                                 *p = emalloc(BY2PG);
 233                                 return *p;
 234                         }
 235                 }
 236         }
 237         Bprint(bioout, "data_access_MMU_miss [addr 0x%.8lux]\n", addr);
 238         longjmp(errjmp, 0);
 239         return 0;               /*to stop compiler whining*/
 240 }