/[gxemul]/trunk/src/memory.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/src/memory.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 4 by dpavlin, Mon Oct 8 16:18:00 2007 UTC revision 22 by dpavlin, Mon Oct 8 16:19:37 2007 UTC
# Line 1  Line 1 
1  /*  /*
2   *  Copyright (C) 2003-2005  Anders Gavare.  All rights reserved.   *  Copyright (C) 2003-2006  Anders Gavare.  All rights reserved.
3   *   *
4   *  Redistribution and use in source and binary forms, with or without   *  Redistribution and use in source and binary forms, with or without
5   *  modification, are permitted provided that the following conditions are met:   *  modification, are permitted provided that the following conditions are met:
# Line 25  Line 25 
25   *  SUCH DAMAGE.   *  SUCH DAMAGE.
26   *   *
27   *   *
28   *  $Id: memory.c,v 1.164 2005/04/09 21:10:54 debug Exp $   *  $Id: memory.c,v 1.187 2006/01/14 12:51:59 debug Exp $
29   *   *
30   *  Functions for handling the memory of an emulated machine.   *  Functions for handling the memory of an emulated machine.
31   */   */
# Line 36  Line 36 
36  #include <sys/types.h>  #include <sys/types.h>
37  #include <sys/mman.h>  #include <sys/mman.h>
38    
 #include "bintrans.h"  
 #include "cop0.h"  
39  #include "cpu.h"  #include "cpu.h"
40  #include "machine.h"  #include "machine.h"
41  #include "memory.h"  #include "memory.h"
 #include "mips_cpu_types.h"  
42  #include "misc.h"  #include "misc.h"
43    
44    
45  extern int quiet_mode;  extern int verbose;
 extern volatile int single_step;  
46    
47    
48  /*  /*
# Line 59  extern volatile int single_step; Line 55  extern volatile int single_step;
55   */   */
56  uint64_t memory_readmax64(struct cpu *cpu, unsigned char *buf, int len)  uint64_t memory_readmax64(struct cpu *cpu, unsigned char *buf, int len)
57  {  {
58          int i;          int i, byte_order = cpu->byte_order;
59          uint64_t x = 0;          uint64_t x = 0;
60    
61            if (len & MEM_PCI_LITTLE_ENDIAN) {
62                    len &= ~MEM_PCI_LITTLE_ENDIAN;
63                    byte_order = EMUL_LITTLE_ENDIAN;
64            }
65    
66          /*  Switch byte order for incoming data, if necessary:  */          /*  Switch byte order for incoming data, if necessary:  */
67          if (cpu->byte_order == EMUL_BIG_ENDIAN)          if (byte_order == EMUL_BIG_ENDIAN)
68                  for (i=0; i<len; i++) {                  for (i=0; i<len; i++) {
69                          x <<= 8;                          x <<= 8;
70                          x |= buf[i];                          x |= buf[i];
# Line 89  uint64_t memory_readmax64(struct cpu *cp Line 90  uint64_t memory_readmax64(struct cpu *cp
90  void memory_writemax64(struct cpu *cpu, unsigned char *buf, int len,  void memory_writemax64(struct cpu *cpu, unsigned char *buf, int len,
91          uint64_t data)          uint64_t data)
92  {  {
93          int i;          int i, byte_order = cpu->byte_order;
94    
95            if (len & MEM_PCI_LITTLE_ENDIAN) {
96                    len &= ~MEM_PCI_LITTLE_ENDIAN;
97                    byte_order = EMUL_LITTLE_ENDIAN;
98            }
99    
100          if (cpu->byte_order == EMUL_LITTLE_ENDIAN)          if (byte_order == EMUL_LITTLE_ENDIAN)
101                  for (i=0; i<len; i++) {                  for (i=0; i<len; i++) {
102                          buf[i] = data & 255;                          buf[i] = data & 255;
103                          data >>= 8;                          data >>= 8;
# Line 108  void memory_writemax64(struct cpu *cpu, Line 114  void memory_writemax64(struct cpu *cpu,
114   *  zeroed_alloc():   *  zeroed_alloc():
115   *   *
116   *  Allocates a block of memory using mmap(), and if that fails, try   *  Allocates a block of memory using mmap(), and if that fails, try
117   *  malloc() + memset().   *  malloc() + memset(). The returned memory block contains only zeroes.
118   */   */
119  void *zeroed_alloc(size_t s)  void *zeroed_alloc(size_t s)
120  {  {
# Line 132  void *zeroed_alloc(size_t s) Line 138  void *zeroed_alloc(size_t s)
138   *  This function creates a new memory object. An emulated machine needs one   *  This function creates a new memory object. An emulated machine needs one
139   *  of these.   *  of these.
140   */   */
141  struct memory *memory_new(uint64_t physical_max)  struct memory *memory_new(uint64_t physical_max, int arch)
142  {  {
143          struct memory *mem;          struct memory *mem;
144          int bits_per_pagetable = BITS_PER_PAGETABLE;          int bits_per_pagetable = BITS_PER_PAGETABLE;
# Line 157  struct memory *memory_new(uint64_t physi Line 163  struct memory *memory_new(uint64_t physi
163          }          }
164    
165          mem->physical_max = physical_max;          mem->physical_max = physical_max;
166            mem->dev_dyntrans_alignment = 4095;
167            if (arch == ARCH_ALPHA)
168                    mem->dev_dyntrans_alignment = 8191;
169    
170          s = entries_per_pagetable * sizeof(void *);          s = entries_per_pagetable * sizeof(void *);
171    
# Line 181  struct memory *memory_new(uint64_t physi Line 190  struct memory *memory_new(uint64_t physi
190  /*  /*
191   *  memory_points_to_string():   *  memory_points_to_string():
192   *   *
193   *  Returns 1 if there's something string-like at addr, otherwise 0.   *  Returns 1 if there's something string-like in emulated memory at address
194     *  addr, otherwise 0.
195   */   */
196  int memory_points_to_string(struct cpu *cpu, struct memory *mem, uint64_t addr,  int memory_points_to_string(struct cpu *cpu, struct memory *mem, uint64_t addr,
197          int min_string_length)          int min_string_length)
# Line 210  int memory_points_to_string(struct cpu * Line 220  int memory_points_to_string(struct cpu *
220  /*  /*
221   *  memory_conv_to_string():   *  memory_conv_to_string():
222   *   *
223   *  Convert virtual memory contents to a string, placing it in a   *  Convert emulated memory contents to a string, placing it in a buffer
224   *  buffer provided by the caller.   *  provided by the caller.
225   */   */
226  char *memory_conv_to_string(struct cpu *cpu, struct memory *mem, uint64_t addr,  char *memory_conv_to_string(struct cpu *cpu, struct memory *mem, uint64_t addr,
227          char *buf, int bufsize)          char *buf, int bufsize)
# Line 253  char *memory_conv_to_string(struct cpu * Line 263  char *memory_conv_to_string(struct cpu *
263    
264    
265  /*  /*
266   *  memory_device_bintrans_access():   *  memory_device_dyntrans_access():
267   *   *
268   *  Get the lowest and highest bintrans access since last time.   *  Get the lowest and highest dyntrans access since last time.
269   */   */
270  void memory_device_bintrans_access(struct cpu *cpu, struct memory *mem,  void memory_device_dyntrans_access(struct cpu *cpu, struct memory *mem,
271          void *extra, uint64_t *low, uint64_t *high)          void *extra, uint64_t *low, uint64_t *high)
272  {  {
 #ifdef BINTRANS  
273          int i, j;          int i, j;
274          size_t s;          size_t s;
275          int need_inval = 0;          int need_inval = 0;
# Line 271  void memory_device_bintrans_access(struc Line 280  void memory_device_bintrans_access(struc
280    
281          for (i=0; i<mem->n_mmapped_devices; i++) {          for (i=0; i<mem->n_mmapped_devices; i++) {
282                  if (mem->dev_extra[i] == extra &&                  if (mem->dev_extra[i] == extra &&
283                      mem->dev_bintrans_data[i] != NULL) {                      mem->dev_flags[i] & DM_DYNTRANS_WRITE_OK &&
284                          if (mem->dev_bintrans_write_low[i] != (uint64_t) -1)                      mem->dev_dyntrans_data[i] != NULL) {
285                            if (mem->dev_dyntrans_write_low[i] != (uint64_t) -1)
286                                  need_inval = 1;                                  need_inval = 1;
287                          if (low != NULL)                          if (low != NULL)
288                                  *low = mem->dev_bintrans_write_low[i];                                  *low = mem->dev_dyntrans_write_low[i];
289                          mem->dev_bintrans_write_low[i] = (uint64_t) -1;                          mem->dev_dyntrans_write_low[i] = (uint64_t) -1;
290    
291                          if (high != NULL)                          if (high != NULL)
292                                  *high = mem->dev_bintrans_write_high[i];                                  *high = mem->dev_dyntrans_write_high[i];
293                          mem->dev_bintrans_write_high[i] = 0;                          mem->dev_dyntrans_write_high[i] = 0;
294    
295                          if (!need_inval)                          if (!need_inval)
296                                  return;                                  return;
297    
                         if (cpu->machine->arch != ARCH_MIPS) {  
                                 /*  TODO!  */  
   
                                 return;  
                         }  
   
298                          /*  Invalidate any pages of this device that might                          /*  Invalidate any pages of this device that might
299                              be in the bintrans load/store cache, by marking                              be in the dyntrans load/store cache, by marking
300                              the pages read-only.  */                              the pages read-only.  */
301                            if (cpu->invalidate_translation_caches != NULL) {
302                          for (s=0; s<mem->dev_length[i]; s+=4096) {                                  for (s=0; s<mem->dev_length[i];
303                                  mips_invalidate_translation_caches_paddr(                                      s+=cpu->machine->arch_pagesize)
304                                      cpu, mem->dev_baseaddr[i] + s);                                          cpu->invalidate_translation_caches
305                                                (cpu, mem->dev_baseaddr[i] + s,
306                                                JUST_MARK_AS_NON_WRITABLE
307                                                | INVALIDATE_PADDR);
308                          }                          }
309    
310                          /*  ... and invalidate the "fast_vaddr_to_hostaddr"                          if (cpu->machine->arch == ARCH_MIPS) {
311                              cache entries that contain pointers to this                                  /*
312                              device:  (NOTE: Device i, cache entry j)  */                                   *  ... and invalidate the "fast_vaddr_to_
313                          for (j=0; j<N_BINTRANS_VADDR_TO_HOST; j++) {                                   *  hostaddr" cache entries that contain
314                                  if (cpu->cd.mips.bintrans_data_hostpage[j] >=                                   *  pointers to this device:  (NOTE: Device i,
315                                      mem->dev_bintrans_data[i] &&                                   *  cache entry j)
316                                      cpu->cd.mips.bintrans_data_hostpage[j] <                                   */
317                                      mem->dev_bintrans_data[i] +                                  for (j=0; j<N_BINTRANS_VADDR_TO_HOST; j++) {
318                                      mem->dev_length[i])                                          if (cpu->cd.
319                                          cpu->cd.mips.                                              mips.bintrans_data_hostpage[j] >=
320                                              bintrans_data_hostpage[j] = NULL;                                              mem->dev_dyntrans_data[i] &&
321                                                cpu->cd.mips.
322                                                bintrans_data_hostpage[j] <
323                                                mem->dev_dyntrans_data[i] +
324                                                mem->dev_length[i])
325                                                    cpu->cd.mips.
326                                                        bintrans_data_hostpage[j]
327                                                        = NULL;
328                                    }
329                          }                          }
   
330                          return;                          return;
331                  }                  }
332          }          }
 #endif  
 }  
   
   
 /*  
  *  memory_device_register_statefunction():  
  *  
  *  TODO: Hm. This is semi-ugly. Should probably be rewritten/redesigned  
  *  some day.  
  */  
 void memory_device_register_statefunction(  
         struct memory *mem, void *extra,  
         int (*dev_f_state)(struct cpu *,  
             struct memory *, void *extra, int wf, int nr,  
             int *type, char **namep, void **data, size_t *len))  
 {  
         int i;  
   
         for (i=0; i<mem->n_mmapped_devices; i++)  
                 if (mem->dev_extra[i] == extra) {  
                         mem->dev_f_state[i] = dev_f_state;  
                         return;  
                 }  
   
         printf("memory_device_register_statefunction(): "  
             "couldn't find the device\n");  
         exit(1);  
333  }  }
334    
335    
# Line 356  void memory_device_register(struct memor Line 343  void memory_device_register(struct memor
343          uint64_t baseaddr, uint64_t len,          uint64_t baseaddr, uint64_t len,
344          int (*f)(struct cpu *,struct memory *,uint64_t,unsigned char *,          int (*f)(struct cpu *,struct memory *,uint64_t,unsigned char *,
345                  size_t,int,void *),                  size_t,int,void *),
346          void *extra, int flags, unsigned char *bintrans_data)          void *extra, int flags, unsigned char *dyntrans_data)
347  {  {
348          int i;          int i, newi = 0;
349    
350          if (mem->n_mmapped_devices >= MAX_DEVICES) {          if (mem->n_mmapped_devices >= MAX_DEVICES) {
351                  fprintf(stderr, "memory_device_register(): too many "                  fprintf(stderr, "memory_device_register(): too many "
# Line 366  void memory_device_register(struct memor Line 353  void memory_device_register(struct memor
353                  exit(1);                  exit(1);
354          }          }
355    
356          /*  Check for collisions:  */          /*
357             *  Figure out at which index to insert this device, and simultaneously
358             *  check for collisions:
359             */
360            newi = -1;
361          for (i=0; i<mem->n_mmapped_devices; i++) {          for (i=0; i<mem->n_mmapped_devices; i++) {
362                    if (i == 0 && baseaddr + len <= mem->dev_baseaddr[i])
363                            newi = i;
364                    if (i > 0 && baseaddr + len <= mem->dev_baseaddr[i] &&
365                        baseaddr >= mem->dev_endaddr[i-1])
366                            newi = i;
367                    if (i == mem->n_mmapped_devices - 1 &&
368                        baseaddr >= mem->dev_endaddr[i])
369                            newi = i + 1;
370    
371                  /*  If we are not colliding with device i, then continue:  */                  /*  If we are not colliding with device i, then continue:  */
372                  if (baseaddr + len <= mem->dev_baseaddr[i])                  if (baseaddr + len <= mem->dev_baseaddr[i])
373                          continue;                          continue;
374                  if (baseaddr >= mem->dev_baseaddr[i] + mem->dev_length[i])                  if (baseaddr >= mem->dev_endaddr[i])
375                          continue;                          continue;
376    
377                  fatal("\nWARNING! \"%s\" collides with device %i (\"%s\")!\n"                  fatal("\nERROR! \"%s\" collides with device %i (\"%s\")!\n",
                     "         Run-time behaviour will be undefined!\n\n",  
378                      device_name, i, mem->dev_name[i]);                      device_name, i, mem->dev_name[i]);
379                    exit(1);
380            }
381            if (mem->n_mmapped_devices == 0)
382                    newi = 0;
383            if (newi == -1) {
384                    fatal("INTERNAL ERROR\n");
385                    exit(1);
386            }
387    
388            if (verbose >= 2) {
389                    /*  (40 bits of physical address is displayed)  */
390                    debug("device at 0x%010llx: %s", (long long)baseaddr,
391                        device_name);
392    
393                    if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)
394                        && (baseaddr & mem->dev_dyntrans_alignment) != 0) {
395                            fatal("\nWARNING: Device dyntrans access, but unaligned"
396                                " baseaddr 0x%llx.\n", (long long)baseaddr);
397                    }
398    
399                    if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)) {
400                            debug(" (dyntrans %s)",
401                                (flags & DM_DYNTRANS_WRITE_OK)? "R/W" : "R");
402                    }
403                    debug("\n");
404            }
405    
406            for (i=0; i<mem->n_mmapped_devices; i++) {
407                    if (dyntrans_data == mem->dev_dyntrans_data[i] &&
408                        mem->dev_flags[i] & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)
409                        && flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)) {
410                            fatal("ERROR: the data pointer used for dyntrans "
411                                "accesses must only be used once!\n");
412                            fatal("(%p cannot be used by '%s'; already in use by '"
413                                "%s')\n", dyntrans_data, device_name,
414                                mem->dev_name[i]);
415                            exit(1);
416                    }
417          }          }
418    
419          /*  (40 bits of physical address is displayed)  */          mem->n_mmapped_devices++;
420          debug("device %2i at 0x%010llx: %s",  
421              mem->n_mmapped_devices, (long long)baseaddr, device_name);          /*
422             *  YUCK! This is ugly. TODO: fix
423  #ifdef BINTRANS           */
424          if (flags & (MEM_BINTRANS_OK | MEM_BINTRANS_WRITE_OK)          /*  Make space for the new entry:  */
425              && (baseaddr & 0xfff) != 0) {          memmove(&mem->dev_name[newi+1], &mem->dev_name[newi], sizeof(char *) *
426                  fatal("\nWARNING: Device bintrans access, but unaligned"              (MAX_DEVICES - newi - 1));
427                      " baseaddr 0x%llx.\n", (long long)baseaddr);          memmove(&mem->dev_baseaddr[newi+1], &mem->dev_baseaddr[newi],
428          }              sizeof(uint64_t) * (MAX_DEVICES - newi - 1));
429            memmove(&mem->dev_endaddr[newi+1], &mem->dev_endaddr[newi],
430          if (flags & (MEM_BINTRANS_OK | MEM_BINTRANS_WRITE_OK)) {              sizeof(uint64_t) * (MAX_DEVICES - newi - 1));
431                  debug(" (bintrans %s)",          memmove(&mem->dev_length[newi+1], &mem->dev_length[newi],
432                      (flags & MEM_BINTRANS_WRITE_OK)? "R/W" : "R");              sizeof(uint64_t) * (MAX_DEVICES - newi - 1));
433          }          memmove(&mem->dev_flags[newi+1], &mem->dev_flags[newi], sizeof(int) *
434  #endif              (MAX_DEVICES - newi - 1));
435          debug("\n");          memmove(&mem->dev_extra[newi+1], &mem->dev_extra[newi], sizeof(void *) *
436                (MAX_DEVICES - newi - 1));
437          mem->dev_name[mem->n_mmapped_devices] = strdup(device_name);          memmove(&mem->dev_f[newi+1], &mem->dev_f[newi], sizeof(void *) *
438          mem->dev_baseaddr[mem->n_mmapped_devices] = baseaddr;              (MAX_DEVICES - newi - 1));
439          mem->dev_length[mem->n_mmapped_devices] = len;          memmove(&mem->dev_dyntrans_data[newi+1], &mem->dev_dyntrans_data[newi],
440          mem->dev_flags[mem->n_mmapped_devices] = flags;              sizeof(void *) * (MAX_DEVICES - newi - 1));
441          mem->dev_bintrans_data[mem->n_mmapped_devices] = bintrans_data;          memmove(&mem->dev_dyntrans_write_low[newi+1],
442                &mem->dev_dyntrans_write_low[newi],
443                sizeof(uint64_t) * (MAX_DEVICES - newi - 1));
444            memmove(&mem->dev_dyntrans_write_high[newi+1],
445                &mem->dev_dyntrans_write_high[newi],
446                sizeof(uint64_t) * (MAX_DEVICES - newi - 1));
447    
448    
449            mem->dev_name[newi] = strdup(device_name);
450            mem->dev_baseaddr[newi] = baseaddr;
451            mem->dev_endaddr[newi] = baseaddr + len;
452            mem->dev_length[newi] = len;
453            mem->dev_flags[newi] = flags;
454            mem->dev_dyntrans_data[newi] = dyntrans_data;
455    
456          if (mem->dev_name[mem->n_mmapped_devices] == NULL) {          if (mem->dev_name[newi] == NULL) {
457                  fprintf(stderr, "out of memory\n");                  fprintf(stderr, "out of memory\n");
458                  exit(1);                  exit(1);
459          }          }
460    
461          if ((size_t)bintrans_data & 1) {          if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)
462                && !(flags & DM_EMULATED_RAM) && dyntrans_data == NULL) {
463                    fatal("\nERROR: Device dyntrans access, but dyntrans_data"
464                        " = NULL!\n");
465                    exit(1);
466            }
467    
468            if ((size_t)dyntrans_data & (sizeof(void *) - 1)) {
469                  fprintf(stderr, "memory_device_register():"                  fprintf(stderr, "memory_device_register():"
470                      " bintrans_data not aligned correctly\n");                      " dyntrans_data not aligned correctly (%p)\n",
471                        dyntrans_data);
472                  exit(1);                  exit(1);
473          }          }
474    
475  #ifdef BINTRANS          mem->dev_dyntrans_write_low[newi] = (uint64_t)-1;
476          mem->dev_bintrans_write_low[mem->n_mmapped_devices] = (uint64_t)-1;          mem->dev_dyntrans_write_high[newi] = 0;
477          mem->dev_bintrans_write_high[mem->n_mmapped_devices] = 0;          mem->dev_f[newi] = f;
478  #endif          mem->dev_extra[newi] = extra;
         mem->dev_f[mem->n_mmapped_devices] = f;  
         mem->dev_extra[mem->n_mmapped_devices] = extra;  
         mem->n_mmapped_devices++;  
479    
480          if (baseaddr < mem->mmap_dev_minaddr)          if (baseaddr < mem->mmap_dev_minaddr)
481                  mem->mmap_dev_minaddr = baseaddr & ~0xfff;                  mem->mmap_dev_minaddr = baseaddr & ~mem->dev_dyntrans_alignment;
482          if (baseaddr + len > mem->mmap_dev_maxaddr)          if (baseaddr + len > mem->mmap_dev_maxaddr)
483                  mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) | 0xfff) + 1;                  mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) |
484                        mem->dev_dyntrans_alignment) + 1;
485  }  }
486    
487    
# Line 454  void memory_device_remove(struct memory Line 510  void memory_device_remove(struct memory
510              (MAX_DEVICES - i - 1));              (MAX_DEVICES - i - 1));
511          memmove(&mem->dev_baseaddr[i], &mem->dev_baseaddr[i+1],          memmove(&mem->dev_baseaddr[i], &mem->dev_baseaddr[i+1],
512              sizeof(uint64_t) * (MAX_DEVICES - i - 1));              sizeof(uint64_t) * (MAX_DEVICES - i - 1));
513            memmove(&mem->dev_endaddr[i], &mem->dev_endaddr[i+1],
514                sizeof(uint64_t) * (MAX_DEVICES - i - 1));
515          memmove(&mem->dev_length[i], &mem->dev_length[i+1], sizeof(uint64_t) *          memmove(&mem->dev_length[i], &mem->dev_length[i+1], sizeof(uint64_t) *
516              (MAX_DEVICES - i - 1));              (MAX_DEVICES - i - 1));
517          memmove(&mem->dev_flags[i], &mem->dev_flags[i+1], sizeof(int) *          memmove(&mem->dev_flags[i], &mem->dev_flags[i+1], sizeof(int) *
# Line 462  void memory_device_remove(struct memory Line 520  void memory_device_remove(struct memory
520              (MAX_DEVICES - i - 1));              (MAX_DEVICES - i - 1));
521          memmove(&mem->dev_f[i], &mem->dev_f[i+1], sizeof(void *) *          memmove(&mem->dev_f[i], &mem->dev_f[i+1], sizeof(void *) *
522              (MAX_DEVICES - i - 1));              (MAX_DEVICES - i - 1));
523          memmove(&mem->dev_f_state[i], &mem->dev_f_state[i+1], sizeof(void *) *          memmove(&mem->dev_dyntrans_data[i], &mem->dev_dyntrans_data[i+1],
             (MAX_DEVICES - i - 1));  
         memmove(&mem->dev_bintrans_data[i], &mem->dev_bintrans_data[i+1],  
524              sizeof(void *) * (MAX_DEVICES - i - 1));              sizeof(void *) * (MAX_DEVICES - i - 1));
525  #ifdef BINTRANS          memmove(&mem->dev_dyntrans_write_low[i], &mem->dev_dyntrans_write_low
526          memmove(&mem->dev_bintrans_write_low[i], &mem->dev_bintrans_write_low              [i+1], sizeof(uint64_t) * (MAX_DEVICES - i - 1));
527              [i+1], sizeof(void *) * (MAX_DEVICES - i - 1));          memmove(&mem->dev_dyntrans_write_high[i], &mem->dev_dyntrans_write_high
528          memmove(&mem->dev_bintrans_write_high[i], &mem->dev_bintrans_write_high              [i+1], sizeof(uint64_t) * (MAX_DEVICES - i - 1));
             [i+1], sizeof(void *) * (MAX_DEVICES - i - 1));  
 #endif  
529  }  }
530    
531    
# Line 501  unsigned char *memory_paddr_to_hostaddr( Line 555  unsigned char *memory_paddr_to_hostaddr(
555          table = mem->pagetable;          table = mem->pagetable;
556          entry = (paddr >> shrcount) & mask;          entry = (paddr >> shrcount) & mask;
557    
558          /*  printf("   entry = %x\n", entry);  */          /*  printf("memory_paddr_to_hostaddr(): p=%16llx w=%i => entry=0x%x\n",
559                (long long)paddr, writeflag, entry);  */
560    
561          if (table[entry] == NULL) {          if (table[entry] == NULL) {
562                  size_t alloclen;                  size_t alloclen;
# Line 524  unsigned char *memory_paddr_to_hostaddr( Line 579  unsigned char *memory_paddr_to_hostaddr(
579                  /*  Anonymous mmap() should return zero-filled memory,                  /*  Anonymous mmap() should return zero-filled memory,
580                      try malloc + memset if mmap failed.  */                      try malloc + memset if mmap failed.  */
581                  table[entry] = (void *) mmap(NULL, alloclen,                  table[entry] = (void *) mmap(NULL, alloclen,
582                      PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,                      PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
                     -1, 0);  
583                  if (table[entry] == NULL) {                  if (table[entry] == NULL) {
584                          table[entry] = malloc(alloclen);                          table[entry] = malloc(alloclen);
585                          if (table[entry] == NULL) {                          if (table[entry] == NULL) {
Legend:
Removed from v.4  
changed lines
  Added in v.22
  ViewVC Help
Powered by ViewVC 1.1.26