system.cc revision 1808 
1/*
2 * Copyright (c) 2002-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * 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 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include "base/loader/object_file.hh"
30#include "base/loader/symtab.hh"
31#include "base/remote_gdb.hh"
32#include "cpu/exec_context.hh"
33#include "kern/kernel_stats.hh"
34#include "mem/functional/memory_control.hh"
35#include "mem/functional/physical.hh"
36#include "targetarch/vtophys.hh"
37#include "sim/builder.hh"
38#include "sim/system.hh"
39#include "base/trace.hh"
40
41using namespace std;
42
43vector<System *> System::systemList;
44
45int System::numSystemsRunning = 0;
46
47System::System(Params *p)
48    : SimObject(p->name), memctrl(p->memctrl), physmem(p->physmem),
49      init_param(p->init_param), numcpus(0), params(p)
50{
51    // add self to global system list
52    systemList.push_back(this);
53
54    kernelSymtab = new SymbolTable;
55    consoleSymtab = new SymbolTable;
56    palSymtab = new SymbolTable;
57    debugSymbolTable = new SymbolTable;
58
59    /**
60     * Load the kernel, pal, and console code into memory
61     */
62    // Load kernel code
63    kernel = createObjectFile(params->kernel_path);
64    if (kernel == NULL)
65        fatal("Could not load kernel file %s", params->kernel_path);
66
67    // Load Console Code
68    console = createObjectFile(params->console_path);
69    if (console == NULL)
70        fatal("Could not load console file %s", params->console_path);
71
72    // Load pal file
73    pal = createObjectFile(params->palcode);
74    if (pal == NULL)
75        fatal("Could not load PALcode file %s", params->palcode);
76
77
78    // Load program sections into memory
79    pal->loadSections(physmem, true);
80    console->loadSections(physmem, true);
81    kernel->loadSections(physmem, true);
82
83    // setup entry points
84    kernelStart = kernel->textBase();
85    kernelEnd = kernel->bssBase() + kernel->bssSize();
86    kernelEntry = kernel->entryPoint();
87
88    // load symbols
89    if (!kernel->loadGlobalSymbols(kernelSymtab))
90        panic("could not load kernel symbols\n");
91
92    if (!kernel->loadLocalSymbols(kernelSymtab))
93        panic("could not load kernel local symbols\n");
94
95    if (!console->loadGlobalSymbols(consoleSymtab))
96        panic("could not load console symbols\n");
97
98    if (!pal->loadGlobalSymbols(palSymtab))
99        panic("could not load pal symbols\n");
100
101    if (!pal->loadLocalSymbols(palSymtab))
102        panic("could not load pal symbols\n");
103
104    if (!kernel->loadGlobalSymbols(debugSymbolTable))
105        panic("could not load kernel symbols\n");
106
107    if (!kernel->loadLocalSymbols(debugSymbolTable))
108        panic("could not load kernel local symbols\n");
109
110    if (!console->loadGlobalSymbols(debugSymbolTable))
111        panic("could not load console symbols\n");
112
113    if (!pal->loadGlobalSymbols(debugSymbolTable))
114        panic("could not load pal symbols\n");
115
116    if (!pal->loadLocalSymbols(debugSymbolTable))
117        panic("could not load pal symbols\n");
118
119
120    DPRINTF(Loader, "Kernel start = %#x\n", kernelStart);
121    DPRINTF(Loader, "Kernel end   = %#x\n", kernelEnd);
122    DPRINTF(Loader, "Kernel entry = %#x\n", kernelEntry);
123    DPRINTF(Loader, "Kernel loaded...\n");
124
125    Addr addr = 0;
126#ifdef DEBUG
127    consolePanicEvent = new BreakPCEvent(&pcEventQueue, "console panic");
128    if (consoleSymtab->findAddress("panic", addr))
129        consolePanicEvent->schedule(addr);
130#endif
131
132    /**
133     * Copy the osflags (kernel arguments) into the consoles
134     * memory. (Presently Linux does not use the console service
135     * routine to get these command line arguments, but Tru64 and
136     * others do.)
137     */
138    if (consoleSymtab->findAddress("env_booted_osflags", addr)) {
139        Addr paddr = vtophys(physmem, addr);
140        char *osflags = (char *)physmem->dma_addr(paddr, sizeof(uint32_t));
141
142        if (osflags)
143              strcpy(osflags, params->boot_osflags.c_str());
144    }
145
146    /**
147     * Set the hardware reset parameter block system type and revision
148     * information to Tsunami.
149     */
150    if (consoleSymtab->findAddress("m5_rpb", addr)) {
151        Addr paddr = vtophys(physmem, addr);
152        char *hwrpb = (char *)physmem->dma_addr(paddr, sizeof(uint64_t));
153
154        if (!hwrpb)
155            panic("could not translate hwrpb addr\n");
156
157        *(uint64_t*)(hwrpb+0x50) = htoa(params->system_type);
158        *(uint64_t*)(hwrpb+0x58) = htoa(params->system_rev);
159    } else
160        panic("could not find hwrpb\n");
161
162    // increment the number of running systms
163    numSystemsRunning++;
164
165    kernelBinning = new Kernel::Binning(this);
166}
167
168System::~System()
169{
170    delete kernelSymtab;
171    delete consoleSymtab;
172    delete kernel;
173    delete console;
174    delete pal;
175
176    delete kernelBinning;
177
178#ifdef DEBUG
179    delete consolePanicEvent;
180#endif
181}
182
183void
184System::setAlphaAccess(Addr access)
185{
186    Addr addr = 0;
187    if (consoleSymtab->findAddress("m5AlphaAccess", addr)) {
188        Addr paddr = vtophys(physmem, addr);
189        uint64_t *m5AlphaAccess =
190            (uint64_t *)physmem->dma_addr(paddr, sizeof(uint64_t));
191
192        if (!m5AlphaAccess)
193            panic("could not translate m5AlphaAccess addr\n");
194
195        *m5AlphaAccess = htoa(EV5::Phys2K0Seg(access));
196    } else
197        panic("could not find m5AlphaAccess\n");
198}
199
200bool
201System::breakpoint()
202{
203    return remoteGDB[0]->trap(ALPHA_KENTRY_INT);
204}
205
206int rgdb_wait = -1;
207
208int
209System::registerExecContext(ExecContext *xc, int id)
210{
211    if (id == -1) {
212        for (id = 0; id < execContexts.size(); id++) {
213            if (!execContexts[id])
214                break;
215        }
216    }
217
218    if (execContexts.size() <= id)
219        execContexts.resize(id + 1);
220
221    if (execContexts[id])
222        panic("Cannot have two CPUs with the same id (%d)\n", id);
223
224    execContexts[id] = xc;
225    numcpus++;
226
227    RemoteGDB *rgdb = new RemoteGDB(this, xc);
228    GDBListener *gdbl = new GDBListener(rgdb, 7000 + id);
229    gdbl->listen();
230    /**
231     * Uncommenting this line waits for a remote debugger to connect
232     * to the simulator before continuing.
233     */
234    if (rgdb_wait != -1 && rgdb_wait == id)
235        gdbl->accept();
236
237    if (remoteGDB.size() <= id) {
238        remoteGDB.resize(id + 1);
239    }
240
241    remoteGDB[id] = rgdb;
242
243    return id;
244}
245
246void
247System::startup()
248{
249    if (!execContexts.empty()) {
250        // activate with zero delay so that we start ticking right
251        // away on cycle 0
252        execContexts[0]->activate(0);
253    }
254}
255
256void
257System::replaceExecContext(ExecContext *xc, int id)
258{
259    if (id >= execContexts.size()) {
260        panic("replaceExecContext: bad id, %d >= %d\n",
261              id, execContexts.size());
262    }
263
264    execContexts[id] = xc;
265    remoteGDB[id]->replaceExecContext(xc);
266}
267
268void
269System::regStats()
270{
271    kernelBinning->regStats(name() + ".kern");
272}
273
274void
275System::serialize(ostream &os)
276{
277    kernelBinning->serialize(os);
278}
279
280
281void
282System::unserialize(Checkpoint *cp, const string &section)
283{
284    kernelBinning->unserialize(cp, section);
285}
286
287void
288System::printSystems()
289{
290    vector<System *>::iterator i = systemList.begin();
291    vector<System *>::iterator end = systemList.end();
292    for (; i != end; ++i) {
293        System *sys = *i;
294        cerr << "System " << sys->name() << ": " << hex << sys << endl;
295    }
296}
297
298extern "C"
299void
300printSystems()
301{
302    System::printSystems();
303}
304
305BEGIN_DECLARE_SIM_OBJECT_PARAMS(System)
306
307    Param<Tick> boot_cpu_frequency;
308    SimObjectParam<MemoryController *> memctrl;
309    SimObjectParam<PhysicalMemory *> physmem;
310
311    Param<string> kernel;
312    Param<string> console;
313    Param<string> pal;
314
315    Param<string> boot_osflags;
316    Param<string> readfile;
317    Param<unsigned int> init_param;
318
319    Param<uint64_t> system_type;
320    Param<uint64_t> system_rev;
321
322    Param<bool> bin;
323    VectorParam<string> binned_fns;
324    Param<bool> bin_int;
325
326END_DECLARE_SIM_OBJECT_PARAMS(System)
327
328BEGIN_INIT_SIM_OBJECT_PARAMS(System)
329
330    INIT_PARAM(boot_cpu_frequency, "Frequency of the boot CPU"),
331    INIT_PARAM(memctrl, "memory controller"),
332    INIT_PARAM(physmem, "phsyical memory"),
333    INIT_PARAM(kernel, "file that contains the kernel code"),
334    INIT_PARAM(console, "file that contains the console code"),
335    INIT_PARAM(pal, "file that contains palcode"),
336    INIT_PARAM_DFLT(boot_osflags, "flags to pass to the kernel during boot",
337                    "a"),
338    INIT_PARAM_DFLT(readfile, "file to read startup script from", ""),
339    INIT_PARAM_DFLT(init_param, "numerical value to pass into simulator", 0),
340    INIT_PARAM_DFLT(system_type, "Type of system we are emulating", 34),
341    INIT_PARAM_DFLT(system_rev, "Revision of system we are emulating", 1<<10),
342    INIT_PARAM_DFLT(bin, "is this system to be binned", false),
343    INIT_PARAM(binned_fns, "functions to be broken down and binned"),
344    INIT_PARAM_DFLT(bin_int, "is interrupt code binned seperately?", true)
345
346END_INIT_SIM_OBJECT_PARAMS(System)
347
348CREATE_SIM_OBJECT(System)
349{
350    System::Params *p = new System::Params;
351    p->name = getInstanceName();
352    p->boot_cpu_frequency = boot_cpu_frequency;
353    p->memctrl = memctrl;
354    p->physmem = physmem;
355    p->kernel_path = kernel;
356    p->console_path = console;
357    p->palcode = pal;
358    p->boot_osflags = boot_osflags;
359    p->init_param = init_param;
360    p->readfile = readfile;
361    p->system_type = system_type;
362    p->system_rev = system_rev;
363    p->bin = bin;
364    p->binned_fns = binned_fns;
365    p->bin_int = bin_int;
366    return new System(p);
367}
368
369REGISTER_SIM_OBJECT("System", System)
370
371