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.164 2005/04/09 21:10:54 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().
 */
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)
{
        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;

        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_bintrans_access():
 *
 *  Get the lowest and highest bintrans access since last time.
 */
void memory_device_bintrans_access(struct cpu *cpu, struct memory *mem,
        void *extra, uint64_t *low, uint64_t *high)
{
#ifdef BINTRANS
        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_bintrans_data[i] != NULL) {
                        if (mem->dev_bintrans_write_low[i] != (uint64_t) -1)
                                need_inval = 1;
                        if (low != NULL)
                                *low = mem->dev_bintrans_write_low[i];
                        mem->dev_bintrans_write_low[i] = (uint64_t) -1;

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

                        if (!need_inval)
                                return;

                        if (cpu->machine->arch != ARCH_MIPS) {
                                /*  TODO!  */

                                return;
                        }

                        /*  Invalidate any pages of this device that might
                            be in the bintrans load/store cache, by marking
                            the pages read-only.  */

                        for (s=0; s<mem->dev_length[i]; s+=4096) {
                                mips_invalidate_translation_caches_paddr(
                                    cpu, mem->dev_baseaddr[i] + s);
                        }

                        /*  ... 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_bintrans_data[i] &&
                                    cpu->cd.mips.bintrans_data_hostpage[j] <
                                    mem->dev_bintrans_data[i] +
                                    mem->dev_length[i])
                                        cpu->cd.mips.
                                            bintrans_data_hostpage[j] = NULL;
                        }

                        return;
                }
        }
#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);
}


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

#ifdef BINTRANS
        if (flags & (MEM_BINTRANS_OK | MEM_BINTRANS_WRITE_OK)
            && (baseaddr & 0xfff) != 0) {
                fatal("\nWARNING: Device bintrans access, but unaligned"
                    " baseaddr 0x%llx.\n", (long long)baseaddr);
        }

        if (flags & (MEM_BINTRANS_OK | MEM_BINTRANS_WRITE_OK)) {
                debug(" (bintrans %s)",
                    (flags & MEM_BINTRANS_WRITE_OK)? "R/W" : "R");
        }
#endif
        debug("\n");

        mem->dev_name[mem->n_mmapped_devices] = strdup(device_name);
        mem->dev_baseaddr[mem->n_mmapped_devices] = baseaddr;
        mem->dev_length[mem->n_mmapped_devices] = len;
        mem->dev_flags[mem->n_mmapped_devices] = flags;
        mem->dev_bintrans_data[mem->n_mmapped_devices] = bintrans_data;

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

        if ((size_t)bintrans_data & 1) {
                fprintf(stderr, "memory_device_register():"
                    " bintrans_data not aligned correctly\n");
                exit(1);
        }

#ifdef BINTRANS
        mem->dev_bintrans_write_low[mem->n_mmapped_devices] = (uint64_t)-1;
        mem->dev_bintrans_write_high[mem->n_mmapped_devices] = 0;
#endif
        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 & ~0xfff;
        if (baseaddr + len > mem->mmap_dev_maxaddr)
                mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) | 0xfff) + 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_bintrans_data[i], &mem->dev_bintrans_data[i+1],
            sizeof(void *) * (MAX_DEVICES - i - 1));
#ifdef BINTRANS
        memmove(&mem->dev_bintrans_write_low[i], &mem->dev_bintrans_write_low
            [i+1], sizeof(void *) * (MAX_DEVICES - i - 1));
        memmove(&mem->dev_bintrans_write_high[i], &mem->dev_bintrans_write_high
            [i+1], sizeof(void *) * (MAX_DEVICES - i - 1));
#endif
}


#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("   entry = %x\n", 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	dpavlin	2	/*
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	dpavlin	4	* $Id: memory.c,v 1.164 2005/04/09 21:10:54 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 "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().
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)
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
161			s = entries_per_pagetable * sizeof(void *);
162
163			mem->pagetable = (unsigned char *) mmap(NULL, s,
164			PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE, -1, 0);
165			if (mem->pagetable == NULL) {
166			mem->pagetable = malloc(s);
167			if (mem->pagetable == NULL) {
168			fprintf(stderr, "out of memory\n");
169			exit(1);
170			}
171			memset(mem->pagetable, 0, s);
172			}
173
174			mem->mmap_dev_minaddr = 0xffffffffffffffffULL;
175			mem->mmap_dev_maxaddr = 0;
176
177			return mem;
178			}
179
180
181			/*
182			* memory_points_to_string():
183			*
184			* Returns 1 if there's something string-like at addr, otherwise 0.
185			*/
186			int memory_points_to_string(struct cpu cpu, struct memory mem, uint64_t addr,
187			int min_string_length)
188			{
189			int cur_length = 0;
190			unsigned char c;
191
192			for (;;) {
193			c = '\0';
194			cpu->memory_rw(cpu, mem, addr+cur_length,
195			&c, sizeof(c), MEM_READ, CACHE_NONE \| NO_EXCEPTIONS);
196			if (c=='\n' \|\| c=='\t' \|\| c=='\r' \|\| (c>=' ' && c<127)) {
197			cur_length ++;
198			if (cur_length >= min_string_length)
199			return 1;
200			} else {
201			if (cur_length >= min_string_length)
202			return 1;
203			else
204			return 0;
205			}
206			}
207			}
208
209
210			/*
211			* memory_conv_to_string():
212			*
213			* Convert virtual memory contents to a string, placing it in a
214			* buffer provided by the caller.
215			*/
216			char memory_conv_to_string(struct cpu cpu, struct memory *mem, uint64_t addr,
217			char *buf, int bufsize)
218			{
219			int len = 0;
220			int output_index = 0;
221			unsigned char c, p='\0';
222
223			while (output_index < bufsize-1) {
224			c = '\0';
225			cpu->memory_rw(cpu, mem, addr+len, &c, sizeof(c), MEM_READ,
226			CACHE_NONE \| NO_EXCEPTIONS);
227			buf[output_index] = c;
228			if (c>=' ' && c<127) {
229			len ++;
230			output_index ++;
231			} else if (c=='\n' \|\| c=='\r' \|\| c=='\t') {
232			len ++;
233			buf[output_index] = '\\';
234			output_index ++;
235			switch (c) {
236			case '\n': p = 'n'; break;
237			case '\r': p = 'r'; break;
238			case '\t': p = 't'; break;
239			}
240			if (output_index < bufsize-1) {
241			buf[output_index] = p;
242			output_index ++;
243			}
244			} else {
245			buf[output_index] = '\0';
246			return buf;
247			}
248			}
249
250			buf[bufsize-1] = '\0';
251			return buf;
252			}
253
254
255			/*
256			* memory_device_bintrans_access():
257			*
258			* Get the lowest and highest bintrans access since last time.
259			*/
260			void memory_device_bintrans_access(struct cpu cpu, struct memory mem,
261			void extra, uint64_t low, uint64_t *high)
262			{
263			#ifdef BINTRANS
264			int i, j;
265			size_t s;
266			int need_inval = 0;
267
268			/* TODO: This is O(n), so it might be good to rewrite it some day.
269			For now, it will be enough, as long as this function is not
270			called too often. */
271
272			for (i=0; i<mem->n_mmapped_devices; i++) {
273			if (mem->dev_extra[i] == extra &&
274			mem->dev_bintrans_data[i] != NULL) {
275			if (mem->dev_bintrans_write_low[i] != (uint64_t) -1)
276			need_inval = 1;
277			if (low != NULL)
278			*low = mem->dev_bintrans_write_low[i];
279			mem->dev_bintrans_write_low[i] = (uint64_t) -1;
280
281			if (high != NULL)
282			*high = mem->dev_bintrans_write_high[i];
283			mem->dev_bintrans_write_high[i] = 0;
284
285			if (!need_inval)
286			return;
287
288			if (cpu->machine->arch != ARCH_MIPS) {
289			/* TODO! */
290
291			return;
292			}
293
294			/* Invalidate any pages of this device that might
295			be in the bintrans load/store cache, by marking
296			the pages read-only. */
297
298			for (s=0; s<mem->dev_length[i]; s+=4096) {
299			mips_invalidate_translation_caches_paddr(
300			cpu, mem->dev_baseaddr[i] + s);
301			}
302
303			/* ... and invalidate the "fast_vaddr_to_hostaddr"
304			cache entries that contain pointers to this
305			device: (NOTE: Device i, cache entry j) */
306			for (j=0; j<N_BINTRANS_VADDR_TO_HOST; j++) {
307			if (cpu->cd.mips.bintrans_data_hostpage[j] >=
308			mem->dev_bintrans_data[i] &&
309			cpu->cd.mips.bintrans_data_hostpage[j] <
310			mem->dev_bintrans_data[i] +
311			mem->dev_length[i])
312			cpu->cd.mips.
313			bintrans_data_hostpage[j] = NULL;
314			}
315
316			return;
317			}
318			}
319			#endif
320			}
321
322
323			/*
324			* memory_device_register_statefunction():
325			*
326			* TODO: Hm. This is semi-ugly. Should probably be rewritten/redesigned
327			* some day.
328			*/
329			void memory_device_register_statefunction(
330			struct memory mem, void extra,
331			int (dev_f_state)(struct cpu ,
332			struct memory , void extra, int wf, int nr,
333			int type, char namep, void data, size_t len))
334			{
335			int i;
336
337			for (i=0; i<mem->n_mmapped_devices; i++)
338			if (mem->dev_extra[i] == extra) {
339			mem->dev_f_state[i] = dev_f_state;
340			return;
341			}
342
343			printf("memory_device_register_statefunction(): "
344			"couldn't find the device\n");
345			exit(1);
346			}
347
348
349			/*
350			* memory_device_register():
351			*
352			* Register a (memory mapped) device by adding it to the dev_* fields of a
353			* memory struct.
354			*/
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			void extra, int flags, unsigned char bintrans_data)
360			{
361			int i;
362
363			if (mem->n_mmapped_devices >= MAX_DEVICES) {
364			fprintf(stderr, "memory_device_register(): too many "
365			"devices registered, cannot register '%s'\n", device_name);
366			exit(1);
367			}
368
369			/* Check for collisions: */
370			for (i=0; i<mem->n_mmapped_devices; i++) {
371			/* If we are not colliding with device i, then continue: */
372			if (baseaddr + len <= mem->dev_baseaddr[i])
373			continue;
374			if (baseaddr >= mem->dev_baseaddr[i] + mem->dev_length[i])
375			continue;
376
377			fatal("\nWARNING! \"%s\" collides with device %i (\"%s\")!\n"
378			" Run-time behaviour will be undefined!\n\n",
379			device_name, i, mem->dev_name[i]);
380			}
381
382			/* (40 bits of physical address is displayed) */
383			debug("device %2i at 0x%010llx: %s",
384			mem->n_mmapped_devices, (long long)baseaddr, device_name);
385
386			#ifdef BINTRANS
387			if (flags & (MEM_BINTRANS_OK \| MEM_BINTRANS_WRITE_OK)
388			&& (baseaddr & 0xfff) != 0) {
389			fatal("\nWARNING: Device bintrans access, but unaligned"
390			" baseaddr 0x%llx.\n", (long long)baseaddr);
391			}
392
393			if (flags & (MEM_BINTRANS_OK \| MEM_BINTRANS_WRITE_OK)) {
394			debug(" (bintrans %s)",
395			(flags & MEM_BINTRANS_WRITE_OK)? "R/W" : "R");
396			}
397			#endif
398			debug("\n");
399
400			mem->dev_name[mem->n_mmapped_devices] = strdup(device_name);
401			mem->dev_baseaddr[mem->n_mmapped_devices] = baseaddr;
402			mem->dev_length[mem->n_mmapped_devices] = len;
403			mem->dev_flags[mem->n_mmapped_devices] = flags;
404			mem->dev_bintrans_data[mem->n_mmapped_devices] = bintrans_data;
405
406			if (mem->dev_name[mem->n_mmapped_devices] == NULL) {
407			fprintf(stderr, "out of memory\n");
408			exit(1);
409			}
410
411			if ((size_t)bintrans_data & 1) {
412			fprintf(stderr, "memory_device_register():"
413			" bintrans_data not aligned correctly\n");
414			exit(1);
415			}
416
417			#ifdef BINTRANS
418			mem->dev_bintrans_write_low[mem->n_mmapped_devices] = (uint64_t)-1;
419			mem->dev_bintrans_write_high[mem->n_mmapped_devices] = 0;
420			#endif
421			mem->dev_f[mem->n_mmapped_devices] = f;
422			mem->dev_extra[mem->n_mmapped_devices] = extra;
423			mem->n_mmapped_devices++;
424
425			if (baseaddr < mem->mmap_dev_minaddr)
426	dpavlin	4	mem->mmap_dev_minaddr = baseaddr & ~0xfff;
427	dpavlin	2	if (baseaddr + len > mem->mmap_dev_maxaddr)
428	dpavlin	4	mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) \| 0xfff) + 1;
429	dpavlin	2	}
430
431
432			/*
433			* memory_device_remove():
434			*
435			* Unregister a (memory mapped) device from a memory struct.
436			*/
437			void memory_device_remove(struct memory *mem, int i)
438			{
439			if (i < 0 \|\| i >= mem->n_mmapped_devices) {
440			fatal("memory_device_remove(): invalid device number %i\n", i);
441			return;
442			}
443
444			mem->n_mmapped_devices --;
445
446			if (i == mem->n_mmapped_devices)
447			return;
448
449			/*
450			* YUCK! This is ugly. TODO: fix
451			*/
452
453			memmove(&mem->dev_name[i], &mem->dev_name[i+1], sizeof(char )
454			(MAX_DEVICES - i - 1));
455			memmove(&mem->dev_baseaddr[i], &mem->dev_baseaddr[i+1],
456			sizeof(uint64_t) * (MAX_DEVICES - i - 1));
457			memmove(&mem->dev_length[i], &mem->dev_length[i+1], sizeof(uint64_t) *
458			(MAX_DEVICES - i - 1));
459			memmove(&mem->dev_flags[i], &mem->dev_flags[i+1], sizeof(int) *
460			(MAX_DEVICES - i - 1));
461			memmove(&mem->dev_extra[i], &mem->dev_extra[i+1], sizeof(void )
462			(MAX_DEVICES - i - 1));
463			memmove(&mem->dev_f[i], &mem->dev_f[i+1], sizeof(void )
464			(MAX_DEVICES - i - 1));
465			memmove(&mem->dev_f_state[i], &mem->dev_f_state[i+1], sizeof(void )
466			(MAX_DEVICES - i - 1));
467			memmove(&mem->dev_bintrans_data[i], &mem->dev_bintrans_data[i+1],
468			sizeof(void ) (MAX_DEVICES - i - 1));
469			#ifdef BINTRANS
470			memmove(&mem->dev_bintrans_write_low[i], &mem->dev_bintrans_write_low
471			[i+1], sizeof(void ) (MAX_DEVICES - i - 1));
472			memmove(&mem->dev_bintrans_write_high[i], &mem->dev_bintrans_write_high
473			[i+1], sizeof(void ) (MAX_DEVICES - i - 1));
474			#endif
475			}
476
477
478			#define MEMORY_RW userland_memory_rw
479			#define MEM_USERLAND
480			#include "memory_rw.c"
481			#undef MEM_USERLAND
482			#undef MEMORY_RW
483
484
485			/*
486			* memory_paddr_to_hostaddr():
487			*
488			* Translate a physical address into a host address.
489			*
490			* Return value is a pointer to a host memblock, or NULL on failure.
491			* On reads, a NULL return value should be interpreted as reading all zeroes.
492			*/
493			unsigned char memory_paddr_to_hostaddr(struct memory mem,
494			uint64_t paddr, int writeflag)
495			{
496			void **table;
497			int entry;
498			const int mask = (1 << BITS_PER_PAGETABLE) - 1;
499			const int shrcount = MAX_BITS - BITS_PER_PAGETABLE;
500
501			table = mem->pagetable;
502			entry = (paddr >> shrcount) & mask;
503
504			/* printf(" entry = %x\n", entry); */
505
506			if (table[entry] == NULL) {
507			size_t alloclen;
508
509			/*
510			* Special case: reading from a nonexistant memblock
511			* returns all zeroes, and doesn't allocate anything.
512			* (If any intermediate pagetable is nonexistant, then
513			* the same thing happens):
514			*/
515			if (writeflag == MEM_READ)
516			return NULL;
517
518			/* Allocate a memblock: */
519			alloclen = 1 << BITS_PER_MEMBLOCK;
520
521			/* printf(" allocating for entry %i, len=%i\n",
522			entry, alloclen); */
523
524			/* Anonymous mmap() should return zero-filled memory,
525			try malloc + memset if mmap failed. */
526			table[entry] = (void *) mmap(NULL, alloclen,
527			PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE,
528			-1, 0);
529			if (table[entry] == NULL) {
530			table[entry] = malloc(alloclen);
531			if (table[entry] == NULL) {
532			fatal("out of memory\n");
533			exit(1);
534			}
535			memset(table[entry], 0, alloclen);
536			}
537			}
538
539			return (unsigned char *) table[entry];
540			}
541