trunk/src/memory.c

/*
 *  Copyright (C) 2003-2006  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: memory.c,v 1.199 2006/10/24 09:32:48 debug Exp $
 *
 *  Functions for handling the memory of an emulated machine.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/mman.h>

#include "cpu.h"
#include "machine.h"
#include "memory.h"
#include "misc.h"


extern int verbose;


/*
 *  memory_readmax64():
 *
 *  Read at most 64 bits of data from a buffer.  Length is given by
 *  len, and the byte order by cpu->byte_order.
 *
 *  This function should not be called with cpu == NULL.
 */
uint64_t memory_readmax64(struct cpu *cpu, unsigned char *buf, int len)
{
        int i, byte_order = cpu->byte_order;
        uint64_t x = 0;

        if (len & MEM_PCI_LITTLE_ENDIAN) {
                len &= ~MEM_PCI_LITTLE_ENDIAN;
                byte_order = EMUL_LITTLE_ENDIAN;
        }

        /*  Switch byte order for incoming data, if necessary:  */
        if (byte_order == EMUL_BIG_ENDIAN)
                for (i=0; i<len; i++) {
                        x <<= 8;
                        x |= buf[i];
                }
        else
                for (i=len-1; i>=0; i--) {
                        x <<= 8;
                        x |= buf[i];
                }

        return x;
}


/*
 *  memory_writemax64():
 *
 *  Write at most 64 bits of data to a buffer.  Length is given by
 *  len, and the byte order by cpu->byte_order.
 *
 *  This function should not be called with cpu == NULL.
 */
void memory_writemax64(struct cpu *cpu, unsigned char *buf, int len,
        uint64_t data)
{
        int i, byte_order = cpu->byte_order;

        if (len & MEM_PCI_LITTLE_ENDIAN) {
                len &= ~MEM_PCI_LITTLE_ENDIAN;
                byte_order = EMUL_LITTLE_ENDIAN;
        }

        if (byte_order == EMUL_LITTLE_ENDIAN)
                for (i=0; i<len; i++) {
                        buf[i] = data & 255;
                        data >>= 8;
                }
        else
                for (i=0; i<len; i++) {
                        buf[len - 1 - i] = data & 255;
                        data >>= 8;
                }
}


/*
 *  zeroed_alloc():
 *
 *  Allocates a block of memory using mmap(), and if that fails, try
 *  malloc() + memset(). The returned memory block contains only zeroes.
 */
void *zeroed_alloc(size_t s)
{
        void *p = mmap(NULL, s, PROT_READ | PROT_WRITE,
            MAP_ANON | MAP_PRIVATE, -1, 0);

        if (p == NULL) {
#if 1
                fprintf(stderr, "zeroed_alloc(): mmap() failed. This should"
                    " not usually happen. If you can reproduce this, then"
                    " please contact me with details about your run-time"
                    " environment.\n");
                exit(1);
#else
                p = malloc(s);
                if (p == NULL) {
                        fprintf(stderr, "out of memory\n");
                        exit(1);
                }
                memset(p, 0, s);
#endif
        }

        return p;
}


/*
 *  memory_new():
 *
 *  This function creates a new memory object. An emulated machine needs one
 *  of these.
 */
struct memory *memory_new(uint64_t physical_max, int arch)
{
        struct memory *mem;
        int bits_per_pagetable = BITS_PER_PAGETABLE;
        int bits_per_memblock = BITS_PER_MEMBLOCK;
        int entries_per_pagetable = 1 << BITS_PER_PAGETABLE;
        int max_bits = MAX_BITS;
        size_t s;

        mem = malloc(sizeof(struct memory));
        if (mem == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        memset(mem, 0, sizeof(struct memory));

        /*  Check bits_per_pagetable and bits_per_memblock for sanity:  */
        if (bits_per_pagetable + bits_per_memblock != max_bits) {
                fprintf(stderr, "memory_new(): bits_per_pagetable and "
                    "bits_per_memblock mismatch\n");
                exit(1);
        }

        mem->physical_max = physical_max;
        mem->dev_dyntrans_alignment = 4095;
        if (arch == ARCH_ALPHA)
                mem->dev_dyntrans_alignment = 8191;

        s = entries_per_pagetable * sizeof(void *);

        mem->pagetable = (unsigned char *) mmap(NULL, s,
            PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
        if (mem->pagetable == NULL) {
                mem->pagetable = malloc(s);
                if (mem->pagetable == NULL) {
                        fprintf(stderr, "out of memory\n");
                        exit(1);
                }
                memset(mem->pagetable, 0, s);
        }

        mem->mmap_dev_minaddr = 0xffffffffffffffffULL;
        mem->mmap_dev_maxaddr = 0;

        return mem;
}


/*
 *  memory_points_to_string():
 *
 *  Returns 1 if there's something string-like in emulated memory at address
 *  addr, otherwise 0.
 */
int memory_points_to_string(struct cpu *cpu, struct memory *mem, uint64_t addr,
        int min_string_length)
{
        int cur_length = 0;
        unsigned char c;

        for (;;) {
                c = '\0';
                cpu->memory_rw(cpu, mem, addr+cur_length,
                    &c, sizeof(c), MEM_READ, CACHE_NONE | NO_EXCEPTIONS);
                if (c=='\n' || c=='\t' || c=='\r' || (c>=' ' && c<127)) {
                        cur_length ++;
                        if (cur_length >= min_string_length)
                                return 1;
                } else {
                        if (cur_length >= min_string_length)
                                return 1;
                        else
                                return 0;
                }
        }
}


/*
 *  memory_conv_to_string():
 *
 *  Convert emulated memory contents to a string, placing it in a buffer
 *  provided by the caller.
 */
char *memory_conv_to_string(struct cpu *cpu, struct memory *mem, uint64_t addr,
        char *buf, int bufsize)
{
        int len = 0;
        int output_index = 0;
        unsigned char c, p='\0';

        while (output_index < bufsize-1) {
                c = '\0';
                cpu->memory_rw(cpu, mem, addr+len, &c, sizeof(c), MEM_READ,
                    CACHE_NONE | NO_EXCEPTIONS);
                buf[output_index] = c;
                if (c>=' ' && c<127) {
                        len ++;
                        output_index ++;
                } else if (c=='\n' || c=='\r' || c=='\t') {
                        len ++;
                        buf[output_index] = '\\';
                        output_index ++;
                        switch (c) {
                        case '\n':      p = 'n'; break;
                        case '\r':      p = 'r'; break;
                        case '\t':      p = 't'; break;
                        }
                        if (output_index < bufsize-1) {
                                buf[output_index] = p;
                                output_index ++;
                        }
                } else {
                        buf[output_index] = '\0';
                        return buf;
                }
        }

        buf[bufsize-1] = '\0';
        return buf;
}


/*
 *  memory_device_dyntrans_access():
 *
 *  Get the lowest and highest dyntrans access since last time.
 */
void memory_device_dyntrans_access(struct cpu *cpu, struct memory *mem,
        void *extra, uint64_t *low, uint64_t *high)
{
        size_t s;
        int i, need_inval = 0;

        /*  TODO: This is O(n), so it might be good to rewrite it some day.
            For now, it will be enough, as long as this function is not
            called too often.  */

        for (i=0; i<mem->n_mmapped_devices; i++) {
                if (mem->devices[i].extra == extra &&
                    mem->devices[i].flags & DM_DYNTRANS_WRITE_OK &&
                    mem->devices[i].dyntrans_data != NULL) {
                        if (mem->devices[i].dyntrans_write_low != (uint64_t) -1)
                                need_inval = 1;
                        if (low != NULL)
                                *low = mem->devices[i].dyntrans_write_low;
                        mem->devices[i].dyntrans_write_low = (uint64_t) -1;

                        if (high != NULL)
                                *high = mem->devices[i].dyntrans_write_high;
                        mem->devices[i].dyntrans_write_high = 0;

                        if (!need_inval)
                                return;

                        /*  Invalidate any pages of this device that might
                            be in the dyntrans load/store cache, by marking
                            the pages read-only.  */
                        if (cpu->invalidate_translation_caches != NULL) {
                                for (s = *low; s <= *high;
                                    s += cpu->machine->arch_pagesize)
                                        cpu->invalidate_translation_caches
                                            (cpu, mem->devices[i].baseaddr + s,
                                            JUST_MARK_AS_NON_WRITABLE
                                            | INVALIDATE_PADDR);
                        }

                        return;
                }
        }
}


/*
 *  memory_device_update_data():
 *
 *  Update a device' dyntrans data pointer.
 *
 *  SUPER-IMPORTANT NOTE: Anyone who changes a dyntrans data pointer while
 *  things are running also needs to invalidate all CPUs' address translation
 *  caches!  Otherwise, these may contain old pointers to the old data.
 */
void memory_device_update_data(struct memory *mem, void *extra,
        unsigned char *data)
{
        int i;

        for (i=0; i<mem->n_mmapped_devices; i++) {
                if (mem->devices[i].extra != extra)
                        continue;

                mem->devices[i].dyntrans_data = data;
                mem->devices[i].dyntrans_write_low = (uint64_t)-1;
                mem->devices[i].dyntrans_write_high = 0;
        }
}


/*
 *  memory_device_register():
 *
 *  Register a memory mapped device.
 */
void memory_device_register(struct memory *mem, const char *device_name,
        uint64_t baseaddr, uint64_t len,
        int (*f)(struct cpu *,struct memory *,uint64_t,unsigned char *,
                size_t,int,void *),
        void *extra, int flags, unsigned char *dyntrans_data)
{
        int i, newi = 0;

        /*
         *  Figure out at which index to insert this device, and simultaneously
         *  check for collisions:
         */
        newi = -1;
        for (i=0; i<mem->n_mmapped_devices; i++) {
                if (i == 0 && baseaddr + len <= mem->devices[i].baseaddr)
                        newi = i;
                if (i > 0 && baseaddr + len <= mem->devices[i].baseaddr &&
                    baseaddr >= mem->devices[i-1].endaddr)
                        newi = i;
                if (i == mem->n_mmapped_devices - 1 &&
                    baseaddr >= mem->devices[i].endaddr)
                        newi = i + 1;

                /*  If this is not colliding with device i, then continue:  */
                if (baseaddr + len <= mem->devices[i].baseaddr)
                        continue;
                if (baseaddr >= mem->devices[i].endaddr)
                        continue;

                fatal("\nERROR! \"%s\" collides with device %i (\"%s\")!\n",
                    device_name, i, mem->devices[i].name);
                exit(1);
        }
        if (mem->n_mmapped_devices == 0)
                newi = 0;
        if (newi == -1) {
                fatal("INTERNAL ERROR\n");
                exit(1);
        }

        if (verbose >= 2) {
                /*  (40 bits of physical address is displayed)  */
                debug("device at 0x%010"PRIx64": %s", (uint64_t) baseaddr,
                    device_name);

                if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)
                    && (baseaddr & mem->dev_dyntrans_alignment) != 0) {
                        fatal("\nWARNING: Device dyntrans access, but unaligned"
                            " baseaddr 0x%"PRIx64".\n", (uint64_t) baseaddr);
                }

                if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)) {
                        debug(" (dyntrans %s)",
                            (flags & DM_DYNTRANS_WRITE_OK)? "R/W" : "R");
                }
                debug("\n");
        }

        for (i=0; i<mem->n_mmapped_devices; i++) {
                if (dyntrans_data == mem->devices[i].dyntrans_data &&
                    mem->devices[i].flags&(DM_DYNTRANS_OK|DM_DYNTRANS_WRITE_OK)
                    && flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)) {
                        fatal("ERROR: the data pointer used for dyntrans "
                            "accesses must only be used once!\n");
                        fatal("(%p cannot be used by '%s'; already in use by '"
                            "%s')\n", dyntrans_data, device_name,
                            mem->devices[i].name);
                        exit(1);
                }
        }

        mem->n_mmapped_devices++;

        mem->devices = realloc(mem->devices, sizeof(struct memory_device)
            * mem->n_mmapped_devices);
        if (mem->devices == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        /*  Make space for the new entry:  */
        if (newi + 1 != mem->n_mmapped_devices)
                memmove(&mem->devices[newi+1], &mem->devices[newi],
                    sizeof(struct memory_device)
                    * (mem->n_mmapped_devices - newi - 1));

        mem->devices[newi].name = strdup(device_name);
        mem->devices[newi].baseaddr = baseaddr;
        mem->devices[newi].endaddr = baseaddr + len;
        mem->devices[newi].length = len;
        mem->devices[newi].flags = flags;
        mem->devices[newi].dyntrans_data = dyntrans_data;

        if (mem->devices[newi].name == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)
            && !(flags & DM_EMULATED_RAM) && dyntrans_data == NULL) {
                fatal("\nERROR: Device dyntrans access, but dyntrans_data"
                    " = NULL!\n");
                exit(1);
        }

        if ((size_t)dyntrans_data & (sizeof(void *) - 1)) {
                fprintf(stderr, "memory_device_register():"
                    " dyntrans_data not aligned correctly (%p)\n",
                    dyntrans_data);
                exit(1);
        }

        mem->devices[newi].dyntrans_write_low = (uint64_t)-1;
        mem->devices[newi].dyntrans_write_high = 0;
        mem->devices[newi].f = f;
        mem->devices[newi].extra = extra;

        if (baseaddr < mem->mmap_dev_minaddr)
                mem->mmap_dev_minaddr = baseaddr & ~mem->dev_dyntrans_alignment;
        if (baseaddr + len > mem->mmap_dev_maxaddr)
                mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) |
                    mem->dev_dyntrans_alignment) + 1;

        if (newi < mem->last_accessed_device)
                mem->last_accessed_device ++;
}


/*
 *  memory_device_remove():
 *
 *  Unregister a memory mapped device from a memory object.
 */
void memory_device_remove(struct memory *mem, int i)
{
        if (i < 0 || i >= mem->n_mmapped_devices) {
                fatal("memory_device_remove(): invalid device number %i\n", i);
                exit(1);
        }

        mem->n_mmapped_devices --;

        if (i == mem->n_mmapped_devices)
                return;

        memmove(&mem->devices[i], &mem->devices[i+1],
            sizeof(struct memory_device) * (mem->n_mmapped_devices - i));

        if (i <= mem->last_accessed_device)
                mem->last_accessed_device --;
        if (mem->last_accessed_device < 0)
                mem->last_accessed_device = 0;
}


#define MEMORY_RW       userland_memory_rw
#define MEM_USERLAND
#include "memory_rw.c"
#undef MEM_USERLAND
#undef MEMORY_RW


/*
 *  memory_paddr_to_hostaddr():
 *
 *  Translate a physical address into a host address. The usual way to call
 *  this function is to make sure that paddr is page aligned, which will result
 *  in the host _page_ corresponding to that address.
 *
 *  Return value is a pointer to the address in the host, or NULL on failure.
 *  On reads, a NULL return value should be interpreted as reading all zeroes.
 */
unsigned char *memory_paddr_to_hostaddr(struct memory *mem,
        uint64_t paddr, int writeflag)
{
        void **table;
        int entry;
        const int mask = (1 << BITS_PER_PAGETABLE) - 1;
        const int shrcount = MAX_BITS - BITS_PER_PAGETABLE;
        unsigned char *hostptr;

        table = mem->pagetable;
        entry = (paddr >> shrcount) & mask;

        /*  printf("memory_paddr_to_hostaddr(): p=%16"PRIx64
            " w=%i => entry=0x%x\n", (uint64_t) paddr, writeflag, entry);  */

        if (table[entry] == NULL) {
                size_t alloclen;

                /*
                 *  Special case:  reading from a nonexistant memblock
                 *  returns all zeroes, and doesn't allocate anything.
                 *  (If any intermediate pagetable is nonexistant, then
                 *  the same thing happens):
                 */
                if (writeflag == MEM_READ)
                        return NULL;

                /*  Allocate a memblock:  */
                alloclen = 1 << BITS_PER_MEMBLOCK;

                /*  printf("  allocating for entry %i, len=%i\n",
                    entry, alloclen);  */

                /*  Anonymous mmap() should return zero-filled memory,
                    try malloc + memset if mmap failed.  */
                table[entry] = (void *) mmap(NULL, alloclen,
                    PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
                if (table[entry] == NULL) {
                        table[entry] = malloc(alloclen);
                        if (table[entry] == NULL) {
                                fatal("out of memory\n");
                                exit(1);
                        }
                        memset(table[entry], 0, alloclen);
                }
        }

        hostptr = (unsigned char *) table[entry];

        if (hostptr != NULL)
                hostptr += (paddr & ((1 << BITS_PER_MEMBLOCK) - 1));

        return hostptr;
}


#define UPDATE_CHECKSUM(value) {                                        \
                internal_state -= 0x118c7771c0c0a77fULL;                \
                internal_state = ((internal_state + (value)) << 7) ^    \
                    (checksum >> 11) ^ ((checksum - (value)) << 3) ^    \
                    (internal_state - checksum) ^ ((value) - internal_state); \
                checksum ^= internal_state;                             \
        }


/*
 *  memory_checksum():
 *
 *  Calculate a 64-bit checksum of everything in a struct memory. This is
 *  useful for tracking down bugs; an old (presumably working) version of
 *  the emulator can be compared to a newer (buggy) version.
 */
uint64_t memory_checksum(struct memory *mem)
{
        uint64_t internal_state = 0x80624185376feff2ULL;
        uint64_t checksum = 0xcb9a87d5c010072cULL;
        const int n_entries = (1 << BITS_PER_PAGETABLE) - 1;
        const size_t len = (1 << BITS_PER_MEMBLOCK) / sizeof(uint64_t);
        size_t entry, i;

        for (entry=0; entry<=n_entries; entry++) {
                uint64_t **table = mem->pagetable;
                uint64_t *memblock = table[entry];

                if (memblock == NULL) {
                        UPDATE_CHECKSUM(0x1198ab7c8174a76fULL);
                        continue;
                }

                for (i=0; i<len; i++)
                        UPDATE_CHECKSUM(memblock[i]);
        }

        return checksum;
}

1	dpavlin	2	/*
2	dpavlin	22	* Copyright (C) 2003-2006 Anders Gavare. All rights reserved.
3	dpavlin	2	*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	32	* $Id: memory.c,v 1.199 2006/10/24 09:32:48 debug Exp $
29	dpavlin	2	*
30			* Functions for handling the memory of an emulated machine.
31			*/
32
33			#include <stdio.h>
34			#include <stdlib.h>
35			#include <string.h>
36			#include <sys/types.h>
37			#include <sys/mman.h>
38
39			#include "cpu.h"
40			#include "machine.h"
41			#include "memory.h"
42			#include "misc.h"
43
44
45	dpavlin	22	extern int verbose;
46	dpavlin	2
47
48			/*
49			* memory_readmax64():
50			*
51			* Read at most 64 bits of data from a buffer. Length is given by
52			* len, and the byte order by cpu->byte_order.
53			*
54			* This function should not be called with cpu == NULL.
55			*/
56			uint64_t memory_readmax64(struct cpu cpu, unsigned char buf, int len)
57			{
58	dpavlin	20	int i, byte_order = cpu->byte_order;
59	dpavlin	2	uint64_t x = 0;
60
61	dpavlin	20	if (len & MEM_PCI_LITTLE_ENDIAN) {
62			len &= ~MEM_PCI_LITTLE_ENDIAN;
63			byte_order = EMUL_LITTLE_ENDIAN;
64			}
65
66	dpavlin	2	/* Switch byte order for incoming data, if necessary: */
67	dpavlin	20	if (byte_order == EMUL_BIG_ENDIAN)
68	dpavlin	2	for (i=0; i<len; i++) {
69			x <<= 8;
70			x \|= buf[i];
71			}
72			else
73			for (i=len-1; i>=0; i--) {
74			x <<= 8;
75			x \|= buf[i];
76			}
77
78			return x;
79			}
80
81
82			/*
83			* memory_writemax64():
84			*
85			* Write at most 64 bits of data to a buffer. Length is given by
86			* len, and the byte order by cpu->byte_order.
87			*
88			* This function should not be called with cpu == NULL.
89			*/
90			void memory_writemax64(struct cpu cpu, unsigned char buf, int len,
91			uint64_t data)
92			{
93	dpavlin	20	int i, byte_order = cpu->byte_order;
94	dpavlin	2
95	dpavlin	20	if (len & MEM_PCI_LITTLE_ENDIAN) {
96			len &= ~MEM_PCI_LITTLE_ENDIAN;
97			byte_order = EMUL_LITTLE_ENDIAN;
98			}
99
100			if (byte_order == EMUL_LITTLE_ENDIAN)
101	dpavlin	2	for (i=0; i<len; i++) {
102			buf[i] = data & 255;
103			data >>= 8;
104			}
105			else
106			for (i=0; i<len; i++) {
107			buf[len - 1 - i] = data & 255;
108			data >>= 8;
109			}
110			}
111
112
113			/*
114			* zeroed_alloc():
115			*
116			* Allocates a block of memory using mmap(), and if that fails, try
117	dpavlin	12	* malloc() + memset(). The returned memory block contains only zeroes.
118	dpavlin	2	*/
119			void *zeroed_alloc(size_t s)
120			{
121			void *p = mmap(NULL, s, PROT_READ \| PROT_WRITE,
122			MAP_ANON \| MAP_PRIVATE, -1, 0);
123	dpavlin	32
124	dpavlin	2	if (p == NULL) {
125	dpavlin	32	#if 1
126			fprintf(stderr, "zeroed_alloc(): mmap() failed. This should"
127			" not usually happen. If you can reproduce this, then"
128			" please contact me with details about your run-time"
129			" environment.\n");
130			exit(1);
131			#else
132	dpavlin	2	p = malloc(s);
133			if (p == NULL) {
134			fprintf(stderr, "out of memory\n");
135			exit(1);
136			}
137			memset(p, 0, s);
138	dpavlin	32	#endif
139	dpavlin	2	}
140	dpavlin	32
141	dpavlin	2	return p;
142			}
143
144
145			/*
146			* memory_new():
147			*
148			* This function creates a new memory object. An emulated machine needs one
149			* of these.
150			*/
151	dpavlin	12	struct memory *memory_new(uint64_t physical_max, int arch)
152	dpavlin	2	{
153			struct memory *mem;
154			int bits_per_pagetable = BITS_PER_PAGETABLE;
155			int bits_per_memblock = BITS_PER_MEMBLOCK;
156			int entries_per_pagetable = 1 << BITS_PER_PAGETABLE;
157			int max_bits = MAX_BITS;
158			size_t s;
159
160			mem = malloc(sizeof(struct memory));
161			if (mem == NULL) {
162			fprintf(stderr, "out of memory\n");
163			exit(1);
164			}
165
166			memset(mem, 0, sizeof(struct memory));
167
168			/* Check bits_per_pagetable and bits_per_memblock for sanity: */
169			if (bits_per_pagetable + bits_per_memblock != max_bits) {
170			fprintf(stderr, "memory_new(): bits_per_pagetable and "
171			"bits_per_memblock mismatch\n");
172			exit(1);
173			}
174
175			mem->physical_max = physical_max;
176	dpavlin	12	mem->dev_dyntrans_alignment = 4095;
177			if (arch == ARCH_ALPHA)
178			mem->dev_dyntrans_alignment = 8191;
179	dpavlin	2
180			s = entries_per_pagetable * sizeof(void *);
181
182			mem->pagetable = (unsigned char *) mmap(NULL, s,
183			PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE, -1, 0);
184			if (mem->pagetable == NULL) {
185			mem->pagetable = malloc(s);
186			if (mem->pagetable == NULL) {
187			fprintf(stderr, "out of memory\n");
188			exit(1);
189			}
190			memset(mem->pagetable, 0, s);
191			}
192
193			mem->mmap_dev_minaddr = 0xffffffffffffffffULL;
194			mem->mmap_dev_maxaddr = 0;
195
196			return mem;
197			}
198
199
200			/*
201			* memory_points_to_string():
202			*
203	dpavlin	22	* Returns 1 if there's something string-like in emulated memory at address
204			* addr, otherwise 0.
205	dpavlin	2	*/
206			int memory_points_to_string(struct cpu cpu, struct memory mem, uint64_t addr,
207			int min_string_length)
208			{
209			int cur_length = 0;
210			unsigned char c;
211
212			for (;;) {
213			c = '\0';
214			cpu->memory_rw(cpu, mem, addr+cur_length,
215			&c, sizeof(c), MEM_READ, CACHE_NONE \| NO_EXCEPTIONS);
216			if (c=='\n' \|\| c=='\t' \|\| c=='\r' \|\| (c>=' ' && c<127)) {
217			cur_length ++;
218			if (cur_length >= min_string_length)
219			return 1;
220			} else {
221			if (cur_length >= min_string_length)
222			return 1;
223			else
224			return 0;
225			}
226			}
227			}
228
229
230			/*
231			* memory_conv_to_string():
232			*
233	dpavlin	22	* Convert emulated memory contents to a string, placing it in a buffer
234			* provided by the caller.
235	dpavlin	2	*/
236			char memory_conv_to_string(struct cpu cpu, struct memory *mem, uint64_t addr,
237			char *buf, int bufsize)
238			{
239			int len = 0;
240			int output_index = 0;
241			unsigned char c, p='\0';
242
243			while (output_index < bufsize-1) {
244			c = '\0';
245			cpu->memory_rw(cpu, mem, addr+len, &c, sizeof(c), MEM_READ,
246			CACHE_NONE \| NO_EXCEPTIONS);
247			buf[output_index] = c;
248			if (c>=' ' && c<127) {
249			len ++;
250			output_index ++;
251			} else if (c=='\n' \|\| c=='\r' \|\| c=='\t') {
252			len ++;
253			buf[output_index] = '\\';
254			output_index ++;
255			switch (c) {
256			case '\n': p = 'n'; break;
257			case '\r': p = 'r'; break;
258			case '\t': p = 't'; break;
259			}
260			if (output_index < bufsize-1) {
261			buf[output_index] = p;
262			output_index ++;
263			}
264			} else {
265			buf[output_index] = '\0';
266			return buf;
267			}
268			}
269
270			buf[bufsize-1] = '\0';
271			return buf;
272			}
273
274
275			/*
276	dpavlin	12	* memory_device_dyntrans_access():
277	dpavlin	2	*
278	dpavlin	22	* Get the lowest and highest dyntrans access since last time.
279	dpavlin	2	*/
280	dpavlin	12	void memory_device_dyntrans_access(struct cpu cpu, struct memory mem,
281	dpavlin	2	void extra, uint64_t low, uint64_t *high)
282			{
283			size_t s;
284	dpavlin	24	int i, need_inval = 0;
285	dpavlin	2
286			/* TODO: This is O(n), so it might be good to rewrite it some day.
287			For now, it will be enough, as long as this function is not
288			called too often. */
289
290			for (i=0; i<mem->n_mmapped_devices; i++) {
291	dpavlin	32	if (mem->devices[i].extra == extra &&
292			mem->devices[i].flags & DM_DYNTRANS_WRITE_OK &&
293			mem->devices[i].dyntrans_data != NULL) {
294			if (mem->devices[i].dyntrans_write_low != (uint64_t) -1)
295	dpavlin	2	need_inval = 1;
296			if (low != NULL)
297	dpavlin	32	*low = mem->devices[i].dyntrans_write_low;
298			mem->devices[i].dyntrans_write_low = (uint64_t) -1;
299	dpavlin	2
300			if (high != NULL)
301	dpavlin	32	*high = mem->devices[i].dyntrans_write_high;
302			mem->devices[i].dyntrans_write_high = 0;
303	dpavlin	2
304			if (!need_inval)
305			return;
306
307			/* Invalidate any pages of this device that might
308	dpavlin	12	be in the dyntrans load/store cache, by marking
309	dpavlin	2	the pages read-only. */
310	dpavlin	18	if (cpu->invalidate_translation_caches != NULL) {
311	dpavlin	32	for (s = low; s <= high;
312			s += cpu->machine->arch_pagesize)
313	dpavlin	18	cpu->invalidate_translation_caches
314	dpavlin	32	(cpu, mem->devices[i].baseaddr + s,
315	dpavlin	18	JUST_MARK_AS_NON_WRITABLE
316			\| INVALIDATE_PADDR);
317	dpavlin	2	}
318
319			return;
320			}
321			}
322			}
323
324
325			/*
326	dpavlin	28	* memory_device_update_data():
327			*
328			* Update a device' dyntrans data pointer.
329			*
330			* SUPER-IMPORTANT NOTE: Anyone who changes a dyntrans data pointer while
331			* things are running also needs to invalidate all CPUs' address translation
332			* caches! Otherwise, these may contain old pointers to the old data.
333			*/
334			void memory_device_update_data(struct memory mem, void extra,
335			unsigned char *data)
336			{
337			int i;
338
339			for (i=0; i<mem->n_mmapped_devices; i++) {
340	dpavlin	32	if (mem->devices[i].extra != extra)
341	dpavlin	28	continue;
342
343	dpavlin	32	mem->devices[i].dyntrans_data = data;
344			mem->devices[i].dyntrans_write_low = (uint64_t)-1;
345			mem->devices[i].dyntrans_write_high = 0;
346	dpavlin	28	}
347			}
348
349
350			/*
351	dpavlin	2	* memory_device_register():
352			*
353	dpavlin	32	* Register a memory mapped device.
354	dpavlin	2	*/
355			void memory_device_register(struct memory mem, const char device_name,
356			uint64_t baseaddr, uint64_t len,
357			int (f)(struct cpu ,struct memory ,uint64_t,unsigned char ,
358			size_t,int,void *),
359	dpavlin	12	void extra, int flags, unsigned char dyntrans_data)
360	dpavlin	2	{
361	dpavlin	22	int i, newi = 0;
362	dpavlin	2
363	dpavlin	22	/*
364			* Figure out at which index to insert this device, and simultaneously
365			* check for collisions:
366			*/
367			newi = -1;
368	dpavlin	2	for (i=0; i<mem->n_mmapped_devices; i++) {
369	dpavlin	32	if (i == 0 && baseaddr + len <= mem->devices[i].baseaddr)
370	dpavlin	22	newi = i;
371	dpavlin	32	if (i > 0 && baseaddr + len <= mem->devices[i].baseaddr &&
372			baseaddr >= mem->devices[i-1].endaddr)
373	dpavlin	22	newi = i;
374			if (i == mem->n_mmapped_devices - 1 &&
375	dpavlin	32	baseaddr >= mem->devices[i].endaddr)
376	dpavlin	22	newi = i + 1;
377
378	dpavlin	32	/* If this is not colliding with device i, then continue: */
379			if (baseaddr + len <= mem->devices[i].baseaddr)
380	dpavlin	2	continue;
381	dpavlin	32	if (baseaddr >= mem->devices[i].endaddr)
382	dpavlin	2	continue;
383
384	dpavlin	22	fatal("\nERROR! \"%s\" collides with device %i (\"%s\")!\n",
385	dpavlin	32	device_name, i, mem->devices[i].name);
386	dpavlin	22	exit(1);
387	dpavlin	2	}
388	dpavlin	22	if (mem->n_mmapped_devices == 0)
389			newi = 0;
390			if (newi == -1) {
391			fatal("INTERNAL ERROR\n");
392			exit(1);
393			}
394	dpavlin	2
395	dpavlin	22	if (verbose >= 2) {
396			/* (40 bits of physical address is displayed) */
397	dpavlin	24	debug("device at 0x%010"PRIx64": %s", (uint64_t) baseaddr,
398	dpavlin	22	device_name);
399	dpavlin	2
400	dpavlin	22	if (flags & (DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK)
401			&& (baseaddr & mem->dev_dyntrans_alignment) != 0) {
402			fatal("\nWARNING: Device dyntrans access, but unaligned"
403	dpavlin	24	" baseaddr 0x%"PRIx64".\n", (uint64_t) baseaddr);
404	dpavlin	22	}
405
406			if (flags & (DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK)) {
407			debug(" (dyntrans %s)",
408			(flags & DM_DYNTRANS_WRITE_OK)? "R/W" : "R");
409			}
410			debug("\n");
411	dpavlin	2	}
412
413	dpavlin	22	for (i=0; i<mem->n_mmapped_devices; i++) {
414	dpavlin	32	if (dyntrans_data == mem->devices[i].dyntrans_data &&
415			mem->devices[i].flags&(DM_DYNTRANS_OK\|DM_DYNTRANS_WRITE_OK)
416	dpavlin	22	&& flags & (DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK)) {
417			fatal("ERROR: the data pointer used for dyntrans "
418			"accesses must only be used once!\n");
419			fatal("(%p cannot be used by '%s'; already in use by '"
420			"%s')\n", dyntrans_data, device_name,
421	dpavlin	32	mem->devices[i].name);
422	dpavlin	22	exit(1);
423			}
424	dpavlin	2	}
425
426	dpavlin	22	mem->n_mmapped_devices++;
427	dpavlin	2
428	dpavlin	32	mem->devices = realloc(mem->devices, sizeof(struct memory_device)
429			* mem->n_mmapped_devices);
430			if (mem->devices == NULL) {
431			fprintf(stderr, "out of memory\n");
432			exit(1);
433			}
434
435	dpavlin	22	/* Make space for the new entry: */
436	dpavlin	32	if (newi + 1 != mem->n_mmapped_devices)
437			memmove(&mem->devices[newi+1], &mem->devices[newi],
438			sizeof(struct memory_device)
439			* (mem->n_mmapped_devices - newi - 1));
440	dpavlin	22
441	dpavlin	32	mem->devices[newi].name = strdup(device_name);
442			mem->devices[newi].baseaddr = baseaddr;
443			mem->devices[newi].endaddr = baseaddr + len;
444			mem->devices[newi].length = len;
445			mem->devices[newi].flags = flags;
446			mem->devices[newi].dyntrans_data = dyntrans_data;
447	dpavlin	22
448	dpavlin	32	if (mem->devices[newi].name == NULL) {
449	dpavlin	2	fprintf(stderr, "out of memory\n");
450			exit(1);
451			}
452
453	dpavlin	20	if (flags & (DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK)
454			&& !(flags & DM_EMULATED_RAM) && dyntrans_data == NULL) {
455	dpavlin	12	fatal("\nERROR: Device dyntrans access, but dyntrans_data"
456			" = NULL!\n");
457			exit(1);
458			}
459
460	dpavlin	18	if ((size_t)dyntrans_data & (sizeof(void *) - 1)) {
461	dpavlin	2	fprintf(stderr, "memory_device_register():"
462	dpavlin	12	" dyntrans_data not aligned correctly (%p)\n",
463			dyntrans_data);
464	dpavlin	2	exit(1);
465			}
466
467	dpavlin	32	mem->devices[newi].dyntrans_write_low = (uint64_t)-1;
468			mem->devices[newi].dyntrans_write_high = 0;
469			mem->devices[newi].f = f;
470			mem->devices[newi].extra = extra;
471	dpavlin	2
472			if (baseaddr < mem->mmap_dev_minaddr)
473	dpavlin	12	mem->mmap_dev_minaddr = baseaddr & ~mem->dev_dyntrans_alignment;
474	dpavlin	2	if (baseaddr + len > mem->mmap_dev_maxaddr)
475	dpavlin	12	mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) \|
476			mem->dev_dyntrans_alignment) + 1;
477	dpavlin	32
478			if (newi < mem->last_accessed_device)
479			mem->last_accessed_device ++;
480	dpavlin	2	}
481
482
483			/*
484			* memory_device_remove():
485			*
486	dpavlin	32	* Unregister a memory mapped device from a memory object.
487	dpavlin	2	*/
488			void memory_device_remove(struct memory *mem, int i)
489			{
490			if (i < 0 \|\| i >= mem->n_mmapped_devices) {
491			fatal("memory_device_remove(): invalid device number %i\n", i);
492	dpavlin	32	exit(1);
493	dpavlin	2	}
494
495			mem->n_mmapped_devices --;
496
497			if (i == mem->n_mmapped_devices)
498			return;
499
500	dpavlin	32	memmove(&mem->devices[i], &mem->devices[i+1],
501			sizeof(struct memory_device) * (mem->n_mmapped_devices - i));
502	dpavlin	2
503	dpavlin	32	if (i <= mem->last_accessed_device)
504			mem->last_accessed_device --;
505			if (mem->last_accessed_device < 0)
506			mem->last_accessed_device = 0;
507	dpavlin	2	}
508
509
510			#define MEMORY_RW userland_memory_rw
511			#define MEM_USERLAND
512			#include "memory_rw.c"
513			#undef MEM_USERLAND
514			#undef MEMORY_RW
515
516
517			/*
518			* memory_paddr_to_hostaddr():
519			*
520	dpavlin	28	* Translate a physical address into a host address. The usual way to call
521			* this function is to make sure that paddr is page aligned, which will result
522			* in the host _page_ corresponding to that address.
523	dpavlin	2	*
524	dpavlin	28	* Return value is a pointer to the address in the host, or NULL on failure.
525	dpavlin	2	* On reads, a NULL return value should be interpreted as reading all zeroes.
526			*/
527			unsigned char memory_paddr_to_hostaddr(struct memory mem,
528			uint64_t paddr, int writeflag)
529			{
530			void **table;
531			int entry;
532			const int mask = (1 << BITS_PER_PAGETABLE) - 1;
533			const int shrcount = MAX_BITS - BITS_PER_PAGETABLE;
534	dpavlin	28	unsigned char *hostptr;
535	dpavlin	2
536			table = mem->pagetable;
537			entry = (paddr >> shrcount) & mask;
538
539	dpavlin	24	/* printf("memory_paddr_to_hostaddr(): p=%16"PRIx64
540			" w=%i => entry=0x%x\n", (uint64_t) paddr, writeflag, entry); */
541	dpavlin	2
542			if (table[entry] == NULL) {
543			size_t alloclen;
544
545			/*
546			* Special case: reading from a nonexistant memblock
547			* returns all zeroes, and doesn't allocate anything.
548			* (If any intermediate pagetable is nonexistant, then
549			* the same thing happens):
550			*/
551			if (writeflag == MEM_READ)
552			return NULL;
553
554			/* Allocate a memblock: */
555			alloclen = 1 << BITS_PER_MEMBLOCK;
556
557			/* printf(" allocating for entry %i, len=%i\n",
558			entry, alloclen); */
559
560			/* Anonymous mmap() should return zero-filled memory,
561			try malloc + memset if mmap failed. */
562			table[entry] = (void *) mmap(NULL, alloclen,
563	dpavlin	22	PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE, -1, 0);
564	dpavlin	2	if (table[entry] == NULL) {
565			table[entry] = malloc(alloclen);
566			if (table[entry] == NULL) {
567			fatal("out of memory\n");
568			exit(1);
569			}
570			memset(table[entry], 0, alloclen);
571			}
572			}
573
574	dpavlin	28	hostptr = (unsigned char *) table[entry];
575
576			if (hostptr != NULL)
577			hostptr += (paddr & ((1 << BITS_PER_MEMBLOCK) - 1));
578
579			return hostptr;
580	dpavlin	2	}
581
582	dpavlin	24
583			#define UPDATE_CHECKSUM(value) { \
584			internal_state -= 0x118c7771c0c0a77fULL; \
585			internal_state = ((internal_state + (value)) << 7) ^ \
586			(checksum >> 11) ^ ((checksum - (value)) << 3) ^ \
587			(internal_state - checksum) ^ ((value) - internal_state); \
588			checksum ^= internal_state; \
589			}
590
591
592			/*
593			* memory_checksum():
594			*
595			* Calculate a 64-bit checksum of everything in a struct memory. This is
596			* useful for tracking down bugs; an old (presumably working) version of
597			* the emulator can be compared to a newer (buggy) version.
598			*/
599			uint64_t memory_checksum(struct memory *mem)
600			{
601			uint64_t internal_state = 0x80624185376feff2ULL;
602			uint64_t checksum = 0xcb9a87d5c010072cULL;
603			const int n_entries = (1 << BITS_PER_PAGETABLE) - 1;
604			const size_t len = (1 << BITS_PER_MEMBLOCK) / sizeof(uint64_t);
605			size_t entry, i;
606
607			for (entry=0; entry<=n_entries; entry++) {
608			uint64_t **table = mem->pagetable;
609			uint64_t *memblock = table[entry];
610
611			if (memblock == NULL) {
612			UPDATE_CHECKSUM(0x1198ab7c8174a76fULL);
613			continue;
614			}
615
616			for (i=0; i<len; i++)
617			UPDATE_CHECKSUM(memblock[i]);
618			}
619
620			return checksum;
621			}
622