trunk/src/memory.c

/*
 *  Copyright (C) 2003-2005  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.180 2005/10/25 15:51:02 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 "bintrans.h"
#include "cop0.h"
#include "cpu.h"
#include "machine.h"
#include "memory.h"
#include "mips_cpu_types.h"
#include "misc.h"


extern int quiet_mode;
extern volatile int single_step;


/*
 *  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;
        uint64_t x = 0;

        /*  Switch byte order for incoming data, if necessary:  */
        if (cpu->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;

        if (cpu->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) {
                p = malloc(s);
                if (p == NULL) {
                        fprintf(stderr, "out of memory\n");
                        exit(1);
                }
                memset(p, 0, s);
        }
        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 at 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 virtual 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 (or bintrans) access since last time.
 */
void memory_device_dyntrans_access(struct cpu *cpu, struct memory *mem,
        void *extra, uint64_t *low, uint64_t *high)
{
        int i, j;
        size_t s;
        int 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->dev_extra[i] == extra &&
                    mem->dev_dyntrans_data[i] != NULL) {
                        if (mem->dev_dyntrans_write_low[i] != (uint64_t) -1)
                                need_inval = 1;
                        if (low != NULL)
                                *low = mem->dev_dyntrans_write_low[i];
                        mem->dev_dyntrans_write_low[i] = (uint64_t) -1;

                        if (high != NULL)
                                *high = mem->dev_dyntrans_write_high[i];
                        mem->dev_dyntrans_write_high[i] = 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=0; s<mem->dev_length[i];
                                    s+=cpu->machine->arch_pagesize)
                                        cpu->invalidate_translation_caches
                                            (cpu, mem->dev_baseaddr[i] + s,
                                            JUST_MARK_AS_NON_WRITABLE
                                            | INVALIDATE_PADDR);
                        }

                        if (cpu->machine->arch == ARCH_MIPS) {
                                /*
                                 *  ... and invalidate the "fast_vaddr_to_
                                 *  hostaddr" cache entries that contain
                                 *  pointers to this device:  (NOTE: Device i,
                                 *  cache entry j)
                                 */
                                for (j=0; j<N_BINTRANS_VADDR_TO_HOST; j++) {
                                        if (cpu->cd.
                                            mips.bintrans_data_hostpage[j] >=
                                            mem->dev_dyntrans_data[i] &&
                                            cpu->cd.mips.
                                            bintrans_data_hostpage[j] <
                                            mem->dev_dyntrans_data[i] +
                                            mem->dev_length[i])
                                                cpu->cd.mips.
                                                    bintrans_data_hostpage[j]
                                                    = NULL;
                                }
                        }
                        return;
                }
        }
}


/*
 *  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);
}


/*
 *  memory_device_register():
 *
 *  Register a (memory mapped) device by adding it to the dev_* fields of a
 *  memory struct.
 */
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;

        if (mem->n_mmapped_devices >= MAX_DEVICES) {
                fprintf(stderr, "memory_device_register(): too many "
                    "devices registered, cannot register '%s'\n", device_name);
                exit(1);
        }

        /*  Check for collisions:  */
        for (i=0; i<mem->n_mmapped_devices; i++) {
                /*  If we are not colliding with device i, then continue:  */
                if (baseaddr + len <= mem->dev_baseaddr[i])
                        continue;
                if (baseaddr >= mem->dev_baseaddr[i] + mem->dev_length[i])
                        continue;

                fatal("\nWARNING! \"%s\" collides with device %i (\"%s\")!\n"
                    "         Run-time behaviour will be undefined!\n\n",
                    device_name, i, mem->dev_name[i]);
        }

        /*  (40 bits of physical address is displayed)  */
        debug("device %2i at 0x%010llx: %s",
            mem->n_mmapped_devices, (long long)baseaddr, device_name);

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

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

        mem->dev_name[mem->n_mmapped_devices] = strdup(device_name);
        mem->dev_baseaddr[mem->n_mmapped_devices] = baseaddr;
        mem->dev_endaddr[mem->n_mmapped_devices] = baseaddr + len;
        mem->dev_length[mem->n_mmapped_devices] = len;
        mem->dev_flags[mem->n_mmapped_devices] = flags;
        mem->dev_dyntrans_data[mem->n_mmapped_devices] = dyntrans_data;

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

        if (flags & (MEM_DYNTRANS_OK | MEM_DYNTRANS_WRITE_OK)
            && !(flags & MEM_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->dev_dyntrans_write_low[mem->n_mmapped_devices] = (uint64_t)-1;
        mem->dev_dyntrans_write_high[mem->n_mmapped_devices] = 0;
        mem->dev_f[mem->n_mmapped_devices] = f;
        mem->dev_extra[mem->n_mmapped_devices] = extra;
        mem->n_mmapped_devices++;

        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;
}


/*
 *  memory_device_remove():
 *
 *  Unregister a (memory mapped) device from a memory struct.
 */
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);
                return;
        }

        mem->n_mmapped_devices --;

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

        /*
         *  YUCK! This is ugly. TODO: fix
         */

        memmove(&mem->dev_name[i], &mem->dev_name[i+1], sizeof(char *) *
            (MAX_DEVICES - i - 1));
        memmove(&mem->dev_baseaddr[i], &mem->dev_baseaddr[i+1],
            sizeof(uint64_t) * (MAX_DEVICES - i - 1));
        memmove(&mem->dev_length[i], &mem->dev_length[i+1], sizeof(uint64_t) *
            (MAX_DEVICES - i - 1));
        memmove(&mem->dev_flags[i], &mem->dev_flags[i+1], sizeof(int) *
            (MAX_DEVICES - i - 1));
        memmove(&mem->dev_extra[i], &mem->dev_extra[i+1], sizeof(void *) *
            (MAX_DEVICES - i - 1));
        memmove(&mem->dev_f[i], &mem->dev_f[i+1], sizeof(void *) *
            (MAX_DEVICES - i - 1));
        memmove(&mem->dev_f_state[i], &mem->dev_f_state[i+1], sizeof(void *) *
            (MAX_DEVICES - i - 1));
        memmove(&mem->dev_dyntrans_data[i], &mem->dev_dyntrans_data[i+1],
            sizeof(void *) * (MAX_DEVICES - i - 1));
        memmove(&mem->dev_dyntrans_write_low[i], &mem->dev_dyntrans_write_low
            [i+1], sizeof(void *) * (MAX_DEVICES - i - 1));
        memmove(&mem->dev_dyntrans_write_high[i], &mem->dev_dyntrans_write_high
            [i+1], sizeof(void *) * (MAX_DEVICES - i - 1));
}


#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.
 *
 *  Return value is a pointer to a host memblock, 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;

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

        /*  printf("memory_paddr_to_hostaddr(): p=%16llx w=%i => entry=0x%x\n",
            (long long)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);
                }
        }

        return (unsigned char *) table[entry];
}

1	/*
2	* Copyright (C) 2003-2005 Anders Gavare. All rights reserved.
3	*
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	* $Id: memory.c,v 1.180 2005/10/25 15:51:02 debug Exp $
29	*
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 "bintrans.h"
40	#include "cop0.h"
41	#include "cpu.h"
42	#include "machine.h"
43	#include "memory.h"
44	#include "mips_cpu_types.h"
45	#include "misc.h"
46
47
48	extern int quiet_mode;
49	extern volatile int single_step;
50
51
52	/*
53	* memory_readmax64():
54	*
55	* Read at most 64 bits of data from a buffer. Length is given by
56	* len, and the byte order by cpu->byte_order.
57	*
58	* This function should not be called with cpu == NULL.
59	*/
60	uint64_t memory_readmax64(struct cpu cpu, unsigned char buf, int len)
61	{
62	int i;
63	uint64_t x = 0;
64
65	/* Switch byte order for incoming data, if necessary: */
66	if (cpu->byte_order == EMUL_BIG_ENDIAN)
67	for (i=0; i<len; i++) {
68	x <<= 8;
69	x \|= buf[i];
70	}
71	else
72	for (i=len-1; i>=0; i--) {
73	x <<= 8;
74	x \|= buf[i];
75	}
76
77	return x;
78	}
79
80
81	/*
82	* memory_writemax64():
83	*
84	* Write at most 64 bits of data to a buffer. Length is given by
85	* len, and the byte order by cpu->byte_order.
86	*
87	* This function should not be called with cpu == NULL.
88	*/
89	void memory_writemax64(struct cpu cpu, unsigned char buf, int len,
90	uint64_t data)
91	{
92	int i;
93
94	if (cpu->byte_order == EMUL_LITTLE_ENDIAN)
95	for (i=0; i<len; i++) {
96	buf[i] = data & 255;
97	data >>= 8;
98	}
99	else
100	for (i=0; i<len; i++) {
101	buf[len - 1 - i] = data & 255;
102	data >>= 8;
103	}
104	}
105
106
107	/*
108	* zeroed_alloc():
109	*
110	* Allocates a block of memory using mmap(), and if that fails, try
111	* malloc() + memset(). The returned memory block contains only zeroes.
112	*/
113	void *zeroed_alloc(size_t s)
114	{
115	void *p = mmap(NULL, s, PROT_READ \| PROT_WRITE,
116	MAP_ANON \| MAP_PRIVATE, -1, 0);
117	if (p == NULL) {
118	p = malloc(s);
119	if (p == NULL) {
120	fprintf(stderr, "out of memory\n");
121	exit(1);
122	}
123	memset(p, 0, s);
124	}
125	return p;
126	}
127
128
129	/*
130	* memory_new():
131	*
132	* This function creates a new memory object. An emulated machine needs one
133	* of these.
134	*/
135	struct memory *memory_new(uint64_t physical_max, int arch)
136	{
137	struct memory *mem;
138	int bits_per_pagetable = BITS_PER_PAGETABLE;
139	int bits_per_memblock = BITS_PER_MEMBLOCK;
140	int entries_per_pagetable = 1 << BITS_PER_PAGETABLE;
141	int max_bits = MAX_BITS;
142	size_t s;
143
144	mem = malloc(sizeof(struct memory));
145	if (mem == NULL) {
146	fprintf(stderr, "out of memory\n");
147	exit(1);
148	}
149
150	memset(mem, 0, sizeof(struct memory));
151
152	/* Check bits_per_pagetable and bits_per_memblock for sanity: */
153	if (bits_per_pagetable + bits_per_memblock != max_bits) {
154	fprintf(stderr, "memory_new(): bits_per_pagetable and "
155	"bits_per_memblock mismatch\n");
156	exit(1);
157	}
158
159	mem->physical_max = physical_max;
160	mem->dev_dyntrans_alignment = 4095;
161	if (arch == ARCH_ALPHA)
162	mem->dev_dyntrans_alignment = 8191;
163
164	s = entries_per_pagetable * sizeof(void *);
165
166	mem->pagetable = (unsigned char *) mmap(NULL, s,
167	PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE, -1, 0);
168	if (mem->pagetable == NULL) {
169	mem->pagetable = malloc(s);
170	if (mem->pagetable == NULL) {
171	fprintf(stderr, "out of memory\n");
172	exit(1);
173	}
174	memset(mem->pagetable, 0, s);
175	}
176
177	mem->mmap_dev_minaddr = 0xffffffffffffffffULL;
178	mem->mmap_dev_maxaddr = 0;
179
180	return mem;
181	}
182
183
184	/*
185	* memory_points_to_string():
186	*
187	* Returns 1 if there's something string-like at addr, otherwise 0.
188	*/
189	int memory_points_to_string(struct cpu cpu, struct memory mem, uint64_t addr,
190	int min_string_length)
191	{
192	int cur_length = 0;
193	unsigned char c;
194
195	for (;;) {
196	c = '\0';
197	cpu->memory_rw(cpu, mem, addr+cur_length,
198	&c, sizeof(c), MEM_READ, CACHE_NONE \| NO_EXCEPTIONS);
199	if (c=='\n' \|\| c=='\t' \|\| c=='\r' \|\| (c>=' ' && c<127)) {
200	cur_length ++;
201	if (cur_length >= min_string_length)
202	return 1;
203	} else {
204	if (cur_length >= min_string_length)
205	return 1;
206	else
207	return 0;
208	}
209	}
210	}
211
212
213	/*
214	* memory_conv_to_string():
215	*
216	* Convert virtual memory contents to a string, placing it in a
217	* buffer provided by the caller.
218	*/
219	char memory_conv_to_string(struct cpu cpu, struct memory *mem, uint64_t addr,
220	char *buf, int bufsize)
221	{
222	int len = 0;
223	int output_index = 0;
224	unsigned char c, p='\0';
225
226	while (output_index < bufsize-1) {
227	c = '\0';
228	cpu->memory_rw(cpu, mem, addr+len, &c, sizeof(c), MEM_READ,
229	CACHE_NONE \| NO_EXCEPTIONS);
230	buf[output_index] = c;
231	if (c>=' ' && c<127) {
232	len ++;
233	output_index ++;
234	} else if (c=='\n' \|\| c=='\r' \|\| c=='\t') {
235	len ++;
236	buf[output_index] = '\\';
237	output_index ++;
238	switch (c) {
239	case '\n': p = 'n'; break;
240	case '\r': p = 'r'; break;
241	case '\t': p = 't'; break;
242	}
243	if (output_index < bufsize-1) {
244	buf[output_index] = p;
245	output_index ++;
246	}
247	} else {
248	buf[output_index] = '\0';
249	return buf;
250	}
251	}
252
253	buf[bufsize-1] = '\0';
254	return buf;
255	}
256
257
258	/*
259	* memory_device_dyntrans_access():
260	*
261	* Get the lowest and highest dyntrans (or bintrans) access since last time.
262	*/
263	void memory_device_dyntrans_access(struct cpu cpu, struct memory mem,
264	void extra, uint64_t low, uint64_t *high)
265	{
266	int i, j;
267	size_t s;
268	int need_inval = 0;
269
270	/* TODO: This is O(n), so it might be good to rewrite it some day.
271	For now, it will be enough, as long as this function is not
272	called too often. */
273
274	for (i=0; i<mem->n_mmapped_devices; i++) {
275	if (mem->dev_extra[i] == extra &&
276	mem->dev_dyntrans_data[i] != NULL) {
277	if (mem->dev_dyntrans_write_low[i] != (uint64_t) -1)
278	need_inval = 1;
279	if (low != NULL)
280	*low = mem->dev_dyntrans_write_low[i];
281	mem->dev_dyntrans_write_low[i] = (uint64_t) -1;
282
283	if (high != NULL)
284	*high = mem->dev_dyntrans_write_high[i];
285	mem->dev_dyntrans_write_high[i] = 0;
286
287	if (!need_inval)
288	return;
289
290	/* Invalidate any pages of this device that might
291	be in the dyntrans load/store cache, by marking
292	the pages read-only. */
293	if (cpu->invalidate_translation_caches != NULL) {
294	for (s=0; s<mem->dev_length[i];
295	s+=cpu->machine->arch_pagesize)
296	cpu->invalidate_translation_caches
297	(cpu, mem->dev_baseaddr[i] + s,
298	JUST_MARK_AS_NON_WRITABLE
299	\| INVALIDATE_PADDR);
300	}
301
302	if (cpu->machine->arch == ARCH_MIPS) {
303	/*
304	* ... and invalidate the "fast_vaddr_to_
305	* hostaddr" cache entries that contain
306	* pointers to this device: (NOTE: Device i,
307	* cache entry j)
308	*/
309	for (j=0; j<N_BINTRANS_VADDR_TO_HOST; j++) {
310	if (cpu->cd.
311	mips.bintrans_data_hostpage[j] >=
312	mem->dev_dyntrans_data[i] &&
313	cpu->cd.mips.
314	bintrans_data_hostpage[j] <
315	mem->dev_dyntrans_data[i] +
316	mem->dev_length[i])
317	cpu->cd.mips.
318	bintrans_data_hostpage[j]
319	= NULL;
320	}
321	}
322	return;
323	}
324	}
325	}
326
327
328	/*
329	* memory_device_register_statefunction():
330	*
331	* TODO: Hm. This is semi-ugly. Should probably be rewritten/redesigned
332	* some day.
333	*/
334	void memory_device_register_statefunction(
335	struct memory mem, void extra,
336	int (dev_f_state)(struct cpu ,
337	struct memory , void extra, int wf, int nr,
338	int type, char namep, void data, size_t len))
339	{
340	int i;
341
342	for (i=0; i<mem->n_mmapped_devices; i++)
343	if (mem->dev_extra[i] == extra) {
344	mem->dev_f_state[i] = dev_f_state;
345	return;
346	}
347
348	printf("memory_device_register_statefunction(): "
349	"couldn't find the device\n");
350	exit(1);
351	}
352
353
354	/*
355	* memory_device_register():
356	*
357	* Register a (memory mapped) device by adding it to the dev_* fields of a
358	* memory struct.
359	*/
360	void memory_device_register(struct memory mem, const char device_name,
361	uint64_t baseaddr, uint64_t len,
362	int (f)(struct cpu ,struct memory ,uint64_t,unsigned char ,
363	size_t,int,void *),
364	void extra, int flags, unsigned char dyntrans_data)
365	{
366	int i;
367
368	if (mem->n_mmapped_devices >= MAX_DEVICES) {
369	fprintf(stderr, "memory_device_register(): too many "
370	"devices registered, cannot register '%s'\n", device_name);
371	exit(1);
372	}
373
374	/* Check for collisions: */
375	for (i=0; i<mem->n_mmapped_devices; i++) {
376	/* If we are not colliding with device i, then continue: */
377	if (baseaddr + len <= mem->dev_baseaddr[i])
378	continue;
379	if (baseaddr >= mem->dev_baseaddr[i] + mem->dev_length[i])
380	continue;
381
382	fatal("\nWARNING! \"%s\" collides with device %i (\"%s\")!\n"
383	" Run-time behaviour will be undefined!\n\n",
384	device_name, i, mem->dev_name[i]);
385	}
386
387	/* (40 bits of physical address is displayed) */
388	debug("device %2i at 0x%010llx: %s",
389	mem->n_mmapped_devices, (long long)baseaddr, device_name);
390
391	if (flags & (MEM_DYNTRANS_OK \| MEM_DYNTRANS_WRITE_OK)
392	&& (baseaddr & mem->dev_dyntrans_alignment) != 0) {
393	fatal("\nWARNING: Device dyntrans access, but unaligned"
394	" baseaddr 0x%llx.\n", (long long)baseaddr);
395	}
396
397	if (flags & (MEM_DYNTRANS_OK \| MEM_DYNTRANS_WRITE_OK)) {
398	debug(" (dyntrans %s)",
399	(flags & MEM_DYNTRANS_WRITE_OK)? "R/W" : "R");
400	}
401	debug("\n");
402
403	mem->dev_name[mem->n_mmapped_devices] = strdup(device_name);
404	mem->dev_baseaddr[mem->n_mmapped_devices] = baseaddr;
405	mem->dev_endaddr[mem->n_mmapped_devices] = baseaddr + len;
406	mem->dev_length[mem->n_mmapped_devices] = len;
407	mem->dev_flags[mem->n_mmapped_devices] = flags;
408	mem->dev_dyntrans_data[mem->n_mmapped_devices] = dyntrans_data;
409
410	if (mem->dev_name[mem->n_mmapped_devices] == NULL) {
411	fprintf(stderr, "out of memory\n");
412	exit(1);
413	}
414
415	if (flags & (MEM_DYNTRANS_OK \| MEM_DYNTRANS_WRITE_OK)
416	&& !(flags & MEM_EMULATED_RAM) && dyntrans_data == NULL) {
417	fatal("\nERROR: Device dyntrans access, but dyntrans_data"
418	" = NULL!\n");
419	exit(1);
420	}
421
422	if ((size_t)dyntrans_data & (sizeof(void *) - 1)) {
423	fprintf(stderr, "memory_device_register():"
424	" dyntrans_data not aligned correctly (%p)\n",
425	dyntrans_data);
426	exit(1);
427	}
428
429	mem->dev_dyntrans_write_low[mem->n_mmapped_devices] = (uint64_t)-1;
430	mem->dev_dyntrans_write_high[mem->n_mmapped_devices] = 0;
431	mem->dev_f[mem->n_mmapped_devices] = f;
432	mem->dev_extra[mem->n_mmapped_devices] = extra;
433	mem->n_mmapped_devices++;
434
435	if (baseaddr < mem->mmap_dev_minaddr)
436	mem->mmap_dev_minaddr = baseaddr & ~mem->dev_dyntrans_alignment;
437	if (baseaddr + len > mem->mmap_dev_maxaddr)
438	mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) \|
439	mem->dev_dyntrans_alignment) + 1;
440	}
441
442
443	/*
444	* memory_device_remove():
445	*
446	* Unregister a (memory mapped) device from a memory struct.
447	*/
448	void memory_device_remove(struct memory *mem, int i)
449	{
450	if (i < 0 \|\| i >= mem->n_mmapped_devices) {
451	fatal("memory_device_remove(): invalid device number %i\n", i);
452	return;
453	}
454
455	mem->n_mmapped_devices --;
456
457	if (i == mem->n_mmapped_devices)
458	return;
459
460	/*
461	* YUCK! This is ugly. TODO: fix
462	*/
463
464	memmove(&mem->dev_name[i], &mem->dev_name[i+1], sizeof(char )
465	(MAX_DEVICES - i - 1));
466	memmove(&mem->dev_baseaddr[i], &mem->dev_baseaddr[i+1],
467	sizeof(uint64_t) * (MAX_DEVICES - i - 1));
468	memmove(&mem->dev_length[i], &mem->dev_length[i+1], sizeof(uint64_t) *
469	(MAX_DEVICES - i - 1));
470	memmove(&mem->dev_flags[i], &mem->dev_flags[i+1], sizeof(int) *
471	(MAX_DEVICES - i - 1));
472	memmove(&mem->dev_extra[i], &mem->dev_extra[i+1], sizeof(void )
473	(MAX_DEVICES - i - 1));
474	memmove(&mem->dev_f[i], &mem->dev_f[i+1], sizeof(void )
475	(MAX_DEVICES - i - 1));
476	memmove(&mem->dev_f_state[i], &mem->dev_f_state[i+1], sizeof(void )
477	(MAX_DEVICES - i - 1));
478	memmove(&mem->dev_dyntrans_data[i], &mem->dev_dyntrans_data[i+1],
479	sizeof(void ) (MAX_DEVICES - i - 1));
480	memmove(&mem->dev_dyntrans_write_low[i], &mem->dev_dyntrans_write_low
481	[i+1], sizeof(void ) (MAX_DEVICES - i - 1));
482	memmove(&mem->dev_dyntrans_write_high[i], &mem->dev_dyntrans_write_high
483	[i+1], sizeof(void ) (MAX_DEVICES - i - 1));
484	}
485
486
487	#define MEMORY_RW userland_memory_rw
488	#define MEM_USERLAND
489	#include "memory_rw.c"
490	#undef MEM_USERLAND
491	#undef MEMORY_RW
492
493
494	/*
495	* memory_paddr_to_hostaddr():
496	*
497	* Translate a physical address into a host address.
498	*
499	* Return value is a pointer to a host memblock, or NULL on failure.
500	* On reads, a NULL return value should be interpreted as reading all zeroes.
501	*/
502	unsigned char memory_paddr_to_hostaddr(struct memory mem,
503	uint64_t paddr, int writeflag)
504	{
505	void **table;
506	int entry;
507	const int mask = (1 << BITS_PER_PAGETABLE) - 1;
508	const int shrcount = MAX_BITS - BITS_PER_PAGETABLE;
509
510	table = mem->pagetable;
511	entry = (paddr >> shrcount) & mask;
512
513	/* printf("memory_paddr_to_hostaddr(): p=%16llx w=%i => entry=0x%x\n",
514	(long long)paddr, writeflag, entry); */
515
516	if (table[entry] == NULL) {
517	size_t alloclen;
518
519	/*
520	* Special case: reading from a nonexistant memblock
521	* returns all zeroes, and doesn't allocate anything.
522	* (If any intermediate pagetable is nonexistant, then
523	* the same thing happens):
524	*/
525	if (writeflag == MEM_READ)
526	return NULL;
527
528	/* Allocate a memblock: */
529	alloclen = 1 << BITS_PER_MEMBLOCK;
530
531	/* printf(" allocating for entry %i, len=%i\n",
532	entry, alloclen); */
533
534	/* Anonymous mmap() should return zero-filled memory,
535	try malloc + memset if mmap failed. */
536	table[entry] = (void *) mmap(NULL, alloclen,
537	PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE,
538	-1, 0);
539	if (table[entry] == NULL) {
540	table[entry] = malloc(alloclen);
541	if (table[entry] == NULL) {
542	fatal("out of memory\n");
543	exit(1);
544	}
545	memset(table[entry], 0, alloclen);
546	}
547	}
548
549	return (unsigned char *) table[entry];
550	}
551