1/*
2 * Copyright (c) 2014 Advanced Micro Devices, Inc.
3 * Copyright (c) 2012 ARM Limited
4 * All rights reserved
5 *
6 * The license below extends only to copyright in the software and shall
7 * not be construed as granting a license to any other intellectual
8 * property including but not limited to intellectual property relating

--- 33 unchanged lines hidden (view full) ---

42 * Steve Reinhardt
43 * Ali Saidi
44 */
45
46#include <fcntl.h>
47#include <unistd.h>
48
49#include <cstdio>
50#include <map>
51#include <string>
52
53#include "base/loader/object_file.hh"
54#include "base/loader/symtab.hh"
55#include "base/intmath.hh"
56#include "base/statistics.hh"
57#include "config/the_isa.hh"
58#include "cpu/thread_context.hh"

--- 40 unchanged lines hidden (view full) ---

99{
100 a_type = TheISA::htog(type);
101 a_val = TheISA::htog(val);
102}
103
104template struct AuxVector<uint32_t>;
105template struct AuxVector<uint64_t>;
106
107static int
108openFile(const string& filename, int flags, mode_t mode)
109{
110 int sim_fd = open(filename.c_str(), flags, mode);
111 if (sim_fd != -1)
112 return sim_fd;
113 fatal("Unable to open %s with mode %O", filename, mode);
114}
115
116static int
117openInputFile(const string &filename)
118{
119 return openFile(filename, O_RDONLY, 0);
120}
121
122static int
123openOutputFile(const string &filename)
124{
125 return openFile(filename, O_WRONLY | O_CREAT | O_TRUNC, 0664);
126}
127
128Process::Process(ProcessParams * params)
129 : SimObject(params), system(params->system),
130 brk_point(0), stack_base(0), stack_size(0), stack_min(0),
131 max_stack_size(params->max_stack_size),
132 next_thread_stack_base(0),
133 M5_pid(system->allocatePID()),
134 useArchPT(params->useArchPT),
135 kvmInSE(params->kvmInSE),
136 pTable(useArchPT ?
137 static_cast<PageTableBase *>(new ArchPageTable(name(), M5_pid, system)) :
138 static_cast<PageTableBase *>(new FuncPageTable(name(), M5_pid)) ),
139 initVirtMem(system->getSystemPort(), this,
140 SETranslatingPortProxy::Always),
141 fd_array(make_shared<array<FDEntry, NUM_FDS>>()),
142 imap {{"", -1},
143 {"cin", STDIN_FILENO},
144 {"stdin", STDIN_FILENO}},
145 oemap{{"", -1},
146 {"cout", STDOUT_FILENO},
147 {"stdout", STDOUT_FILENO},
148 {"cerr", STDERR_FILENO},
149 {"stderr", STDERR_FILENO}}
150{
151 int sim_fd;
152 std::map<string,int>::iterator it;
153
154 // Search through the input options and set fd if match is found;
155 // otherwise, open an input file and seek to location.
156 FDEntry *fde_stdin = get_fd_entry(STDIN_FILENO);
157 if ((it = imap.find(params->input)) != imap.end())
158 sim_fd = it->second;
159 else
160 sim_fd = openInputFile(params->input);
161 fde_stdin->set(sim_fd, params->input, O_RDONLY, -1, false);
162
163 // Search through the output/error options and set fd if match is found;
164 // otherwise, open an output file and seek to location.
165 FDEntry *fde_stdout = get_fd_entry(STDOUT_FILENO);
166 if ((it = oemap.find(params->output)) != oemap.end())
167 sim_fd = it->second;
168 else
169 sim_fd = openOutputFile(params->output);
170 fde_stdout->set(sim_fd, params->output, O_WRONLY | O_CREAT | O_TRUNC,
171 0664, false);
172
173 FDEntry *fde_stderr = get_fd_entry(STDERR_FILENO);
174 if (params->output == params->errout)
175 // Reuse the same file descriptor if these match.
176 sim_fd = fde_stdout->fd;
177 else if ((it = oemap.find(params->errout)) != oemap.end())
178 sim_fd = it->second;
179 else
180 sim_fd = openOutputFile(params->errout);
181 fde_stderr->set(sim_fd, params->errout, O_WRONLY | O_CREAT | O_TRUNC,
182 0664, false);
183
184 mmap_start = mmap_end = 0;
185 nxm_start = nxm_end = 0;
186 // other parameters will be initialized when the program is loaded
187}
188
189
190void
191Process::regStats()
192{
193 using namespace Stats;
194
195 num_syscalls
196 .name(name() + ".num_syscalls")
197 .desc("Number of system calls")
198 ;
199}
200
201void
202Process::inheritFdArray(Process *p)
203{
204 fd_array = p->fd_array;
205}
206
207ThreadContext *
208Process::findFreeContext()
209{
210 for (int id : contextIds) {
211 ThreadContext *tc = system->getThreadContext(id);
212 if (tc->status() == ThreadContext::Halted)
213 return tc;
214 }

--- 21 unchanged lines hidden (view full) ---

236 find_file_offsets();
237 return DrainState::Drained;
238}
239
240int
241Process::alloc_fd(int sim_fd, const string& filename, int flags, int mode,
242 bool pipe)
243{
244 if (sim_fd == -1)
245 return -1;
246
247 for (int free_fd = 0; free_fd < fd_array->size(); free_fd++) {
248 FDEntry *fde = get_fd_entry(free_fd);
249 if (fde->isFree()) {
250 fde->set(sim_fd, filename, flags, mode, pipe);
251 return free_fd;
252 }
253 }
254
255 fatal("Out of target file descriptors");
256}
257
258void
259Process::reset_fd_entry(int tgt_fd)
260{
261 FDEntry *fde = get_fd_entry(tgt_fd);
262 assert(fde->fd > -1);
263
264 fde->reset();
265}
266
267int
268Process::sim_fd(int tgt_fd)
269{
270 FDEntry *entry = get_fd_entry(tgt_fd);
271 return entry ? entry->fd : -1;
272}
273
274FDEntry *
275Process::get_fd_entry(int tgt_fd)
276{
277 assert(0 <= tgt_fd && tgt_fd < fd_array->size());
278 return &(*fd_array)[tgt_fd];
279}
280
281int
282Process::tgt_fd(int sim_fd)
283{
284 for (int index = 0; index < fd_array->size(); index++)
285 if ((*fd_array)[index].fd == sim_fd)
286 return index;
287 return -1;
288}
289
290void
291Process::allocateMem(Addr vaddr, int64_t size, bool clobber)
292{
293 int npages = divCeil(size, (int64_t)PageBytes);

--- 21 unchanged lines hidden (view full) ---

315 allocateMem(stack_min, TheISA::PageBytes);
316 inform("Increasing stack size by one page.");
317 };
318 return true;
319 }
320 return false;
321}
322
323void
324Process::fix_file_offsets()
325{
326 auto seek = [] (FDEntry *fde)
327 {
328 if (lseek(fde->fd, fde->fileOffset, SEEK_SET) < 0)
329 fatal("Unable to see to location in %s", fde->filename);
330 };
331
332 std::map<string,int>::iterator it;
333
334 // Search through the input options and set fd if match is found;
335 // otherwise, open an input file and seek to location.
336 FDEntry *fde_stdin = get_fd_entry(STDIN_FILENO);
337 if ((it = imap.find(fde_stdin->filename)) != imap.end()) {
338 fde_stdin->fd = it->second;
339 } else {
340 fde_stdin->fd = openInputFile(fde_stdin->filename);
341 seek(fde_stdin);
342 }
343
344 // Search through the output/error options and set fd if match is found;
345 // otherwise, open an output file and seek to location.
346 FDEntry *fde_stdout = get_fd_entry(STDOUT_FILENO);
347 if ((it = oemap.find(fde_stdout->filename)) != oemap.end()) {
348 fde_stdout->fd = it->second;
349 } else {
350 fde_stdout->fd = openOutputFile(fde_stdout->filename);
351 seek(fde_stdout);
352 }
353
354 FDEntry *fde_stderr = get_fd_entry(STDERR_FILENO);
355 if (fde_stdout->filename == fde_stderr->filename) {
356 // Reuse the same file descriptor if these match.
357 fde_stderr->fd = fde_stdout->fd;
358 } else if ((it = oemap.find(fde_stderr->filename)) != oemap.end()) {
359 fde_stderr->fd = it->second;
360 } else {
361 fde_stderr->fd = openOutputFile(fde_stderr->filename);
362 seek(fde_stderr);
363 }
364
365 for (int tgt_fd = 3; tgt_fd < fd_array->size(); tgt_fd++) {
366 FDEntry *fde = get_fd_entry(tgt_fd);
367 if (fde->fd == -1)
368 continue;
369
370 if (fde->isPipe) {
371 if (fde->filename == "PIPE-WRITE")
372 continue;
373 assert(fde->filename == "PIPE-READ");
374
375 int fds[2];
376 if (pipe(fds) < 0)
377 fatal("Unable to create new pipe");
378
379 fde->fd = fds[0];
380
381 FDEntry *fde_write = get_fd_entry(fde->readPipeSource);
382 assert(fde_write->filename == "PIPE-WRITE");
383 fde_write->fd = fds[1];
384 } else {
385 fde->fd = openFile(fde->filename.c_str(), fde->flags, fde->mode);
386 seek(fde);
387 }
388 }
389}
390
391void
392Process::find_file_offsets()
393{
394 for (auto& fde : *fd_array) {
395 if (fde.fd != -1)
396 fde.fileOffset = lseek(fde.fd, 0, SEEK_CUR);
397 }
398}
399
400void
401Process::setReadPipeSource(int read_pipe_fd, int source_fd)
402{
403 FDEntry *fde = get_fd_entry(read_pipe_fd);
404 assert(source_fd >= -1);
405 fde->readPipeSource = source_fd;
406}
407
408void
409Process::serialize(CheckpointOut &cp) const
410{
411 SERIALIZE_SCALAR(brk_point);
412 SERIALIZE_SCALAR(stack_base);
413 SERIALIZE_SCALAR(stack_size);
414 SERIALIZE_SCALAR(stack_min);
415 SERIALIZE_SCALAR(next_thread_stack_base);
416 SERIALIZE_SCALAR(mmap_start);
417 SERIALIZE_SCALAR(mmap_end);
418 SERIALIZE_SCALAR(nxm_start);
419 SERIALIZE_SCALAR(nxm_end);
420 pTable->serialize(cp);
421 for (int x = 0; x < fd_array->size(); x++) {
422 (*fd_array)[x].serializeSection(cp, csprintf("FDEntry%d", x));
423 }
424 SERIALIZE_SCALAR(M5_pid);
425
426}
427
428void
429Process::unserialize(CheckpointIn &cp)
430{
431 UNSERIALIZE_SCALAR(brk_point);
432 UNSERIALIZE_SCALAR(stack_base);
433 UNSERIALIZE_SCALAR(stack_size);
434 UNSERIALIZE_SCALAR(stack_min);
435 UNSERIALIZE_SCALAR(next_thread_stack_base);
436 UNSERIALIZE_SCALAR(mmap_start);
437 UNSERIALIZE_SCALAR(mmap_end);
438 UNSERIALIZE_SCALAR(nxm_start);
439 UNSERIALIZE_SCALAR(nxm_end);
440 pTable->unserialize(cp);
441 for (int x = 0; x < fd_array->size(); x++) {
442 FDEntry *fde = get_fd_entry(x);
443 fde->unserializeSection(cp, csprintf("FDEntry%d", x));
444 }
445 fix_file_offsets();
446 UNSERIALIZE_OPT_SCALAR(M5_pid);
447 // The above returns a bool so that you could do something if you don't
448 // find the param in the checkpoint if you wanted to, like set a default
449 // but in this case we'll just stick with the instantiated value if not
450 // found.
451}
452
453
454bool
455Process::map(Addr vaddr, Addr paddr, int size, bool cacheable)
456{
457 pTable->map(vaddr, paddr, size,

--- 220 unchanged lines hidden ---