1/*
2 * Copyright (c) 2012-2013, 2015 ARM Limited
3 * Copyright (c) 2015 Advanced Micro Devices, Inc.
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
9 * to a hardware implementation of the functionality of the software
10 * licensed hereunder. You may use the software subject to the license
11 * terms below provided that you ensure that this notice is replicated
12 * unmodified and in its entirety in all distributions of the software,
13 * modified or unmodified, in source code or in binary form.
14 *
15 * Copyright (c) 2003-2005 The Regents of The University of Michigan
16 * All rights reserved.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions are
20 * met: redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer;
22 * redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution;
25 * neither the name of the copyright holders nor the names of its
26 * contributors may be used to endorse or promote products derived from
27 * this software without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 * Authors: Steve Reinhardt
42 * Kevin Lim
43 */
44
45#ifndef __SIM_SYSCALL_EMUL_HH__
46#define __SIM_SYSCALL_EMUL_HH__
47
48#if (defined(__APPLE__) || defined(__OpenBSD__) || \
49 defined(__FreeBSD__) || defined(__CYGWIN__) || \
50 defined(__NetBSD__))
51#define NO_STAT64 1
52#else
53#define NO_STAT64 0
54#endif
55
56#if (defined(__APPLE__) || defined(__OpenBSD__) || \
57 defined(__FreeBSD__) || defined(__NetBSD__))
58#define NO_STATFS 1
59#else
60#define NO_STATFS 0
61#endif
62
63#if (defined(__APPLE__) || defined(__OpenBSD__) || \
64 defined(__FreeBSD__) || defined(__NetBSD__))
65#define NO_FALLOCATE 1
66#else
67#define NO_FALLOCATE 0
68#endif
69
70///
71/// @file syscall_emul.hh
72///
73/// This file defines objects used to emulate syscalls from the target
74/// application on the host machine.
75
76#ifdef __CYGWIN32__
77#include <sys/fcntl.h>
78
79#endif
80#include <fcntl.h>
81#include <net/if.h>
82#include <poll.h>
83#include <sys/ioctl.h>
84#include <sys/mman.h>
85#include <sys/socket.h>
86#include <sys/stat.h>
87
88#if (NO_STATFS == 0)
89#include <sys/statfs.h>
90
91#else
92#include <sys/mount.h>
93
94#endif
95#include <sys/time.h>
96#include <sys/types.h>
97#include <sys/uio.h>
98#include <unistd.h>
99
100#include <cerrno>
101#include <memory>
102#include <string>
103
104#include "arch/generic/tlb.hh"
105#include "arch/utility.hh"
106#include "base/intmath.hh"
107#include "base/loader/object_file.hh"
108#include "base/logging.hh"
109#include "base/trace.hh"
110#include "base/types.hh"
111#include "config/the_isa.hh"
112#include "cpu/base.hh"
113#include "cpu/thread_context.hh"
114#include "mem/page_table.hh"
115#include "params/Process.hh"
116#include "sim/emul_driver.hh"
117#include "sim/futex_map.hh"
118#include "sim/process.hh"
119#include "sim/syscall_debug_macros.hh"
120#include "sim/syscall_desc.hh"
121#include "sim/syscall_emul_buf.hh"
122#include "sim/syscall_return.hh"
123
124#if defined(__APPLE__) && defined(__MACH__) && !defined(CMSG_ALIGN)
125#define CMSG_ALIGN(len) (((len) + sizeof(size_t) - 1) & ~(sizeof(size_t) - 1))
126#endif
127
128//////////////////////////////////////////////////////////////////////
129//
130// The following emulation functions are generic enough that they
131// don't need to be recompiled for different emulated OS's. They are
132// defined in sim/syscall_emul.cc.
133//
134//////////////////////////////////////////////////////////////////////
135
136
137/// Handler for unimplemented syscalls that we haven't thought about.
138SyscallReturn unimplementedFunc(SyscallDesc *desc, int num,
139 Process *p, ThreadContext *tc);
140
141/// Handler for unimplemented syscalls that we never intend to
142/// implement (signal handling, etc.) and should not affect the correct
143/// behavior of the program. Print a warning only if the appropriate
144/// trace flag is enabled. Return success to the target program.
145SyscallReturn ignoreFunc(SyscallDesc *desc, int num,
146 Process *p, ThreadContext *tc);
147
148// Target fallocateFunc() handler.
149SyscallReturn fallocateFunc(SyscallDesc *desc, int num,
150 Process *p, ThreadContext *tc);
151
152/// Target exit() handler: terminate current context.
153SyscallReturn exitFunc(SyscallDesc *desc, int num,
154 Process *p, ThreadContext *tc);
155
156/// Target exit_group() handler: terminate simulation. (exit all threads)
157SyscallReturn exitGroupFunc(SyscallDesc *desc, int num,
158 Process *p, ThreadContext *tc);
159
160/// Target set_tid_address() handler.
161SyscallReturn setTidAddressFunc(SyscallDesc *desc, int num,
162 Process *p, ThreadContext *tc);
163
164/// Target getpagesize() handler.
165SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num,
166 Process *p, ThreadContext *tc);
167
168/// Target brk() handler: set brk address.
169SyscallReturn brkFunc(SyscallDesc *desc, int num,
170 Process *p, ThreadContext *tc);
171
172/// Target close() handler.
173SyscallReturn closeFunc(SyscallDesc *desc, int num,
174 Process *p, ThreadContext *tc);
175
176/// Target lseek() handler.
177SyscallReturn lseekFunc(SyscallDesc *desc, int num,
178 Process *p, ThreadContext *tc);
179
180/// Target _llseek() handler.
181SyscallReturn _llseekFunc(SyscallDesc *desc, int num,
182 Process *p, ThreadContext *tc);
183
184/// Target munmap() handler.
185SyscallReturn munmapFunc(SyscallDesc *desc, int num,
186 Process *p, ThreadContext *tc);
187
188/// Target shutdown() handler.
189SyscallReturn shutdownFunc(SyscallDesc *desc, int num,
190 Process *p, ThreadContext *tc);
191
192/// Target gethostname() handler.
193SyscallReturn gethostnameFunc(SyscallDesc *desc, int num,
194 Process *p, ThreadContext *tc);
195
196/// Target getcwd() handler.
197SyscallReturn getcwdFunc(SyscallDesc *desc, int num,
198 Process *p, ThreadContext *tc);
199
200/// Target readlink() handler.
201SyscallReturn readlinkFunc(SyscallDesc *desc, int num,
202 Process *p, ThreadContext *tc,
203 int index = 0);
204SyscallReturn readlinkFunc(SyscallDesc *desc, int num,
205 Process *p, ThreadContext *tc);
206
207/// Target unlink() handler.
208SyscallReturn unlinkHelper(SyscallDesc *desc, int num,
209 Process *p, ThreadContext *tc,
210 int index);
211SyscallReturn unlinkFunc(SyscallDesc *desc, int num,
212 Process *p, ThreadContext *tc);
213
214/// Target link() handler
215SyscallReturn linkFunc(SyscallDesc *desc, int num, Process *p,
216 ThreadContext *tc);
217
218/// Target symlink() handler.
219SyscallReturn symlinkFunc(SyscallDesc *desc, int num, Process *p,
220 ThreadContext *tc);
221
222/// Target mkdir() handler.
223SyscallReturn mkdirFunc(SyscallDesc *desc, int num,
224 Process *p, ThreadContext *tc);
225
226/// Target mknod() handler.
227SyscallReturn mknodFunc(SyscallDesc *desc, int num,
228 Process *p, ThreadContext *tc);
229
230/// Target chdir() handler.
231SyscallReturn chdirFunc(SyscallDesc *desc, int num,
232 Process *p, ThreadContext *tc);
233
234// Target rmdir() handler.
235SyscallReturn rmdirFunc(SyscallDesc *desc, int num,
236 Process *p, ThreadContext *tc);
237
238/// Target rename() handler.
239SyscallReturn renameFunc(SyscallDesc *desc, int num,
240 Process *p, ThreadContext *tc);
241
242
243/// Target truncate() handler.
244SyscallReturn truncateFunc(SyscallDesc *desc, int num,
245 Process *p, ThreadContext *tc);
246
247
248/// Target ftruncate() handler.
249SyscallReturn ftruncateFunc(SyscallDesc *desc, int num,
250 Process *p, ThreadContext *tc);
251
252
253/// Target truncate64() handler.
254SyscallReturn truncate64Func(SyscallDesc *desc, int num,
255 Process *p, ThreadContext *tc);
256
257/// Target ftruncate64() handler.
258SyscallReturn ftruncate64Func(SyscallDesc *desc, int num,
259 Process *p, ThreadContext *tc);
260
261
262/// Target umask() handler.
263SyscallReturn umaskFunc(SyscallDesc *desc, int num,
264 Process *p, ThreadContext *tc);
265
266/// Target gettid() handler.
267SyscallReturn gettidFunc(SyscallDesc *desc, int num,
268 Process *p, ThreadContext *tc);
269
270/// Target chown() handler.
271SyscallReturn chownFunc(SyscallDesc *desc, int num,
272 Process *p, ThreadContext *tc);
273
274/// Target setpgid() handler.
275SyscallReturn setpgidFunc(SyscallDesc *desc, int num,
276 Process *p, ThreadContext *tc);
277
278/// Target fchown() handler.
279SyscallReturn fchownFunc(SyscallDesc *desc, int num,
280 Process *p, ThreadContext *tc);
281
282/// Target dup() handler.
283SyscallReturn dupFunc(SyscallDesc *desc, int num,
284 Process *process, ThreadContext *tc);
285
286/// Target dup2() handler.
287SyscallReturn dup2Func(SyscallDesc *desc, int num,
288 Process *process, ThreadContext *tc);
289
290/// Target fcntl() handler.
291SyscallReturn fcntlFunc(SyscallDesc *desc, int num,
292 Process *process, ThreadContext *tc);
293
294/// Target fcntl64() handler.
295SyscallReturn fcntl64Func(SyscallDesc *desc, int num,
296 Process *process, ThreadContext *tc);
297
298/// Target setuid() handler.
299SyscallReturn setuidFunc(SyscallDesc *desc, int num,
300 Process *p, ThreadContext *tc);
301
302/// Target pipe() handler.
303SyscallReturn pipeFunc(SyscallDesc *desc, int num,
304 Process *p, ThreadContext *tc);
305
306/// Internal pipe() handler.
307SyscallReturn pipeImpl(SyscallDesc *desc, int num, Process *p,
308 ThreadContext *tc, bool pseudoPipe);
309
310/// Target getpid() handler.
311SyscallReturn getpidFunc(SyscallDesc *desc, int num,
312 Process *p, ThreadContext *tc);
313
314// Target getpeername() handler.
315SyscallReturn getpeernameFunc(SyscallDesc *desc, int num,
316 Process *p, ThreadContext *tc);
317
318// Target bind() handler.
319SyscallReturn bindFunc(SyscallDesc *desc, int num,
320 Process *p, ThreadContext *tc);
321
322// Target listen() handler.
323SyscallReturn listenFunc(SyscallDesc *desc, int num,
324 Process *p, ThreadContext *tc);
325
326// Target connect() handler.
327SyscallReturn connectFunc(SyscallDesc *desc, int num,
328 Process *p, ThreadContext *tc);
329
330#if defined(SYS_getdents)
331// Target getdents() handler.
332SyscallReturn getdentsFunc(SyscallDesc *desc, int num,
333 Process *p, ThreadContext *tc);
334#endif
335
336#if defined(SYS_getdents64)
337// Target getdents() handler.
338SyscallReturn getdents64Func(SyscallDesc *desc, int num,
339 Process *p, ThreadContext *tc);
340#endif
341
342// Target sendto() handler.
343SyscallReturn sendtoFunc(SyscallDesc *desc, int num,
344 Process *p, ThreadContext *tc);
345
346// Target recvfrom() handler.
347SyscallReturn recvfromFunc(SyscallDesc *desc, int num,
348 Process *p, ThreadContext *tc);
349
350// Target recvmsg() handler.
351SyscallReturn recvmsgFunc(SyscallDesc *desc, int num,
352 Process *p, ThreadContext *tc);
353
354// Target sendmsg() handler.
355SyscallReturn sendmsgFunc(SyscallDesc *desc, int num,
356 Process *p, ThreadContext *tc);
357
358// Target getuid() handler.
359SyscallReturn getuidFunc(SyscallDesc *desc, int num,
360 Process *p, ThreadContext *tc);
361
362/// Target getgid() handler.
363SyscallReturn getgidFunc(SyscallDesc *desc, int num,
364 Process *p, ThreadContext *tc);
365
366/// Target getppid() handler.
367SyscallReturn getppidFunc(SyscallDesc *desc, int num,
368 Process *p, ThreadContext *tc);
369
370/// Target geteuid() handler.
371SyscallReturn geteuidFunc(SyscallDesc *desc, int num,
372 Process *p, ThreadContext *tc);
373
374/// Target getegid() handler.
375SyscallReturn getegidFunc(SyscallDesc *desc, int num,
376 Process *p, ThreadContext *tc);
377
378/// Target access() handler
379SyscallReturn accessFunc(SyscallDesc *desc, int num,
380 Process *p, ThreadContext *tc);
381SyscallReturn accessFunc(SyscallDesc *desc, int num,
382 Process *p, ThreadContext *tc,
383 int index);
384
385// Target getsockopt() handler.
386SyscallReturn getsockoptFunc(SyscallDesc *desc, int num,
387 Process *p, ThreadContext *tc);
388
389// Target setsockopt() handler.
390SyscallReturn setsockoptFunc(SyscallDesc *desc, int num,
391 Process *p, ThreadContext *tc);
392
393// Target getsockname() handler.
394SyscallReturn getsocknameFunc(SyscallDesc *desc, int num,
395 Process *p, ThreadContext *tc);
396
397/// Futex system call
398/// Implemented by Daniel Sanchez
399/// Used by printf's in multi-threaded apps
400template <class OS>
401SyscallReturn
402futexFunc(SyscallDesc *desc, int callnum, Process *process,
403 ThreadContext *tc)
404{
405 using namespace std;
406
407 int index = 0;
408 Addr uaddr = process->getSyscallArg(tc, index);
409 int op = process->getSyscallArg(tc, index);
410 int val = process->getSyscallArg(tc, index);
411 int timeout M5_VAR_USED = process->getSyscallArg(tc, index);
412 Addr uaddr2 M5_VAR_USED = process->getSyscallArg(tc, index);
413 int val3 = process->getSyscallArg(tc, index);
414
415 /*
416 * Unsupported option that does not affect the correctness of the
417 * application. This is a performance optimization utilized by Linux.
418 */
419 op &= ~OS::TGT_FUTEX_PRIVATE_FLAG;
420 op &= ~OS::TGT_FUTEX_CLOCK_REALTIME_FLAG;
421
422 FutexMap &futex_map = tc->getSystemPtr()->futexMap;
423
424 if (OS::TGT_FUTEX_WAIT == op || OS::TGT_FUTEX_WAIT_BITSET == op) {
425 // Ensure futex system call accessed atomically.
426 BufferArg buf(uaddr, sizeof(int));
427 buf.copyIn(tc->getMemProxy());
428 int mem_val = *(int*)buf.bufferPtr();
429
430 /*
431 * The value in memory at uaddr is not equal with the expected val
432 * (a different thread must have changed it before the system call was
433 * invoked). In this case, we need to throw an error.
434 */
435 if (val != mem_val)
436 return -OS::TGT_EWOULDBLOCK;
437
438 if (OS::TGT_FUTEX_WAIT) {
439 futex_map.suspend(uaddr, process->tgid(), tc);
440 } else {
441 futex_map.suspend_bitset(uaddr, process->tgid(), tc, val3);
442 }
443
444 return 0;
445 } else if (OS::TGT_FUTEX_WAKE == op) {
446 return futex_map.wakeup(uaddr, process->tgid(), val);
447 } else if (OS::TGT_FUTEX_WAKE_BITSET == op) {
448 return futex_map.wakeup_bitset(uaddr, process->tgid(), val3);
449 } else if (OS::TGT_FUTEX_REQUEUE == op ||
450 OS::TGT_FUTEX_CMP_REQUEUE == op) {
451
452 // Ensure futex system call accessed atomically.
453 BufferArg buf(uaddr, sizeof(int));
454 buf.copyIn(tc->getMemProxy());
455 int mem_val = *(int*)buf.bufferPtr();
456 /*
457 * For CMP_REQUEUE, the whole operation is only started only if
458 * val3 is still the value of the futex pointed to by uaddr.
459 */
460 if (OS::TGT_FUTEX_CMP_REQUEUE && val3 != mem_val)
461 return -OS::TGT_EWOULDBLOCK;
462 return futex_map.requeue(uaddr, process->tgid(), val, timeout, uaddr2);
463 } else if (OS::TGT_FUTEX_WAKE_OP == op) {
464 /*
465 * The FUTEX_WAKE_OP operation is equivalent to executing the
466 * following code atomically and totally ordered with respect to
467 * other futex operations on any of the two supplied futex words:
468 *
469 * int oldval = *(int *) addr2;
470 * *(int *) addr2 = oldval op oparg;
471 * futex(addr1, FUTEX_WAKE, val, 0, 0, 0);
472 * if (oldval cmp cmparg)
473 * futex(addr2, FUTEX_WAKE, val2, 0, 0, 0);
474 *
475 * (op, oparg, cmp, cmparg are encoded in val3)
476 *
477 * +---+---+-----------+-----------+
478 * |op |cmp| oparg | cmparg |
479 * +---+---+-----------+-----------+
480 * 4 4 12 12 <== # of bits
481 *
482 * reference: http://man7.org/linux/man-pages/man2/futex.2.html
483 *
484 */
485 // get value from simulated-space
486 BufferArg buf(uaddr2, sizeof(int));
487 buf.copyIn(tc->getMemProxy());
488 int oldval = *(int*)buf.bufferPtr();
489 int newval = oldval;
490 // extract op, oparg, cmp, cmparg from val3
491 int wake_cmparg = val3 & 0xfff;
492 int wake_oparg = (val3 & 0xfff000) >> 12;
493 int wake_cmp = (val3 & 0xf000000) >> 24;
494 int wake_op = (val3 & 0xf0000000) >> 28;
495 if ((wake_op & OS::TGT_FUTEX_OP_ARG_SHIFT) >> 3 == 1)
496 wake_oparg = (1 << wake_oparg);
497 wake_op &= ~OS::TGT_FUTEX_OP_ARG_SHIFT;
498 // perform operation on the value of the second futex
499 if (wake_op == OS::TGT_FUTEX_OP_SET)
500 newval = wake_oparg;
501 else if (wake_op == OS::TGT_FUTEX_OP_ADD)
502 newval += wake_oparg;
503 else if (wake_op == OS::TGT_FUTEX_OP_OR)
504 newval |= wake_oparg;
505 else if (wake_op == OS::TGT_FUTEX_OP_ANDN)
506 newval &= ~wake_oparg;
507 else if (wake_op == OS::TGT_FUTEX_OP_XOR)
508 newval ^= wake_oparg;
509 // copy updated value back to simulated-space
510 *(int*)buf.bufferPtr() = newval;
511 buf.copyOut(tc->getMemProxy());
512 // perform the first wake-up
513 int woken1 = futex_map.wakeup(uaddr, process->tgid(), val);
514 int woken2 = 0;
515 // calculate the condition of the second wake-up
516 bool is_wake2 = false;
517 if (wake_cmp == OS::TGT_FUTEX_OP_CMP_EQ)
518 is_wake2 = oldval == wake_cmparg;
519 else if (wake_cmp == OS::TGT_FUTEX_OP_CMP_NE)
520 is_wake2 = oldval != wake_cmparg;
521 else if (wake_cmp == OS::TGT_FUTEX_OP_CMP_LT)
522 is_wake2 = oldval < wake_cmparg;
523 else if (wake_cmp == OS::TGT_FUTEX_OP_CMP_LE)
524 is_wake2 = oldval <= wake_cmparg;
525 else if (wake_cmp == OS::TGT_FUTEX_OP_CMP_GT)
526 is_wake2 = oldval > wake_cmparg;
527 else if (wake_cmp == OS::TGT_FUTEX_OP_CMP_GE)
528 is_wake2 = oldval >= wake_cmparg;
529 // perform the second wake-up
530 if (is_wake2)
531 woken2 = futex_map.wakeup(uaddr2, process->tgid(), timeout);
532
533 return woken1 + woken2;
534 }
535 warn("futex: op %d not implemented; ignoring.", op);
536 return -ENOSYS;
537}
538
539
540/// Pseudo Funcs - These functions use a different return convension,
541/// returning a second value in a register other than the normal return register
542SyscallReturn pipePseudoFunc(SyscallDesc *desc, int num,
543 Process *process, ThreadContext *tc);
544
545/// Target getpidPseudo() handler.
546SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num,
547 Process *p, ThreadContext *tc);
548
549/// Target getuidPseudo() handler.
550SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num,
551 Process *p, ThreadContext *tc);
552
553/// Target getgidPseudo() handler.
554SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num,
555 Process *p, ThreadContext *tc);
556
557
558/// A readable name for 1,000,000, for converting microseconds to seconds.
559const int one_million = 1000000;
560/// A readable name for 1,000,000,000, for converting nanoseconds to seconds.
561const int one_billion = 1000000000;
562
563/// Approximate seconds since the epoch (1/1/1970). About a billion,
564/// by my reckoning. We want to keep this a constant (not use the
565/// real-world time) to keep simulations repeatable.
566const unsigned seconds_since_epoch = 1000000000;
567
568/// Helper function to convert current elapsed time to seconds and
569/// microseconds.
570template <class T1, class T2>
571void
572getElapsedTimeMicro(T1 &sec, T2 &usec)
573{
574 uint64_t elapsed_usecs = curTick() / SimClock::Int::us;
575 sec = elapsed_usecs / one_million;
576 usec = elapsed_usecs % one_million;
577}
578
579/// Helper function to convert current elapsed time to seconds and
580/// nanoseconds.
581template <class T1, class T2>
582void
583getElapsedTimeNano(T1 &sec, T2 &nsec)
584{
585 uint64_t elapsed_nsecs = curTick() / SimClock::Int::ns;
586 sec = elapsed_nsecs / one_billion;
587 nsec = elapsed_nsecs % one_billion;
588}
589
590//////////////////////////////////////////////////////////////////////
591//
592// The following emulation functions are generic, but need to be
593// templated to account for differences in types, constants, etc.
594//
595//////////////////////////////////////////////////////////////////////
596
597 typedef struct statfs hst_statfs;
598#if NO_STAT64
599 typedef struct stat hst_stat;
600 typedef struct stat hst_stat64;
601#else
602 typedef struct stat hst_stat;
603 typedef struct stat64 hst_stat64;
604#endif
605
606//// Helper function to convert a host stat buffer to a target stat
607//// buffer. Also copies the target buffer out to the simulated
608//// memory space. Used by stat(), fstat(), and lstat().
609
610template <typename target_stat, typename host_stat>
611void
612convertStatBuf(target_stat &tgt, host_stat *host, bool fakeTTY = false)
613{
614 using namespace TheISA;
615
616 if (fakeTTY)
617 tgt->st_dev = 0xA;
618 else
619 tgt->st_dev = host->st_dev;
620 tgt->st_dev = TheISA::htog(tgt->st_dev);
621 tgt->st_ino = host->st_ino;
622 tgt->st_ino = TheISA::htog(tgt->st_ino);
623 tgt->st_mode = host->st_mode;
624 if (fakeTTY) {
625 // Claim to be a character device
626 tgt->st_mode &= ~S_IFMT; // Clear S_IFMT
627 tgt->st_mode |= S_IFCHR; // Set S_IFCHR
628 }
629 tgt->st_mode = TheISA::htog(tgt->st_mode);
630 tgt->st_nlink = host->st_nlink;
631 tgt->st_nlink = TheISA::htog(tgt->st_nlink);
632 tgt->st_uid = host->st_uid;
633 tgt->st_uid = TheISA::htog(tgt->st_uid);
634 tgt->st_gid = host->st_gid;
635 tgt->st_gid = TheISA::htog(tgt->st_gid);
636 if (fakeTTY)
637 tgt->st_rdev = 0x880d;
638 else
639 tgt->st_rdev = host->st_rdev;
640 tgt->st_rdev = TheISA::htog(tgt->st_rdev);
641 tgt->st_size = host->st_size;
642 tgt->st_size = TheISA::htog(tgt->st_size);
643 tgt->st_atimeX = host->st_atime;
644 tgt->st_atimeX = TheISA::htog(tgt->st_atimeX);
645 tgt->st_mtimeX = host->st_mtime;
646 tgt->st_mtimeX = TheISA::htog(tgt->st_mtimeX);
647 tgt->st_ctimeX = host->st_ctime;
648 tgt->st_ctimeX = TheISA::htog(tgt->st_ctimeX);
649 // Force the block size to be 8KB. This helps to ensure buffered io works
650 // consistently across different hosts.
651 tgt->st_blksize = 0x2000;
652 tgt->st_blksize = TheISA::htog(tgt->st_blksize);
653 tgt->st_blocks = host->st_blocks;
654 tgt->st_blocks = TheISA::htog(tgt->st_blocks);
655}
656
657// Same for stat64
658
659template <typename target_stat, typename host_stat64>
660void
661convertStat64Buf(target_stat &tgt, host_stat64 *host, bool fakeTTY = false)
662{
663 using namespace TheISA;
664
665 convertStatBuf<target_stat, host_stat64>(tgt, host, fakeTTY);
666#if defined(STAT_HAVE_NSEC)
667 tgt->st_atime_nsec = host->st_atime_nsec;
668 tgt->st_atime_nsec = TheISA::htog(tgt->st_atime_nsec);
669 tgt->st_mtime_nsec = host->st_mtime_nsec;
670 tgt->st_mtime_nsec = TheISA::htog(tgt->st_mtime_nsec);
671 tgt->st_ctime_nsec = host->st_ctime_nsec;
672 tgt->st_ctime_nsec = TheISA::htog(tgt->st_ctime_nsec);
673#else
674 tgt->st_atime_nsec = 0;
675 tgt->st_mtime_nsec = 0;
676 tgt->st_ctime_nsec = 0;
677#endif
678}
679
680// Here are a couple of convenience functions
681template<class OS>
682void
683copyOutStatBuf(SETranslatingPortProxy &mem, Addr addr,
684 hst_stat *host, bool fakeTTY = false)
685{
686 typedef TypedBufferArg<typename OS::tgt_stat> tgt_stat_buf;
687 tgt_stat_buf tgt(addr);
688 convertStatBuf<tgt_stat_buf, hst_stat>(tgt, host, fakeTTY);
689 tgt.copyOut(mem);
690}
691
692template<class OS>
693void
694copyOutStat64Buf(SETranslatingPortProxy &mem, Addr addr,
695 hst_stat64 *host, bool fakeTTY = false)
696{
697 typedef TypedBufferArg<typename OS::tgt_stat64> tgt_stat_buf;
698 tgt_stat_buf tgt(addr);
699 convertStat64Buf<tgt_stat_buf, hst_stat64>(tgt, host, fakeTTY);
700 tgt.copyOut(mem);
701}
702
703template <class OS>
704void
705copyOutStatfsBuf(SETranslatingPortProxy &mem, Addr addr,
706 hst_statfs *host)
707{
708 TypedBufferArg<typename OS::tgt_statfs> tgt(addr);
709
710 tgt->f_type = TheISA::htog(host->f_type);
711#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
712 tgt->f_bsize = TheISA::htog(host->f_iosize);
713#else
714 tgt->f_bsize = TheISA::htog(host->f_bsize);
715#endif
716 tgt->f_blocks = TheISA::htog(host->f_blocks);
717 tgt->f_bfree = TheISA::htog(host->f_bfree);
718 tgt->f_bavail = TheISA::htog(host->f_bavail);
719 tgt->f_files = TheISA::htog(host->f_files);
720 tgt->f_ffree = TheISA::htog(host->f_ffree);
721 memcpy(&tgt->f_fsid, &host->f_fsid, sizeof(host->f_fsid));
722#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
723 tgt->f_namelen = TheISA::htog(host->f_namemax);
724 tgt->f_frsize = TheISA::htog(host->f_bsize);
725#elif defined(__APPLE__)
726 tgt->f_namelen = 0;
727 tgt->f_frsize = 0;
728#else
729 tgt->f_namelen = TheISA::htog(host->f_namelen);
730 tgt->f_frsize = TheISA::htog(host->f_frsize);
731#endif
732#if defined(__linux__)
733 memcpy(&tgt->f_spare, &host->f_spare, sizeof(host->f_spare));
734#else
735 /*
736 * The fields are different sizes per OS. Don't bother with
737 * f_spare or f_reserved on non-Linux for now.
738 */
739 memset(&tgt->f_spare, 0, sizeof(tgt->f_spare));
740#endif
741
742 tgt.copyOut(mem);
743}
744
745/// Target ioctl() handler. For the most part, programs call ioctl()
746/// only to find out if their stdout is a tty, to determine whether to
747/// do line or block buffering. We always claim that output fds are
748/// not TTYs to provide repeatable results.
749template <class OS>
750SyscallReturn
751ioctlFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
752{
753 int index = 0;
754 int tgt_fd = p->getSyscallArg(tc, index);
755 unsigned req = p->getSyscallArg(tc, index);
756
757 DPRINTF_SYSCALL(Verbose, "ioctl(%d, 0x%x, ...)\n", tgt_fd, req);
758
759 if (OS::isTtyReq(req))
760 return -ENOTTY;
761
762 auto dfdp = std::dynamic_pointer_cast<DeviceFDEntry>((*p->fds)[tgt_fd]);
763 if (dfdp) {
764 EmulatedDriver *emul_driver = dfdp->getDriver();
765 if (emul_driver)
766 return emul_driver->ioctl(p, tc, req);
767 }
768
769 auto sfdp = std::dynamic_pointer_cast<SocketFDEntry>((*p->fds)[tgt_fd]);
770 if (sfdp) {
771 int status;
772
773 switch (req) {
774 case SIOCGIFCONF: {
775 Addr conf_addr = p->getSyscallArg(tc, index);
776 BufferArg conf_arg(conf_addr, sizeof(ifconf));
777 conf_arg.copyIn(tc->getMemProxy());
778
779 ifconf *conf = (ifconf*)conf_arg.bufferPtr();
780 Addr ifc_buf_addr = (Addr)conf->ifc_buf;
781 BufferArg ifc_buf_arg(ifc_buf_addr, conf->ifc_len);
782 ifc_buf_arg.copyIn(tc->getMemProxy());
783
784 conf->ifc_buf = (char*)ifc_buf_arg.bufferPtr();
785
786 status = ioctl(sfdp->getSimFD(), req, conf_arg.bufferPtr());
787 if (status != -1) {
788 conf->ifc_buf = (char*)ifc_buf_addr;
789 ifc_buf_arg.copyOut(tc->getMemProxy());
790 conf_arg.copyOut(tc->getMemProxy());
791 }
792
793 return status;
794 }
795 case SIOCGIFFLAGS:
796#ifdef __linux__
797 case SIOCGIFINDEX:
798#endif
799 case SIOCGIFNETMASK:
800 case SIOCGIFADDR:
801#ifdef __linux__
802 case SIOCGIFHWADDR:
803#endif
804 case SIOCGIFMTU: {
805 Addr req_addr = p->getSyscallArg(tc, index);
806 BufferArg req_arg(req_addr, sizeof(ifreq));
807 req_arg.copyIn(tc->getMemProxy());
808
809 status = ioctl(sfdp->getSimFD(), req, req_arg.bufferPtr());
810 if (status != -1)
811 req_arg.copyOut(tc->getMemProxy());
812 return status;
813 }
814 }
815 }
816
817 /**
818 * For lack of a better return code, return ENOTTY. Ideally, we should
819 * return something better here, but at least we issue the warning.
820 */
821 warn("Unsupported ioctl call (return ENOTTY): ioctl(%d, 0x%x, ...) @ \n",
822 tgt_fd, req, tc->pcState());
823 return -ENOTTY;
824}
825
826template <class OS>
827SyscallReturn
828openImpl(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc,
829 bool isopenat)
830{
831 int index = 0;
832 int tgt_dirfd = -1;
833
834 /**
835 * If using the openat variant, read in the target directory file
836 * descriptor from the simulated process.
837 */
838 if (isopenat)
839 tgt_dirfd = p->getSyscallArg(tc, index);
840
841 /**
842 * Retrieve the simulated process' memory proxy and then read in the path
843 * string from that memory space into the host's working memory space.
844 */
845 std::string path;
846 if (!tc->getMemProxy().tryReadString(path, p->getSyscallArg(tc, index)))
847 return -EFAULT;
848
849#ifdef __CYGWIN32__
850 int host_flags = O_BINARY;
851#else
852 int host_flags = 0;
853#endif
854 /**
855 * Translate target flags into host flags. Flags exist which are not
856 * ported between architectures which can cause check failures.
857 */
858 int tgt_flags = p->getSyscallArg(tc, index);
859 for (int i = 0; i < OS::NUM_OPEN_FLAGS; i++) {
860 if (tgt_flags & OS::openFlagTable[i].tgtFlag) {
861 tgt_flags &= ~OS::openFlagTable[i].tgtFlag;
862 host_flags |= OS::openFlagTable[i].hostFlag;
863 }
864 }
865 if (tgt_flags) {
866 warn("open%s: cannot decode flags 0x%x",
867 isopenat ? "at" : "", tgt_flags);
868 }
869#ifdef __CYGWIN32__
870 host_flags |= O_BINARY;
871#endif
872
873 int mode = p->getSyscallArg(tc, index);
874
875 /**
876 * If the simulated process called open or openat with AT_FDCWD specified,
877 * take the current working directory value which was passed into the
878 * process class as a Python parameter and append the current path to
879 * create a full path.
880 * Otherwise, openat with a valid target directory file descriptor has
881 * been called. If the path option, which was passed in as a parameter,
882 * is not absolute, retrieve the directory file descriptor's path and
883 * prepend it to the path passed in as a parameter.
884 * In every case, we should have a full path (which is relevant to the
885 * host) to work with after this block has been passed.
886 */
887 std::string redir_path = path;
888 std::string abs_path = path;
889 if (!isopenat || tgt_dirfd == OS::TGT_AT_FDCWD) {
890 abs_path = p->absolutePath(path, true);
891 redir_path = p->checkPathRedirect(path);
892 } else if (!startswith(path, "/")) {
893 std::shared_ptr<FDEntry> fdep = ((*p->fds)[tgt_dirfd]);
894 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>(fdep);
895 if (!ffdp)
896 return -EBADF;
897 abs_path = ffdp->getFileName() + path;
898 redir_path = p->checkPathRedirect(abs_path);
899 }
900
901 /**
902 * Since this is an emulated environment, we create pseudo file
903 * descriptors for device requests that have been registered with
904 * the process class through Python; this allows us to create a file
905 * descriptor for subsequent ioctl or mmap calls.
906 */
907 if (startswith(abs_path, "/dev/")) {
908 std::string filename = abs_path.substr(strlen("/dev/"));
909 EmulatedDriver *drv = p->findDriver(filename);
910 if (drv) {
911 DPRINTF_SYSCALL(Verbose, "open%s: passing call to "
912 "driver open with path[%s]\n",
913 isopenat ? "at" : "", abs_path.c_str());
914 return drv->open(p, tc, mode, host_flags);
915 }
916 /**
917 * Fall through here for pass through to host devices, such
918 * as /dev/zero
919 */
920 }
921
922 /**
923 * We make several attempts resolve a call to open.
924 *
925 * 1) Resolve any path redirection before hand. This will set the path
926 * up with variable 'redir_path' which may contain a modified path or
927 * the original path value. This should already be done in prior code.
928 * 2) Try to handle the access using 'special_paths'. Some special_paths
929 * and files cannot be called on the host and need to be handled as
930 * special cases inside the simulator. These special_paths are handled by
931 * C++ routines to provide output back to userspace.
932 * 3) If the full path that was created above does not match any of the
933 * special cases, pass it through to the open call on the __HOST__ to let
934 * the host open the file on our behalf. Again, the openImpl tries to
935 * USE_THE_HOST_FILESYSTEM_OPEN (with a possible redirection to the
936 * faux-filesystem files). The faux-filesystem is dynamically created
937 * during simulator configuration using Python functions.
938 * 4) If the host cannot open the file, the open attempt failed in "3)".
939 * Return the host's error code back through the system call to the
940 * simulated process. If running a debug trace, also notify the user that
941 * the open call failed.
942 *
943 * Any success will set sim_fd to something other than -1 and skip the
944 * next conditions effectively bypassing them.
945 */
946 int sim_fd = -1;
947 std::string used_path;
948 std::vector<std::string> special_paths =
949 { "/proc/meminfo/", "/system/", "/sys/", "/platform/",
950 "/etc/passwd" };
951 for (auto entry : special_paths) {
952 if (startswith(path, entry)) {
953 sim_fd = OS::openSpecialFile(abs_path, p, tc);
954 used_path = abs_path;
955 }
956 }
957 if (sim_fd == -1) {
958 sim_fd = open(redir_path.c_str(), host_flags, mode);
959 used_path = redir_path;
960 }
961 if (sim_fd == -1) {
962 int local = -errno;
963 DPRINTF_SYSCALL(Verbose, "open%s: failed -> path:%s "
964 "(inferred from:%s)\n", isopenat ? "at" : "",
965 used_path.c_str(), path.c_str());
966 return local;
967 }
968
969 /**
970 * The file was opened successfully and needs to be recorded in the
971 * process' file descriptor array so that it can be retrieved later.
972 * The target file descriptor that is chosen will be the lowest unused
973 * file descriptor.
974 * Return the indirect target file descriptor back to the simulated
975 * process to act as a handle for the opened file.
976 */
977 auto ffdp = std::make_shared<FileFDEntry>(sim_fd, host_flags, path, 0);
978 int tgt_fd = p->fds->allocFD(ffdp);
979 DPRINTF_SYSCALL(Verbose, "open%s: sim_fd[%d], target_fd[%d] -> path:%s\n"
980 "(inferred from:%s)\n", isopenat ? "at" : "",
981 sim_fd, tgt_fd, used_path.c_str(), path.c_str());
982 return tgt_fd;
983}
984
985/// Target open() handler.
986template <class OS>
987SyscallReturn
988openFunc(SyscallDesc *desc, int callnum, Process *process,
989 ThreadContext *tc)
990{
991 return openImpl<OS>(desc, callnum, process, tc, false);
992}
993
994/// Target openat() handler.
995template <class OS>
996SyscallReturn
997openatFunc(SyscallDesc *desc, int callnum, Process *process,
998 ThreadContext *tc)
999{
1000 return openImpl<OS>(desc, callnum, process, tc, true);
1001}
1002
1003/// Target unlinkat() handler.
1004template <class OS>
1005SyscallReturn
1006unlinkatFunc(SyscallDesc *desc, int callnum, Process *process,
1007 ThreadContext *tc)
1008{
1009 int index = 0;
1010 int dirfd = process->getSyscallArg(tc, index);
1011 if (dirfd != OS::TGT_AT_FDCWD)
1012 warn("unlinkat: first argument not AT_FDCWD; unlikely to work");
1013
1014 return unlinkHelper(desc, callnum, process, tc, 1);
1015}
1016
1017/// Target facessat() handler
1018template <class OS>
1019SyscallReturn
1020faccessatFunc(SyscallDesc *desc, int callnum, Process *process,
1021 ThreadContext *tc)
1022{
1023 int index = 0;
1024 int dirfd = process->getSyscallArg(tc, index);
1025 if (dirfd != OS::TGT_AT_FDCWD)
1026 warn("faccessat: first argument not AT_FDCWD; unlikely to work");
1027 return accessFunc(desc, callnum, process, tc, 1);
1028}
1029
1030/// Target readlinkat() handler
1031template <class OS>
1032SyscallReturn
1033readlinkatFunc(SyscallDesc *desc, int callnum, Process *process,
1034 ThreadContext *tc)
1035{
1036 int index = 0;
1037 int dirfd = process->getSyscallArg(tc, index);
1038 if (dirfd != OS::TGT_AT_FDCWD)
1039 warn("openat: first argument not AT_FDCWD; unlikely to work");
1040 return readlinkFunc(desc, callnum, process, tc, 1);
1041}
1042
1043/// Target renameat() handler.
1044template <class OS>
1045SyscallReturn
1046renameatFunc(SyscallDesc *desc, int callnum, Process *process,
1047 ThreadContext *tc)
1048{
1049 int index = 0;
1050
1051 int olddirfd = process->getSyscallArg(tc, index);
1052 if (olddirfd != OS::TGT_AT_FDCWD)
1053 warn("renameat: first argument not AT_FDCWD; unlikely to work");
1054
1055 std::string old_name;
1056
1057 if (!tc->getMemProxy().tryReadString(old_name,
1058 process->getSyscallArg(tc, index)))
1059 return -EFAULT;
1060
1061 int newdirfd = process->getSyscallArg(tc, index);
1062 if (newdirfd != OS::TGT_AT_FDCWD)
1063 warn("renameat: third argument not AT_FDCWD; unlikely to work");
1064
1065 std::string new_name;
1066
1067 if (!tc->getMemProxy().tryReadString(new_name,
1068 process->getSyscallArg(tc, index)))
1069 return -EFAULT;
1070
1071 // Adjust path for cwd and redirection
1072 old_name = process->checkPathRedirect(old_name);
1073 new_name = process->checkPathRedirect(new_name);
1074
1075 int result = rename(old_name.c_str(), new_name.c_str());
1076 return (result == -1) ? -errno : result;
1077}
1078
1079/// Target sysinfo() handler.
1080template <class OS>
1081SyscallReturn
1082sysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
1083 ThreadContext *tc)
1084{
1085
1086 int index = 0;
1087 TypedBufferArg<typename OS::tgt_sysinfo>
1088 sysinfo(process->getSyscallArg(tc, index));
1089
1090 sysinfo->uptime = seconds_since_epoch;
1091 sysinfo->totalram = process->system->memSize();
1092 sysinfo->mem_unit = 1;
1093
1094 sysinfo.copyOut(tc->getMemProxy());
1095
1096 return 0;
1097}
1098
1099/// Target chmod() handler.
1100template <class OS>
1101SyscallReturn
1102chmodFunc(SyscallDesc *desc, int callnum, Process *process,
1103 ThreadContext *tc)
1104{
1105 std::string path;
1106
1107 int index = 0;
1108 if (!tc->getMemProxy().tryReadString(path,
1109 process->getSyscallArg(tc, index))) {
1110 return -EFAULT;
1111 }
1112
1113 uint32_t mode = process->getSyscallArg(tc, index);
1114 mode_t hostMode = 0;
1115
1116 // XXX translate mode flags via OS::something???
1117 hostMode = mode;
1118
1119 // Adjust path for cwd and redirection
1120 path = process->checkPathRedirect(path);
1121
1122 // do the chmod
1123 int result = chmod(path.c_str(), hostMode);
1124 if (result < 0)
1125 return -errno;
1126
1127 return 0;
1128}
1129
1130template <class OS>
1131SyscallReturn
1132pollFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
1133{
1134 int index = 0;
1135 Addr fdsPtr = p->getSyscallArg(tc, index);
1136 int nfds = p->getSyscallArg(tc, index);
1137 int tmout = p->getSyscallArg(tc, index);
1138
1139 BufferArg fdsBuf(fdsPtr, sizeof(struct pollfd) * nfds);
1140 fdsBuf.copyIn(tc->getMemProxy());
1141
1142 /**
1143 * Record the target file descriptors in a local variable. We need to
1144 * replace them with host file descriptors but we need a temporary copy
1145 * for later. Afterwards, replace each target file descriptor in the
1146 * poll_fd array with its host_fd.
1147 */
1148 int temp_tgt_fds[nfds];
1149 for (index = 0; index < nfds; index++) {
1150 temp_tgt_fds[index] = ((struct pollfd *)fdsBuf.bufferPtr())[index].fd;
1151 auto tgt_fd = temp_tgt_fds[index];
1152 auto hbfdp = std::dynamic_pointer_cast<HBFDEntry>((*p->fds)[tgt_fd]);
1153 if (!hbfdp)
1154 return -EBADF;
1155 auto host_fd = hbfdp->getSimFD();
1156 ((struct pollfd *)fdsBuf.bufferPtr())[index].fd = host_fd;
1157 }
1158
1159 /**
1160 * We cannot allow an infinite poll to occur or it will inevitably cause
1161 * a deadlock in the gem5 simulator with clone. We must pass in tmout with
1162 * a non-negative value, however it also makes no sense to poll on the
1163 * underlying host for any other time than tmout a zero timeout.
1164 */
1165 int status;
1166 if (tmout < 0) {
1167 status = poll((struct pollfd *)fdsBuf.bufferPtr(), nfds, 0);
1168 if (status == 0) {
1169 /**
1170 * If blocking indefinitely, check the signal list to see if a
1171 * signal would break the poll out of the retry cycle and try
1172 * to return the signal interrupt instead.
1173 */
1174 System *sysh = tc->getSystemPtr();
1175 std::list<BasicSignal>::iterator it;
1176 for (it=sysh->signalList.begin(); it!=sysh->signalList.end(); it++)
1177 if (it->receiver == p)
1178 return -EINTR;
1179 return SyscallReturn::retry();
1180 }
1181 } else
1182 status = poll((struct pollfd *)fdsBuf.bufferPtr(), nfds, 0);
1183
1184 if (status == -1)
1185 return -errno;
1186
1187 /**
1188 * Replace each host_fd in the returned poll_fd array with its original
1189 * target file descriptor.
1190 */
1191 for (index = 0; index < nfds; index++) {
1192 auto tgt_fd = temp_tgt_fds[index];
1193 ((struct pollfd *)fdsBuf.bufferPtr())[index].fd = tgt_fd;
1194 }
1195
1196 /**
1197 * Copy out the pollfd struct because the host may have updated fields
1198 * in the structure.
1199 */
1200 fdsBuf.copyOut(tc->getMemProxy());
1201
1202 return status;
1203}
1204
1205/// Target fchmod() handler.
1206template <class OS>
1207SyscallReturn
1208fchmodFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
1209{
1210 int index = 0;
1211 int tgt_fd = p->getSyscallArg(tc, index);
1212 uint32_t mode = p->getSyscallArg(tc, index);
1213
1214 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>((*p->fds)[tgt_fd]);
1215 if (!ffdp)
1216 return -EBADF;
1217 int sim_fd = ffdp->getSimFD();
1218
1219 mode_t hostMode = mode;
1220
1221 int result = fchmod(sim_fd, hostMode);
1222
1223 return (result < 0) ? -errno : 0;
1224}
1225
1226/// Target mremap() handler.
1227template <class OS>
1228SyscallReturn
1229mremapFunc(SyscallDesc *desc, int callnum, Process *process, ThreadContext *tc)
1230{
1231 int index = 0;
1232 Addr start = process->getSyscallArg(tc, index);
1233 uint64_t old_length = process->getSyscallArg(tc, index);
1234 uint64_t new_length = process->getSyscallArg(tc, index);
1235 uint64_t flags = process->getSyscallArg(tc, index);
1236 uint64_t provided_address = 0;
1237 bool use_provided_address = flags & OS::TGT_MREMAP_FIXED;
1238
1239 if (use_provided_address)
1240 provided_address = process->getSyscallArg(tc, index);
1241
1242 if ((start % TheISA::PageBytes != 0) ||
1243 (provided_address % TheISA::PageBytes != 0)) {
1244 warn("mremap failing: arguments not page aligned");
1245 return -EINVAL;
1246 }
1247
1248 new_length = roundUp(new_length, TheISA::PageBytes);
1249
1250 if (new_length > old_length) {
1251 std::shared_ptr<MemState> mem_state = process->memState;
1252 Addr mmap_end = mem_state->getMmapEnd();
1253
1254 if ((start + old_length) == mmap_end &&
1255 (!use_provided_address || provided_address == start)) {
1256 // This case cannot occur when growing downward, as
1257 // start is greater than or equal to mmap_end.
1258 uint64_t diff = new_length - old_length;
1259 process->allocateMem(mmap_end, diff);
1260 mem_state->setMmapEnd(mmap_end + diff);
1261 return start;
1262 } else {
1263 if (!use_provided_address && !(flags & OS::TGT_MREMAP_MAYMOVE)) {
1264 warn("can't remap here and MREMAP_MAYMOVE flag not set\n");
1265 return -ENOMEM;
1266 } else {
1267 uint64_t new_start = provided_address;
1268 if (!use_provided_address) {
1269 new_start = process->mmapGrowsDown() ?
1270 mmap_end - new_length : mmap_end;
1271 mmap_end = process->mmapGrowsDown() ?
1272 new_start : mmap_end + new_length;
1273 mem_state->setMmapEnd(mmap_end);
1274 }
1275
1276 process->pTable->remap(start, old_length, new_start);
1277 warn("mremapping to new vaddr %08p-%08p, adding %d\n",
1278 new_start, new_start + new_length,
1279 new_length - old_length);
1280 // add on the remaining unallocated pages
1281 process->allocateMem(new_start + old_length,
1282 new_length - old_length,
1283 use_provided_address /* clobber */);
1284 if (use_provided_address &&
1285 ((new_start + new_length > mem_state->getMmapEnd() &&
1286 !process->mmapGrowsDown()) ||
1287 (new_start < mem_state->getMmapEnd() &&
1288 process->mmapGrowsDown()))) {
1289 // something fishy going on here, at least notify the user
1290 // @todo: increase mmap_end?
1291 warn("mmap region limit exceeded with MREMAP_FIXED\n");
1292 }
1293 warn("returning %08p as start\n", new_start);
1294 return new_start;
1295 }
1296 }
1297 } else {
1298 if (use_provided_address && provided_address != start)
1299 process->pTable->remap(start, new_length, provided_address);
1300 process->pTable->unmap(start + new_length, old_length - new_length);
1301 return use_provided_address ? provided_address : start;
1302 }
1303}
1304
1305/// Target stat() handler.
1306template <class OS>
1307SyscallReturn
1308statFunc(SyscallDesc *desc, int callnum, Process *process,
1309 ThreadContext *tc)
1310{
1311 std::string path;
1312
1313 int index = 0;
1314 if (!tc->getMemProxy().tryReadString(path,
1315 process->getSyscallArg(tc, index))) {
1316 return -EFAULT;
1317 }
1318 Addr bufPtr = process->getSyscallArg(tc, index);
1319
1320 // Adjust path for cwd and redirection
1321 path = process->checkPathRedirect(path);
1322
1323 struct stat hostBuf;
1324 int result = stat(path.c_str(), &hostBuf);
1325
1326 if (result < 0)
1327 return -errno;
1328
1329 copyOutStatBuf<OS>(tc->getMemProxy(), bufPtr, &hostBuf);
1330
1331 return 0;
1332}
1333
1334
1335/// Target stat64() handler.
1336template <class OS>
1337SyscallReturn
1338stat64Func(SyscallDesc *desc, int callnum, Process *process,
1339 ThreadContext *tc)
1340{
1341 std::string path;
1342
1343 int index = 0;
1344 if (!tc->getMemProxy().tryReadString(path,
1345 process->getSyscallArg(tc, index)))
1346 return -EFAULT;
1347 Addr bufPtr = process->getSyscallArg(tc, index);
1348
1349 // Adjust path for cwd and redirection
1350 path = process->checkPathRedirect(path);
1351
1352#if NO_STAT64
1353 struct stat hostBuf;
1354 int result = stat(path.c_str(), &hostBuf);
1355#else
1356 struct stat64 hostBuf;
1357 int result = stat64(path.c_str(), &hostBuf);
1358#endif
1359
1360 if (result < 0)
1361 return -errno;
1362
1363 copyOutStat64Buf<OS>(tc->getMemProxy(), bufPtr, &hostBuf);
1364
1365 return 0;
1366}
1367
1368
1369/// Target fstatat64() handler.
1370template <class OS>
1371SyscallReturn
1372fstatat64Func(SyscallDesc *desc, int callnum, Process *process,
1373 ThreadContext *tc)
1374{
1375 int index = 0;
1376 int dirfd = process->getSyscallArg(tc, index);
1377 if (dirfd != OS::TGT_AT_FDCWD)
1378 warn("fstatat64: first argument not AT_FDCWD; unlikely to work");
1379
1380 std::string path;
1381 if (!tc->getMemProxy().tryReadString(path,
1382 process->getSyscallArg(tc, index)))
1383 return -EFAULT;
1384 Addr bufPtr = process->getSyscallArg(tc, index);
1385
1386 // Adjust path for cwd and redirection
1387 path = process->checkPathRedirect(path);
1388
1389#if NO_STAT64
1390 struct stat hostBuf;
1391 int result = stat(path.c_str(), &hostBuf);
1392#else
1393 struct stat64 hostBuf;
1394 int result = stat64(path.c_str(), &hostBuf);
1395#endif
1396
1397 if (result < 0)
1398 return -errno;
1399
1400 copyOutStat64Buf<OS>(tc->getMemProxy(), bufPtr, &hostBuf);
1401
1402 return 0;
1403}
1404
1405
1406/// Target fstat64() handler.
1407template <class OS>
1408SyscallReturn
1409fstat64Func(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
1410{
1411 int index = 0;
1412 int tgt_fd = p->getSyscallArg(tc, index);
1413 Addr bufPtr = p->getSyscallArg(tc, index);
1414
1415 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>((*p->fds)[tgt_fd]);
1416 if (!ffdp)
1417 return -EBADF;
1418 int sim_fd = ffdp->getSimFD();
1419
1420#if NO_STAT64
1421 struct stat hostBuf;
1422 int result = fstat(sim_fd, &hostBuf);
1423#else
1424 struct stat64 hostBuf;
1425 int result = fstat64(sim_fd, &hostBuf);
1426#endif
1427
1428 if (result < 0)
1429 return -errno;
1430
1431 copyOutStat64Buf<OS>(tc->getMemProxy(), bufPtr, &hostBuf, (sim_fd == 1));
1432
1433 return 0;
1434}
1435
1436
1437/// Target lstat() handler.
1438template <class OS>
1439SyscallReturn
1440lstatFunc(SyscallDesc *desc, int callnum, Process *process,
1441 ThreadContext *tc)
1442{
1443 std::string path;
1444
1445 int index = 0;
1446 if (!tc->getMemProxy().tryReadString(path,
1447 process->getSyscallArg(tc, index))) {
1448 return -EFAULT;
1449 }
1450 Addr bufPtr = process->getSyscallArg(tc, index);
1451
1452 // Adjust path for cwd and redirection
1453 path = process->checkPathRedirect(path);
1454
1455 struct stat hostBuf;
1456 int result = lstat(path.c_str(), &hostBuf);
1457
1458 if (result < 0)
1459 return -errno;
1460
1461 copyOutStatBuf<OS>(tc->getMemProxy(), bufPtr, &hostBuf);
1462
1463 return 0;
1464}
1465
1466/// Target lstat64() handler.
1467template <class OS>
1468SyscallReturn
1469lstat64Func(SyscallDesc *desc, int callnum, Process *process,
1470 ThreadContext *tc)
1471{
1472 std::string path;
1473
1474 int index = 0;
1475 if (!tc->getMemProxy().tryReadString(path,
1476 process->getSyscallArg(tc, index))) {
1477 return -EFAULT;
1478 }
1479 Addr bufPtr = process->getSyscallArg(tc, index);
1480
1481 // Adjust path for cwd and redirection
1482 path = process->checkPathRedirect(path);
1483
1484#if NO_STAT64
1485 struct stat hostBuf;
1486 int result = lstat(path.c_str(), &hostBuf);
1487#else
1488 struct stat64 hostBuf;
1489 int result = lstat64(path.c_str(), &hostBuf);
1490#endif
1491
1492 if (result < 0)
1493 return -errno;
1494
1495 copyOutStat64Buf<OS>(tc->getMemProxy(), bufPtr, &hostBuf);
1496
1497 return 0;
1498}
1499
1500/// Target fstat() handler.
1501template <class OS>
1502SyscallReturn
1503fstatFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
1504{
1505 int index = 0;
1506 int tgt_fd = p->getSyscallArg(tc, index);
1507 Addr bufPtr = p->getSyscallArg(tc, index);
1508
1509 DPRINTF_SYSCALL(Verbose, "fstat(%d, ...)\n", tgt_fd);
1510
1511 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>((*p->fds)[tgt_fd]);
1512 if (!ffdp)
1513 return -EBADF;
1514 int sim_fd = ffdp->getSimFD();
1515
1516 struct stat hostBuf;
1517 int result = fstat(sim_fd, &hostBuf);
1518
1519 if (result < 0)
1520 return -errno;
1521
1522 copyOutStatBuf<OS>(tc->getMemProxy(), bufPtr, &hostBuf, (sim_fd == 1));
1523
1524 return 0;
1525}
1526
1527/// Target statfs() handler.
1528template <class OS>
1529SyscallReturn
1530statfsFunc(SyscallDesc *desc, int callnum, Process *process,
1531 ThreadContext *tc)
1532{
1533#if NO_STATFS
1534 warn("Host OS cannot support calls to statfs. Ignoring syscall");
1535#else
1536 std::string path;
1537
1538 int index = 0;
1539 if (!tc->getMemProxy().tryReadString(path,
1540 process->getSyscallArg(tc, index))) {
1541 return -EFAULT;
1542 }
1543 Addr bufPtr = process->getSyscallArg(tc, index);
1544
1545 // Adjust path for cwd and redirection
1546 path = process->checkPathRedirect(path);
1547
1548 struct statfs hostBuf;
1549 int result = statfs(path.c_str(), &hostBuf);
1550
1551 if (result < 0)
1552 return -errno;
1553
1554 copyOutStatfsBuf<OS>(tc->getMemProxy(), bufPtr, &hostBuf);
1555#endif
1556 return 0;
1557}
1558
1559template <class OS>
1560SyscallReturn
1561cloneFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
1562{
1563 int index = 0;
1564
1565 RegVal flags = p->getSyscallArg(tc, index);
1566 RegVal newStack = p->getSyscallArg(tc, index);
1567 Addr ptidPtr = p->getSyscallArg(tc, index);
1568
1569#if THE_ISA == RISCV_ISA or THE_ISA == ARM_ISA
1570 /**
1571 * Linux sets CLONE_BACKWARDS flag for RISC-V and Arm.
1572 * The flag defines the list of clone() arguments in the following
1573 * order: flags -> newStack -> ptidPtr -> tlsPtr -> ctidPtr
1574 */
1575 Addr tlsPtr = p->getSyscallArg(tc, index);
1576 Addr ctidPtr = p->getSyscallArg(tc, index);
1577#else
1578 Addr ctidPtr = p->getSyscallArg(tc, index);
1579 Addr tlsPtr = p->getSyscallArg(tc, index);
1580#endif
1581
1582 if (((flags & OS::TGT_CLONE_SIGHAND)&& !(flags & OS::TGT_CLONE_VM)) ||
1583 ((flags & OS::TGT_CLONE_THREAD) && !(flags & OS::TGT_CLONE_SIGHAND)) ||
1584 ((flags & OS::TGT_CLONE_FS) && (flags & OS::TGT_CLONE_NEWNS)) ||
1585 ((flags & OS::TGT_CLONE_NEWIPC) && (flags & OS::TGT_CLONE_SYSVSEM)) ||
1586 ((flags & OS::TGT_CLONE_NEWPID) && (flags & OS::TGT_CLONE_THREAD)) ||
1587 ((flags & OS::TGT_CLONE_VM) && !(newStack)))
1588 return -EINVAL;
1589
1590 ThreadContext *ctc;
1591 if (!(ctc = p->findFreeContext())) {
1592 DPRINTF_SYSCALL(Verbose, "clone: no spare thread context in system"
1593 "[cpu %d, thread %d]", tc->cpuId(), tc->threadId());
1594 return -EAGAIN;
1595 }
1596
1597 /**
1598 * Note that ProcessParams is generated by swig and there are no other
1599 * examples of how to create anything but this default constructor. The
1600 * fields are manually initialized instead of passing parameters to the
1601 * constructor.
1602 */
1603 ProcessParams *pp = new ProcessParams();
1604 pp->executable.assign(*(new std::string(p->progName())));
1605 pp->cmd.push_back(*(new std::string(p->progName())));
1606 pp->system = p->system;
1607 pp->cwd.assign(p->tgtCwd);
1608 pp->input.assign("stdin");
1609 pp->output.assign("stdout");
1610 pp->errout.assign("stderr");
1611 pp->uid = p->uid();
1612 pp->euid = p->euid();
1613 pp->gid = p->gid();
1614 pp->egid = p->egid();
1615
1616 /* Find the first free PID that's less than the maximum */
1617 std::set<int> const& pids = p->system->PIDs;
1618 int temp_pid = *pids.begin();
1619 do {
1620 temp_pid++;
1621 } while (pids.find(temp_pid) != pids.end());
1622 if (temp_pid >= System::maxPID)
1623 fatal("temp_pid is too large: %d", temp_pid);
1624
1625 pp->pid = temp_pid;
1626 pp->ppid = (flags & OS::TGT_CLONE_THREAD) ? p->ppid() : p->pid();
1627 pp->useArchPT = p->useArchPT;
1628 pp->kvmInSE = p->kvmInSE;
1629 Process *cp = pp->create();
1630 delete pp;
1631
1632 Process *owner = ctc->getProcessPtr();
1633 ctc->setProcessPtr(cp);
1634 cp->assignThreadContext(ctc->contextId());
1635 owner->revokeThreadContext(ctc->contextId());
1636
1637 if (flags & OS::TGT_CLONE_PARENT_SETTID) {
1638 BufferArg ptidBuf(ptidPtr, sizeof(long));
1639 long *ptid = (long *)ptidBuf.bufferPtr();
1640 *ptid = cp->pid();
1641 ptidBuf.copyOut(tc->getMemProxy());
1642 }
1643
1644 if (flags & OS::TGT_CLONE_THREAD) {
1645 cp->pTable->shared = true;
1646 cp->useForClone = true;
1647 }
1648 cp->initState();
1649 p->clone(tc, ctc, cp, flags);
1650
1651 if (flags & OS::TGT_CLONE_THREAD) {
1652 delete cp->sigchld;
1653 cp->sigchld = p->sigchld;
1654 } else if (flags & OS::TGT_SIGCHLD) {
1655 *cp->sigchld = true;
1656 }
1657
1658 if (flags & OS::TGT_CLONE_CHILD_SETTID) {
1659 BufferArg ctidBuf(ctidPtr, sizeof(long));
1660 long *ctid = (long *)ctidBuf.bufferPtr();
1661 *ctid = cp->pid();
1662 ctidBuf.copyOut(ctc->getMemProxy());
1663 }
1664
1665 if (flags & OS::TGT_CLONE_CHILD_CLEARTID)
1666 cp->childClearTID = (uint64_t)ctidPtr;
1667
1668 ctc->clearArchRegs();
1669
1670 OS::archClone(flags, p, cp, tc, ctc, newStack, tlsPtr);
1671
1672 cp->setSyscallReturn(ctc, 0);
1673
1674#if THE_ISA == ALPHA_ISA
1675 ctc->setIntReg(TheISA::SyscallSuccessReg, 0);
1676#elif THE_ISA == SPARC_ISA
1677 tc->setIntReg(TheISA::SyscallPseudoReturnReg, 0);
1678 ctc->setIntReg(TheISA::SyscallPseudoReturnReg, 1);
1679#endif
1680
1681 if (p->kvmInSE) {
1682#if THE_ISA == X86_ISA
1683 ctc->pcState(tc->readIntReg(TheISA::INTREG_RCX));
1684#else
1685 panic("KVM CPU model is not supported for this ISA");
1686#endif
1687 } else {
1688 TheISA::PCState cpc = tc->pcState();
1689 cpc.advance();
1690 ctc->pcState(cpc);
1691 }
1692 ctc->activate();
1693
1694 return cp->pid();
1695}
1696
1697/// Target fstatfs() handler.
1698template <class OS>
1699SyscallReturn
1700fstatfsFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
1701{
1702 int index = 0;
1703 int tgt_fd = p->getSyscallArg(tc, index);
1704 Addr bufPtr = p->getSyscallArg(tc, index);
1705
1706 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>((*p->fds)[tgt_fd]);
1707 if (!ffdp)
1708 return -EBADF;
1709 int sim_fd = ffdp->getSimFD();
1710
1711 struct statfs hostBuf;
1712 int result = fstatfs(sim_fd, &hostBuf);
1713
1714 if (result < 0)
1715 return -errno;
1716
1717 copyOutStatfsBuf<OS>(tc->getMemProxy(), bufPtr, &hostBuf);
1718
1719 return 0;
1720}
1721
1722/// Target readv() handler.
1723template <class OS>
1724SyscallReturn
1725readvFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
1726{
1727 int index = 0;
1728 int tgt_fd = p->getSyscallArg(tc, index);
1729
1730 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>((*p->fds)[tgt_fd]);
1731 if (!ffdp)
1732 return -EBADF;
1733 int sim_fd = ffdp->getSimFD();
1734
1735 SETranslatingPortProxy &prox = tc->getMemProxy();
1736 uint64_t tiov_base = p->getSyscallArg(tc, index);
1737 size_t count = p->getSyscallArg(tc, index);
1738 typename OS::tgt_iovec tiov[count];
1739 struct iovec hiov[count];
1740 for (size_t i = 0; i < count; ++i) {
1741 prox.readBlob(tiov_base + (i * sizeof(typename OS::tgt_iovec)),
1742 (uint8_t*)&tiov[i], sizeof(typename OS::tgt_iovec));
1743 hiov[i].iov_len = TheISA::gtoh(tiov[i].iov_len);
1744 hiov[i].iov_base = new char [hiov[i].iov_len];
1745 }
1746
1747 int result = readv(sim_fd, hiov, count);
1748 int local_errno = errno;
1749
1750 for (size_t i = 0; i < count; ++i) {
1751 if (result != -1) {
1752 prox.writeBlob(TheISA::htog(tiov[i].iov_base),
1753 (uint8_t*)hiov[i].iov_base, hiov[i].iov_len);
1754 }
1755 delete [] (char *)hiov[i].iov_base;
1756 }
1757
1758 return (result == -1) ? -local_errno : result;
1759}
1760
1761/// Target writev() handler.
1762template <class OS>
1763SyscallReturn
1764writevFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
1765{
1766 int index = 0;
1767 int tgt_fd = p->getSyscallArg(tc, index);
1768
1769 auto hbfdp = std::dynamic_pointer_cast<HBFDEntry>((*p->fds)[tgt_fd]);
1770 if (!hbfdp)
1771 return -EBADF;
1772 int sim_fd = hbfdp->getSimFD();
1773
1774 SETranslatingPortProxy &prox = tc->getMemProxy();
1775 uint64_t tiov_base = p->getSyscallArg(tc, index);
1776 size_t count = p->getSyscallArg(tc, index);
1777 struct iovec hiov[count];
1778 for (size_t i = 0; i < count; ++i) {
1779 typename OS::tgt_iovec tiov;
1780
1781 prox.readBlob(tiov_base + i*sizeof(typename OS::tgt_iovec),
1782 (uint8_t*)&tiov, sizeof(typename OS::tgt_iovec));
1783 hiov[i].iov_len = TheISA::gtoh(tiov.iov_len);
1784 hiov[i].iov_base = new char [hiov[i].iov_len];
1785 prox.readBlob(TheISA::gtoh(tiov.iov_base), (uint8_t *)hiov[i].iov_base,
1786 hiov[i].iov_len);
1787 }
1788
1789 int result = writev(sim_fd, hiov, count);
1790
1791 for (size_t i = 0; i < count; ++i)
1792 delete [] (char *)hiov[i].iov_base;
1793
1794 return (result == -1) ? -errno : result;
1795}
1796
1797/// Real mmap handler.
1798template <class OS>
1799SyscallReturn
1800mmapImpl(SyscallDesc *desc, int num, Process *p, ThreadContext *tc,
1801 bool is_mmap2)
1802{
1803 int index = 0;
1804 Addr start = p->getSyscallArg(tc, index);
1805 uint64_t length = p->getSyscallArg(tc, index);
1806 int prot = p->getSyscallArg(tc, index);
1807 int tgt_flags = p->getSyscallArg(tc, index);
1808 int tgt_fd = p->getSyscallArg(tc, index);
1809 int offset = p->getSyscallArg(tc, index);
1810
1811 if (is_mmap2)
1812 offset *= TheISA::PageBytes;
1813
1814 if (start & (TheISA::PageBytes - 1) ||
1815 offset & (TheISA::PageBytes - 1) ||
1816 (tgt_flags & OS::TGT_MAP_PRIVATE &&
1817 tgt_flags & OS::TGT_MAP_SHARED) ||
1818 (!(tgt_flags & OS::TGT_MAP_PRIVATE) &&
1819 !(tgt_flags & OS::TGT_MAP_SHARED)) ||
1820 !length) {
1821 return -EINVAL;
1822 }
1823
1824 if ((prot & PROT_WRITE) && (tgt_flags & OS::TGT_MAP_SHARED)) {
1825 // With shared mmaps, there are two cases to consider:
1826 // 1) anonymous: writes should modify the mapping and this should be
1827 // visible to observers who share the mapping. Currently, it's
1828 // difficult to update the shared mapping because there's no
1829 // structure which maintains information about the which virtual
1830 // memory areas are shared. If that structure existed, it would be
1831 // possible to make the translations point to the same frames.
1832 // 2) file-backed: writes should modify the mapping and the file
1833 // which is backed by the mapping. The shared mapping problem is the
1834 // same as what was mentioned about the anonymous mappings. For
1835 // file-backed mappings, the writes to the file are difficult
1836 // because it requires syncing what the mapping holds with the file
1837 // that resides on the host system. So, any write on a real system
1838 // would cause the change to be propagated to the file mapping at
1839 // some point in the future (the inode is tracked along with the
1840 // mapping). This isn't guaranteed to always happen, but it usually
1841 // works well enough. The guarantee is provided by the msync system
1842 // call. We could force the change through with shared mappings with
1843 // a call to msync, but that again would require more information
1844 // than we currently maintain.
1845 warn("mmap: writing to shared mmap region is currently "
1846 "unsupported. The write succeeds on the target, but it "
1847 "will not be propagated to the host or shared mappings");
1848 }
1849
1850 length = roundUp(length, TheISA::PageBytes);
1851
1852 int sim_fd = -1;
1853 uint8_t *pmap = nullptr;
1854 if (!(tgt_flags & OS::TGT_MAP_ANONYMOUS)) {
1855 std::shared_ptr<FDEntry> fdep = (*p->fds)[tgt_fd];
1856
1857 auto dfdp = std::dynamic_pointer_cast<DeviceFDEntry>(fdep);
1858 if (dfdp) {
1859 EmulatedDriver *emul_driver = dfdp->getDriver();
1860 return emul_driver->mmap(p, tc, start, length, prot,
1861 tgt_flags, tgt_fd, offset);
1862 }
1863
1864 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>(fdep);
1865 if (!ffdp)
1866 return -EBADF;
1867 sim_fd = ffdp->getSimFD();
1868
1869 pmap = (decltype(pmap))mmap(nullptr, length, PROT_READ, MAP_PRIVATE,
1870 sim_fd, offset);
1871
1872 if (pmap == (decltype(pmap))-1) {
1873 warn("mmap: failed to map file into host address space");
1874 return -errno;
1875 }
1876 }
1877
1878 // Extend global mmap region if necessary. Note that we ignore the
1879 // start address unless MAP_FIXED is specified.
1880 if (!(tgt_flags & OS::TGT_MAP_FIXED)) {
1881 std::shared_ptr<MemState> mem_state = p->memState;
1882 Addr mmap_end = mem_state->getMmapEnd();
1883
1884 start = p->mmapGrowsDown() ? mmap_end - length : mmap_end;
1885 mmap_end = p->mmapGrowsDown() ? start : mmap_end + length;
1886
1887 mem_state->setMmapEnd(mmap_end);
1888 }
1889
1890 DPRINTF_SYSCALL(Verbose, " mmap range is 0x%x - 0x%x\n",
1891 start, start + length - 1);
1892
1893 // We only allow mappings to overwrite existing mappings if
1894 // TGT_MAP_FIXED is set. Otherwise it shouldn't be a problem
1895 // because we ignore the start hint if TGT_MAP_FIXED is not set.
1896 int clobber = tgt_flags & OS::TGT_MAP_FIXED;
1897 if (clobber) {
1898 for (auto tc : p->system->threadContexts) {
1899 // If we might be overwriting old mappings, we need to
1900 // invalidate potentially stale mappings out of the TLBs.
1901 tc->getDTBPtr()->flushAll();
1902 tc->getITBPtr()->flushAll();
1903 }
1904 }
1905
1906 // Allocate physical memory and map it in. If the page table is already
1907 // mapped and clobber is not set, the simulator will issue throw a
1908 // fatal and bail out of the simulation.
1909 p->allocateMem(start, length, clobber);
1910
1911 // Transfer content into target address space.
1912 SETranslatingPortProxy &tp = tc->getMemProxy();
1913 if (tgt_flags & OS::TGT_MAP_ANONYMOUS) {
1914 // In general, we should zero the mapped area for anonymous mappings,
1915 // with something like:
1916 // tp.memsetBlob(start, 0, length);
1917 // However, given that we don't support sparse mappings, and
1918 // some applications can map a couple of gigabytes of space
1919 // (intending sparse usage), that can get painfully expensive.
1920 // Fortunately, since we don't properly implement munmap either,
1921 // there's no danger of remapping used memory, so for now all
1922 // newly mapped memory should already be zeroed so we can skip it.
1923 } else {
1924 // It is possible to mmap an area larger than a file, however
1925 // accessing unmapped portions the system triggers a "Bus error"
1926 // on the host. We must know when to stop copying the file from
1927 // the host into the target address space.
1928 struct stat file_stat;
1929 if (fstat(sim_fd, &file_stat) > 0)
1930 fatal("mmap: cannot stat file");
1931
1932 // Copy the portion of the file that is resident. This requires
1933 // checking both the mmap size and the filesize that we are
1934 // trying to mmap into this space; the mmap size also depends
1935 // on the specified offset into the file.
1936 uint64_t size = std::min((uint64_t)file_stat.st_size - offset,
1937 length);
1938 tp.writeBlob(start, pmap, size);
1939
1940 // Cleanup the mmap region before exiting this function.
1941 munmap(pmap, length);
1942
1943 // Maintain the symbol table for dynamic executables.
1944 // The loader will call mmap to map the images into its address
1945 // space and we intercept that here. We can verify that we are
1946 // executing inside the loader by checking the program counter value.
1947 // XXX: with multiprogrammed workloads or multi-node configurations,
1948 // this will not work since there is a single global symbol table.
1949 ObjectFile *interpreter = p->getInterpreter();
1950 if (interpreter) {
1951 Addr text_start = interpreter->textBase();
1952 Addr text_end = text_start + interpreter->textSize();
1953
1954 Addr pc = tc->pcState().pc();
1955
1956 if (pc >= text_start && pc < text_end) {
1957 std::shared_ptr<FDEntry> fdep = (*p->fds)[tgt_fd];
1958 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>(fdep);
1959 ObjectFile *lib = createObjectFile(ffdp->getFileName());
1960
1961 if (lib) {
1962 lib->loadAllSymbols(debugSymbolTable,
1963 lib->textBase(), start);
1964 }
1965 }
1966 }
1967
1968 // Note that we do not zero out the remainder of the mapping. This
1969 // is done by a real system, but it probably will not affect
1970 // execution (hopefully).
1971 }
1972
1973 return start;
1974}
1975
1976template <class OS>
1977SyscallReturn
1978pwrite64Func(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
1979{
1980 int index = 0;
1981 int tgt_fd = p->getSyscallArg(tc, index);
1982 Addr bufPtr = p->getSyscallArg(tc, index);
1983 int nbytes = p->getSyscallArg(tc, index);
1984 int offset = p->getSyscallArg(tc, index);
1985
1986 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>((*p->fds)[tgt_fd]);
1987 if (!ffdp)
1988 return -EBADF;
1989 int sim_fd = ffdp->getSimFD();
1990
1991 BufferArg bufArg(bufPtr, nbytes);
1992 bufArg.copyIn(tc->getMemProxy());
1993
1994 int bytes_written = pwrite(sim_fd, bufArg.bufferPtr(), nbytes, offset);
1995
1996 return (bytes_written == -1) ? -errno : bytes_written;
1997}
1998
1999/// Target mmap() handler.
2000template <class OS>
2001SyscallReturn
2002mmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2003{
2004 return mmapImpl<OS>(desc, num, p, tc, false);
2005}
2006
2007/// Target mmap2() handler.
2008template <class OS>
2009SyscallReturn
2010mmap2Func(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2011{
2012 return mmapImpl<OS>(desc, num, p, tc, true);
2013}
2014
2015/// Target getrlimit() handler.
2016template <class OS>
2017SyscallReturn
2018getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
2019 ThreadContext *tc)
2020{
2021 int index = 0;
2022 unsigned resource = process->getSyscallArg(tc, index);
2023 TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, index));
2024
2025 switch (resource) {
2026 case OS::TGT_RLIMIT_STACK:
2027 // max stack size in bytes: make up a number (8MB for now)
2028 rlp->rlim_cur = rlp->rlim_max = 8 * 1024 * 1024;
2029 rlp->rlim_cur = TheISA::htog(rlp->rlim_cur);
2030 rlp->rlim_max = TheISA::htog(rlp->rlim_max);
2031 break;
2032
2033 case OS::TGT_RLIMIT_DATA:
2034 // max data segment size in bytes: make up a number
2035 rlp->rlim_cur = rlp->rlim_max = 256 * 1024 * 1024;
2036 rlp->rlim_cur = TheISA::htog(rlp->rlim_cur);
2037 rlp->rlim_max = TheISA::htog(rlp->rlim_max);
2038 break;
2039
2040 default:
2041 warn("getrlimit: unimplemented resource %d", resource);
2042 return -EINVAL;
2043 break;
2044 }
2045
2046 rlp.copyOut(tc->getMemProxy());
2047 return 0;
2048}
2049
2050template <class OS>
2051SyscallReturn
2052prlimitFunc(SyscallDesc *desc, int callnum, Process *process,
2053 ThreadContext *tc)
2054{
2055 int index = 0;
2056 if (process->getSyscallArg(tc, index) != 0)
2057 {
2058 warn("prlimit: ignoring rlimits for nonzero pid");
2059 return -EPERM;
2060 }
2061 int resource = process->getSyscallArg(tc, index);
2062 Addr n = process->getSyscallArg(tc, index);
2063 if (n != 0)
2064 warn("prlimit: ignoring new rlimit");
2065 Addr o = process->getSyscallArg(tc, index);
2066 if (o != 0)
2067 {
2068 TypedBufferArg<typename OS::rlimit> rlp(o);
2069 switch (resource) {
2070 case OS::TGT_RLIMIT_STACK:
2071 // max stack size in bytes: make up a number (8MB for now)
2072 rlp->rlim_cur = rlp->rlim_max = 8 * 1024 * 1024;
2073 rlp->rlim_cur = TheISA::htog(rlp->rlim_cur);
2074 rlp->rlim_max = TheISA::htog(rlp->rlim_max);
2075 break;
2076 case OS::TGT_RLIMIT_DATA:
2077 // max data segment size in bytes: make up a number
2078 rlp->rlim_cur = rlp->rlim_max = 256*1024*1024;
2079 rlp->rlim_cur = TheISA::htog(rlp->rlim_cur);
2080 rlp->rlim_max = TheISA::htog(rlp->rlim_max);
2081 break;
2082 default:
2083 warn("prlimit: unimplemented resource %d", resource);
2084 return -EINVAL;
2085 break;
2086 }
2087 rlp.copyOut(tc->getMemProxy());
2088 }
2089 return 0;
2090}
2091
2092/// Target clock_gettime() function.
2093template <class OS>
2094SyscallReturn
2095clock_gettimeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2096{
2097 int index = 1;
2098 //int clk_id = p->getSyscallArg(tc, index);
2099 TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index));
2100
2101 getElapsedTimeNano(tp->tv_sec, tp->tv_nsec);
2102 tp->tv_sec += seconds_since_epoch;
2103 tp->tv_sec = TheISA::htog(tp->tv_sec);
2104 tp->tv_nsec = TheISA::htog(tp->tv_nsec);
2105
2106 tp.copyOut(tc->getMemProxy());
2107
2108 return 0;
2109}
2110
2111/// Target clock_getres() function.
2112template <class OS>
2113SyscallReturn
2114clock_getresFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2115{
2116 int index = 1;
2117 TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index));
2118
2119 // Set resolution at ns, which is what clock_gettime() returns
2120 tp->tv_sec = 0;
2121 tp->tv_nsec = 1;
2122
2123 tp.copyOut(tc->getMemProxy());
2124
2125 return 0;
2126}
2127
2128/// Target gettimeofday() handler.
2129template <class OS>
2130SyscallReturn
2131gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
2132 ThreadContext *tc)
2133{
2134 int index = 0;
2135 TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, index));
2136
2137 getElapsedTimeMicro(tp->tv_sec, tp->tv_usec);
2138 tp->tv_sec += seconds_since_epoch;
2139 tp->tv_sec = TheISA::htog(tp->tv_sec);
2140 tp->tv_usec = TheISA::htog(tp->tv_usec);
2141
2142 tp.copyOut(tc->getMemProxy());
2143
2144 return 0;
2145}
2146
2147
2148/// Target utimes() handler.
2149template <class OS>
2150SyscallReturn
2151utimesFunc(SyscallDesc *desc, int callnum, Process *process,
2152 ThreadContext *tc)
2153{
2154 std::string path;
2155
2156 int index = 0;
2157 if (!tc->getMemProxy().tryReadString(path,
2158 process->getSyscallArg(tc, index))) {
2159 return -EFAULT;
2160 }
2161
2162 TypedBufferArg<typename OS::timeval [2]>
2163 tp(process->getSyscallArg(tc, index));
2164 tp.copyIn(tc->getMemProxy());
2165
2166 struct timeval hostTimeval[2];
2167 for (int i = 0; i < 2; ++i) {
2168 hostTimeval[i].tv_sec = TheISA::gtoh((*tp)[i].tv_sec);
2169 hostTimeval[i].tv_usec = TheISA::gtoh((*tp)[i].tv_usec);
2170 }
2171
2172 // Adjust path for cwd and redirection
2173 path = process->checkPathRedirect(path);
2174
2175 int result = utimes(path.c_str(), hostTimeval);
2176
2177 if (result < 0)
2178 return -errno;
2179
2180 return 0;
2181}
2182
2183template <class OS>
2184SyscallReturn
2185execveFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
2186{
2187 desc->setFlags(0);
2188
2189 int index = 0;
2190 std::string path;
2191 SETranslatingPortProxy & mem_proxy = tc->getMemProxy();
2192 if (!mem_proxy.tryReadString(path, p->getSyscallArg(tc, index)))
2193 return -EFAULT;
2194
2195 if (access(path.c_str(), F_OK) == -1)
2196 return -EACCES;
2197
2198 auto read_in = [](std::vector<std::string> & vect,
2199 SETranslatingPortProxy & mem_proxy,
2200 Addr mem_loc)
2201 {
2202 for (int inc = 0; ; inc++) {
2203 BufferArg b((mem_loc + sizeof(Addr) * inc), sizeof(Addr));
2204 b.copyIn(mem_proxy);
2205
2206 if (!*(Addr*)b.bufferPtr())
2207 break;
2208
2209 vect.push_back(std::string());
2210 mem_proxy.tryReadString(vect[inc], *(Addr*)b.bufferPtr());
2211 }
2212 };
2213
2214 /**
2215 * Note that ProcessParams is generated by swig and there are no other
2216 * examples of how to create anything but this default constructor. The
2217 * fields are manually initialized instead of passing parameters to the
2218 * constructor.
2219 */
2220 ProcessParams *pp = new ProcessParams();
2221 pp->executable = path;
2222 Addr argv_mem_loc = p->getSyscallArg(tc, index);
2223 read_in(pp->cmd, mem_proxy, argv_mem_loc);
2224 Addr envp_mem_loc = p->getSyscallArg(tc, index);
2225 read_in(pp->env, mem_proxy, envp_mem_loc);
2226 pp->uid = p->uid();
2227 pp->egid = p->egid();
2228 pp->euid = p->euid();
2229 pp->gid = p->gid();
2230 pp->ppid = p->ppid();
2231 pp->pid = p->pid();
2232 pp->input.assign("cin");
2233 pp->output.assign("cout");
2234 pp->errout.assign("cerr");
2235 pp->cwd.assign(p->tgtCwd);
2236 pp->system = p->system;
2237 /**
2238 * Prevent process object creation with identical PIDs (which will trip
2239 * a fatal check in Process constructor). The execve call is supposed to
2240 * take over the currently executing process' identity but replace
2241 * whatever it is doing with a new process image. Instead of hijacking
2242 * the process object in the simulator, we create a new process object
2243 * and bind to the previous process' thread below (hijacking the thread).
2244 */
2245 p->system->PIDs.erase(p->pid());
2246 Process *new_p = pp->create();
2247 delete pp;
2248
2249 /**
2250 * Work through the file descriptor array and close any files marked
2251 * close-on-exec.
2252 */
2253 new_p->fds = p->fds;
2254 for (int i = 0; i < new_p->fds->getSize(); i++) {
2255 std::shared_ptr<FDEntry> fdep = (*new_p->fds)[i];
2256 if (fdep && fdep->getCOE())
2257 new_p->fds->closeFDEntry(i);
2258 }
2259
2260 *new_p->sigchld = true;
2261
2262 delete p;
2263 tc->clearArchRegs();
2264 tc->setProcessPtr(new_p);
2265 new_p->assignThreadContext(tc->contextId());
2266 new_p->initState();
2267 tc->activate();
2268 TheISA::PCState pcState = tc->pcState();
2269 tc->setNPC(pcState.instAddr());
2270
2271 desc->setFlags(SyscallDesc::SuppressReturnValue);
2272 return 0;
2273}
2274
2275/// Target getrusage() function.
2276template <class OS>
2277SyscallReturn
2278getrusageFunc(SyscallDesc *desc, int callnum, Process *process,
2279 ThreadContext *tc)
2280{
2281 int index = 0;
2282 int who = process->getSyscallArg(tc, index); // THREAD, SELF, or CHILDREN
2283 TypedBufferArg<typename OS::rusage> rup(process->getSyscallArg(tc, index));
2284
2285 rup->ru_utime.tv_sec = 0;
2286 rup->ru_utime.tv_usec = 0;
2287 rup->ru_stime.tv_sec = 0;
2288 rup->ru_stime.tv_usec = 0;
2289 rup->ru_maxrss = 0;
2290 rup->ru_ixrss = 0;
2291 rup->ru_idrss = 0;
2292 rup->ru_isrss = 0;
2293 rup->ru_minflt = 0;
2294 rup->ru_majflt = 0;
2295 rup->ru_nswap = 0;
2296 rup->ru_inblock = 0;
2297 rup->ru_oublock = 0;
2298 rup->ru_msgsnd = 0;
2299 rup->ru_msgrcv = 0;
2300 rup->ru_nsignals = 0;
2301 rup->ru_nvcsw = 0;
2302 rup->ru_nivcsw = 0;
2303
2304 switch (who) {
2305 case OS::TGT_RUSAGE_SELF:
2306 getElapsedTimeMicro(rup->ru_utime.tv_sec, rup->ru_utime.tv_usec);
2307 rup->ru_utime.tv_sec = TheISA::htog(rup->ru_utime.tv_sec);
2308 rup->ru_utime.tv_usec = TheISA::htog(rup->ru_utime.tv_usec);
2309 break;
2310
2311 case OS::TGT_RUSAGE_CHILDREN:
2312 // do nothing. We have no child processes, so they take no time.
2313 break;
2314
2315 default:
2316 // don't really handle THREAD or CHILDREN, but just warn and
2317 // plow ahead
2318 warn("getrusage() only supports RUSAGE_SELF. Parameter %d ignored.",
2319 who);
2320 }
2321
2322 rup.copyOut(tc->getMemProxy());
2323
2324 return 0;
2325}
2326
2327/// Target times() function.
2328template <class OS>
2329SyscallReturn
2330timesFunc(SyscallDesc *desc, int callnum, Process *process,
2331 ThreadContext *tc)
2332{
2333 int index = 0;
2334 TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, index));
2335
2336 // Fill in the time structure (in clocks)
2337 int64_t clocks = curTick() * OS::M5_SC_CLK_TCK / SimClock::Int::s;
2338 bufp->tms_utime = clocks;
2339 bufp->tms_stime = 0;
2340 bufp->tms_cutime = 0;
2341 bufp->tms_cstime = 0;
2342
2343 // Convert to host endianness
2344 bufp->tms_utime = TheISA::htog(bufp->tms_utime);
2345
2346 // Write back
2347 bufp.copyOut(tc->getMemProxy());
2348
2349 // Return clock ticks since system boot
2350 return clocks;
2351}
2352
2353/// Target time() function.
2354template <class OS>
2355SyscallReturn
2356timeFunc(SyscallDesc *desc, int callnum, Process *process, ThreadContext *tc)
2357{
2358 typename OS::time_t sec, usec;
2359 getElapsedTimeMicro(sec, usec);
2360 sec += seconds_since_epoch;
2361
2362 int index = 0;
2363 Addr taddr = (Addr)process->getSyscallArg(tc, index);
2364 if (taddr != 0) {
2365 typename OS::time_t t = sec;
2366 t = TheISA::htog(t);
2367 SETranslatingPortProxy &p = tc->getMemProxy();
2368 p.writeBlob(taddr, (uint8_t*)&t, (int)sizeof(typename OS::time_t));
2369 }
2370 return sec;
2371}
2372
2373template <class OS>
2374SyscallReturn
2375tgkillFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
2376{
2377 int index = 0;
2378 int tgid = process->getSyscallArg(tc, index);
2379 int tid = process->getSyscallArg(tc, index);
2380 int sig = process->getSyscallArg(tc, index);
2381
2382 /**
2383 * This system call is intended to allow killing a specific thread
2384 * within an arbitrary thread group if sanctioned with permission checks.
2385 * It's usually true that threads share the termination signal as pointed
2386 * out by the pthread_kill man page and this seems to be the intended
2387 * usage. Due to this being an emulated environment, assume the following:
2388 * Threads are allowed to call tgkill because the EUID for all threads
2389 * should be the same. There is no signal handling mechanism for kernel
2390 * registration of signal handlers since signals are poorly supported in
2391 * emulation mode. Since signal handlers cannot be registered, all
2392 * threads within in a thread group must share the termination signal.
2393 * We never exhaust PIDs so there's no chance of finding the wrong one
2394 * due to PID rollover.
2395 */
2396
2397 System *sys = tc->getSystemPtr();
2398 Process *tgt_proc = nullptr;
2399 for (int i = 0; i < sys->numContexts(); i++) {
2400 Process *temp = sys->threadContexts[i]->getProcessPtr();
2401 if (temp->pid() == tid) {
2402 tgt_proc = temp;
2403 break;
2404 }
2405 }
2406
2407 if (sig != 0 || sig != OS::TGT_SIGABRT)
2408 return -EINVAL;
2409
2410 if (tgt_proc == nullptr)
2411 return -ESRCH;
2412
2413 if (tgid != -1 && tgt_proc->tgid() != tgid)
2414 return -ESRCH;
2415
2416 if (sig == OS::TGT_SIGABRT)
2417 exitGroupFunc(desc, 252, process, tc);
2418
2419 return 0;
2420}
2421
2422template <class OS>
2423SyscallReturn
2424socketFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2425{
2426 int index = 0;
2427 int domain = p->getSyscallArg(tc, index);
2428 int type = p->getSyscallArg(tc, index);
2429 int prot = p->getSyscallArg(tc, index);
2430
2431 int sim_fd = socket(domain, type, prot);
2432 if (sim_fd == -1)
2433 return -errno;
2434
2435 auto sfdp = std::make_shared<SocketFDEntry>(sim_fd, domain, type, prot);
2436 int tgt_fd = p->fds->allocFD(sfdp);
2437
2438 return tgt_fd;
2439}
2440
2441template <class OS>
2442SyscallReturn
2443socketpairFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2444{
2445 int index = 0;
2446 int domain = p->getSyscallArg(tc, index);
2447 int type = p->getSyscallArg(tc, index);
2448 int prot = p->getSyscallArg(tc, index);
2449 Addr svPtr = p->getSyscallArg(tc, index);
2450
2451 BufferArg svBuf((Addr)svPtr, 2 * sizeof(int));
2452 int status = socketpair(domain, type, prot, (int *)svBuf.bufferPtr());
2453 if (status == -1)
2454 return -errno;
2455
2456 int *fds = (int *)svBuf.bufferPtr();
2457
2458 auto sfdp1 = std::make_shared<SocketFDEntry>(fds[0], domain, type, prot);
2459 fds[0] = p->fds->allocFD(sfdp1);
2460 auto sfdp2 = std::make_shared<SocketFDEntry>(fds[1], domain, type, prot);
2461 fds[1] = p->fds->allocFD(sfdp2);
2462 svBuf.copyOut(tc->getMemProxy());
2463
2464 return status;
2465}
2466
2467template <class OS>
2468SyscallReturn
2469selectFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
2470{
2471 int retval;
2472
2473 int index = 0;
2474 int nfds_t = p->getSyscallArg(tc, index);
2475 Addr fds_read_ptr = p->getSyscallArg(tc, index);
2476 Addr fds_writ_ptr = p->getSyscallArg(tc, index);
2477 Addr fds_excp_ptr = p->getSyscallArg(tc, index);
2478 Addr time_val_ptr = p->getSyscallArg(tc, index);
2479
2480 TypedBufferArg<typename OS::fd_set> rd_t(fds_read_ptr);
2481 TypedBufferArg<typename OS::fd_set> wr_t(fds_writ_ptr);
2482 TypedBufferArg<typename OS::fd_set> ex_t(fds_excp_ptr);
2483 TypedBufferArg<typename OS::timeval> tp(time_val_ptr);
2484
2485 /**
2486 * Host fields. Notice that these use the definitions from the system
2487 * headers instead of the gem5 headers and libraries. If the host and
2488 * target have different header file definitions, this will not work.
2489 */
2490 fd_set rd_h;
2491 FD_ZERO(&rd_h);
2492 fd_set wr_h;
2493 FD_ZERO(&wr_h);
2494 fd_set ex_h;
2495 FD_ZERO(&ex_h);
2496
2497 /**
2498 * Copy in the fd_set from the target.
2499 */
2500 if (fds_read_ptr)
2501 rd_t.copyIn(tc->getMemProxy());
2502 if (fds_writ_ptr)
2503 wr_t.copyIn(tc->getMemProxy());
2504 if (fds_excp_ptr)
2505 ex_t.copyIn(tc->getMemProxy());
2506
2507 /**
2508 * We need to translate the target file descriptor set into a host file
2509 * descriptor set. This involves both our internal process fd array
2510 * and the fd_set defined in Linux header files. The nfds field also
2511 * needs to be updated as it will be only target specific after
2512 * retrieving it from the target; the nfds value is expected to be the
2513 * highest file descriptor that needs to be checked, so we need to extend
2514 * it out for nfds_h when we do the update.
2515 */
2516 int nfds_h = 0;
2517 std::map<int, int> trans_map;
2518 auto try_add_host_set = [&](fd_set *tgt_set_entry,
2519 fd_set *hst_set_entry,
2520 int iter) -> bool
2521 {
2522 /**
2523 * By this point, we know that we are looking at a valid file
2524 * descriptor set on the target. We need to check if the target file
2525 * descriptor value passed in as iter is part of the set.
2526 */
2527 if (FD_ISSET(iter, tgt_set_entry)) {
2528 /**
2529 * We know that the target file descriptor belongs to the set,
2530 * but we do not yet know if the file descriptor is valid or
2531 * that we have a host mapping. Check that now.
2532 */
2533 auto hbfdp = std::dynamic_pointer_cast<HBFDEntry>((*p->fds)[iter]);
2534 if (!hbfdp)
2535 return true;
2536 auto sim_fd = hbfdp->getSimFD();
2537
2538 /**
2539 * Add the sim_fd to tgt_fd translation into trans_map for use
2540 * later when we need to zero the target fd_set structures and
2541 * then update them with hits returned from the host select call.
2542 */
2543 trans_map[sim_fd] = iter;
2544
2545 /**
2546 * We know that the host file descriptor exists so now we check
2547 * if we need to update the max count for nfds_h before passing
2548 * the duplicated structure into the host.
2549 */
2550 nfds_h = std::max(nfds_h - 1, sim_fd + 1);
2551
2552 /**
2553 * Add the host file descriptor to the set that we are going to
2554 * pass into the host.
2555 */
2556 FD_SET(sim_fd, hst_set_entry);
2557 }
2558 return false;
2559 };
2560
2561 for (int i = 0; i < nfds_t; i++) {
2562 if (fds_read_ptr) {
2563 bool ebadf = try_add_host_set((fd_set*)&*rd_t, &rd_h, i);
2564 if (ebadf) return -EBADF;
2565 }
2566 if (fds_writ_ptr) {
2567 bool ebadf = try_add_host_set((fd_set*)&*wr_t, &wr_h, i);
2568 if (ebadf) return -EBADF;
2569 }
2570 if (fds_excp_ptr) {
2571 bool ebadf = try_add_host_set((fd_set*)&*ex_t, &ex_h, i);
2572 if (ebadf) return -EBADF;
2573 }
2574 }
2575
2576 if (time_val_ptr) {
2577 /**
2578 * It might be possible to decrement the timeval based on some
2579 * derivation of wall clock determined from elapsed simulator ticks
2580 * but that seems like overkill. Rather, we just set the timeval with
2581 * zero timeout. (There is no reason to block during the simulation
2582 * as it only decreases simulator performance.)
2583 */
2584 tp->tv_sec = 0;
2585 tp->tv_usec = 0;
2586
2587 retval = select(nfds_h,
2588 fds_read_ptr ? &rd_h : nullptr,
2589 fds_writ_ptr ? &wr_h : nullptr,
2590 fds_excp_ptr ? &ex_h : nullptr,
2591 (timeval*)&*tp);
2592 } else {
2593 /**
2594 * If the timeval pointer is null, setup a new timeval structure to
2595 * pass into the host select call. Unfortunately, we will need to
2596 * manually check the return value and throw a retry fault if the
2597 * return value is zero. Allowing the system call to block will
2598 * likely deadlock the event queue.
2599 */
2600 struct timeval tv = { 0, 0 };
2601
2602 retval = select(nfds_h,
2603 fds_read_ptr ? &rd_h : nullptr,
2604 fds_writ_ptr ? &wr_h : nullptr,
2605 fds_excp_ptr ? &ex_h : nullptr,
2606 &tv);
2607
2608 if (retval == 0) {
2609 /**
2610 * If blocking indefinitely, check the signal list to see if a
2611 * signal would break the poll out of the retry cycle and try to
2612 * return the signal interrupt instead.
2613 */
2614 for (auto sig : tc->getSystemPtr()->signalList)
2615 if (sig.receiver == p)
2616 return -EINTR;
2617 return SyscallReturn::retry();
2618 }
2619 }
2620
2621 if (retval == -1)
2622 return -errno;
2623
2624 FD_ZERO((fd_set*)&*rd_t);
2625 FD_ZERO((fd_set*)&*wr_t);
2626 FD_ZERO((fd_set*)&*ex_t);
2627
2628 /**
2629 * We need to translate the host file descriptor set into a target file
2630 * descriptor set. This involves both our internal process fd array
2631 * and the fd_set defined in header files.
2632 */
2633 for (int i = 0; i < nfds_h; i++) {
2634 if (fds_read_ptr) {
2635 if (FD_ISSET(i, &rd_h))
2636 FD_SET(trans_map[i], (fd_set*)&*rd_t);
2637 }
2638
2639 if (fds_writ_ptr) {
2640 if (FD_ISSET(i, &wr_h))
2641 FD_SET(trans_map[i], (fd_set*)&*wr_t);
2642 }
2643
2644 if (fds_excp_ptr) {
2645 if (FD_ISSET(i, &ex_h))
2646 FD_SET(trans_map[i], (fd_set*)&*ex_t);
2647 }
2648 }
2649
2650 if (fds_read_ptr)
2651 rd_t.copyOut(tc->getMemProxy());
2652 if (fds_writ_ptr)
2653 wr_t.copyOut(tc->getMemProxy());
2654 if (fds_excp_ptr)
2655 ex_t.copyOut(tc->getMemProxy());
2656 if (time_val_ptr)
2657 tp.copyOut(tc->getMemProxy());
2658
2659 return retval;
2660}
2661
2662template <class OS>
2663SyscallReturn
2664readFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2665{
2666 int index = 0;
2667 int tgt_fd = p->getSyscallArg(tc, index);
2668 Addr buf_ptr = p->getSyscallArg(tc, index);
2669 int nbytes = p->getSyscallArg(tc, index);
2670
2671 auto hbfdp = std::dynamic_pointer_cast<HBFDEntry>((*p->fds)[tgt_fd]);
2672 if (!hbfdp)
2673 return -EBADF;
2674 int sim_fd = hbfdp->getSimFD();
2675
2676 struct pollfd pfd;
2677 pfd.fd = sim_fd;
2678 pfd.events = POLLIN | POLLPRI;
2679 if ((poll(&pfd, 1, 0) == 0)
2680 && !(hbfdp->getFlags() & OS::TGT_O_NONBLOCK))
2681 return SyscallReturn::retry();
2682
2683 BufferArg buf_arg(buf_ptr, nbytes);
2684 int bytes_read = read(sim_fd, buf_arg.bufferPtr(), nbytes);
2685
2686 if (bytes_read > 0)
2687 buf_arg.copyOut(tc->getMemProxy());
2688
2689 return (bytes_read == -1) ? -errno : bytes_read;
2690}
2691
2692template <class OS>
2693SyscallReturn
2694writeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2695{
2696 int index = 0;
2697 int tgt_fd = p->getSyscallArg(tc, index);
2698 Addr buf_ptr = p->getSyscallArg(tc, index);
2699 int nbytes = p->getSyscallArg(tc, index);
2700
2701 auto hbfdp = std::dynamic_pointer_cast<HBFDEntry>((*p->fds)[tgt_fd]);
2702 if (!hbfdp)
2703 return -EBADF;
2704 int sim_fd = hbfdp->getSimFD();
2705
2706 BufferArg buf_arg(buf_ptr, nbytes);
2707 buf_arg.copyIn(tc->getMemProxy());
2708
2709 struct pollfd pfd;
2710 pfd.fd = sim_fd;
2711 pfd.events = POLLOUT;
2712
2713 /**
2714 * We don't want to poll on /dev/random. The kernel will not enable the
2715 * file descriptor for writing unless the entropy in the system falls
2716 * below write_wakeup_threshold. This is not guaranteed to happen
2717 * depending on host settings.
2718 */
2719 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>(hbfdp);
2720 if (ffdp && (ffdp->getFileName() != "/dev/random")) {
2721 if (!poll(&pfd, 1, 0) && !(ffdp->getFlags() & OS::TGT_O_NONBLOCK))
2722 return SyscallReturn::retry();
2723 }
2724
2725 int bytes_written = write(sim_fd, buf_arg.bufferPtr(), nbytes);
2726
2727 if (bytes_written != -1)
2728 fsync(sim_fd);
2729
2730 return (bytes_written == -1) ? -errno : bytes_written;
2731}
2732
2733template <class OS>
2734SyscallReturn
2735wait4Func(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2736{
2737 int index = 0;
2738 pid_t pid = p->getSyscallArg(tc, index);
2739 Addr statPtr = p->getSyscallArg(tc, index);
2740 int options = p->getSyscallArg(tc, index);
2741 Addr rusagePtr = p->getSyscallArg(tc, index);
2742
2743 if (rusagePtr)
2744 DPRINTF_SYSCALL(Verbose, "wait4: rusage pointer provided %lx, however "
2745 "functionality not supported. Ignoring rusage pointer.\n",
2746 rusagePtr);
2747
2748 /**
2749 * Currently, wait4 is only implemented so that it will wait for children
2750 * exit conditions which are denoted by a SIGCHLD signals posted into the
2751 * system signal list. We return no additional information via any of the
2752 * parameters supplied to wait4. If nothing is found in the system signal
2753 * list, we will wait indefinitely for SIGCHLD to post by retrying the
2754 * call.
2755 */
2756 System *sysh = tc->getSystemPtr();
2757 std::list<BasicSignal>::iterator iter;
2758 for (iter=sysh->signalList.begin(); iter!=sysh->signalList.end(); iter++) {
2759 if (iter->receiver == p) {
2760 if (pid < -1) {
2761 if ((iter->sender->pgid() == -pid)
2762 && (iter->signalValue == OS::TGT_SIGCHLD))
2763 goto success;
2764 } else if (pid == -1) {
2765 if (iter->signalValue == OS::TGT_SIGCHLD)
2766 goto success;
2767 } else if (pid == 0) {
2768 if ((iter->sender->pgid() == p->pgid())
2769 && (iter->signalValue == OS::TGT_SIGCHLD))
2770 goto success;
2771 } else {
2772 if ((iter->sender->pid() == pid)
2773 && (iter->signalValue == OS::TGT_SIGCHLD))
2774 goto success;
2775 }
2776 }
2777 }
2778
2779 return (options & OS::TGT_WNOHANG) ? 0 : SyscallReturn::retry();
2780
2781success:
2782 // Set status to EXITED for WIFEXITED evaluations.
2783 const int EXITED = 0;
2784 BufferArg statusBuf(statPtr, sizeof(int));
2785 *(int *)statusBuf.bufferPtr() = EXITED;
2786 statusBuf.copyOut(tc->getMemProxy());
2787
2788 // Return the child PID.
2789 pid_t retval = iter->sender->pid();
2790 sysh->signalList.erase(iter);
2791 return retval;
2792}
2793
2794template <class OS>
2795SyscallReturn
2796acceptFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
2797{
2798 struct sockaddr sa;
2799 socklen_t addrLen;
2800 int host_fd;
2801 int index = 0;
2802 int tgt_fd = p->getSyscallArg(tc, index);
2803 Addr addrPtr = p->getSyscallArg(tc, index);
2804 Addr lenPtr = p->getSyscallArg(tc, index);
2805
2806 BufferArg *lenBufPtr = nullptr;
2807 BufferArg *addrBufPtr = nullptr;
2808
2809 auto sfdp = std::dynamic_pointer_cast<SocketFDEntry>((*p->fds)[tgt_fd]);
2810 if (!sfdp)
2811 return -EBADF;
2812 int sim_fd = sfdp->getSimFD();
2813
2814 /**
2815 * We poll the socket file descriptor first to guarantee that we do not
2816 * block on our accept call. The socket can be opened without the
2817 * non-blocking flag (it blocks). This will cause deadlocks between
2818 * communicating processes.
2819 */
2820 struct pollfd pfd;
2821 pfd.fd = sim_fd;
2822 pfd.events = POLLIN | POLLPRI;
2823 if ((poll(&pfd, 1, 0) == 0)
2824 && !(sfdp->getFlags() & OS::TGT_O_NONBLOCK))
2825 return SyscallReturn::retry();
2826
2827 if (lenPtr) {
2828 lenBufPtr = new BufferArg(lenPtr, sizeof(socklen_t));
2829 lenBufPtr->copyIn(tc->getMemProxy());
2830 memcpy(&addrLen, (socklen_t *)lenBufPtr->bufferPtr(),
2831 sizeof(socklen_t));
2832 }
2833
2834 if (addrPtr) {
2835 addrBufPtr = new BufferArg(addrPtr, sizeof(struct sockaddr));
2836 addrBufPtr->copyIn(tc->getMemProxy());
2837 memcpy(&sa, (struct sockaddr *)addrBufPtr->bufferPtr(),
2838 sizeof(struct sockaddr));
2839 }
2840
2841 host_fd = accept(sim_fd, &sa, &addrLen);
2842
2843 if (host_fd == -1)
2844 return -errno;
2845
2846 if (addrPtr) {
2847 memcpy(addrBufPtr->bufferPtr(), &sa, sizeof(sa));
2848 addrBufPtr->copyOut(tc->getMemProxy());
2849 delete(addrBufPtr);
2850 }
2851
2852 if (lenPtr) {
2853 *(socklen_t *)lenBufPtr->bufferPtr() = addrLen;
2854 lenBufPtr->copyOut(tc->getMemProxy());
2855 delete(lenBufPtr);
2856 }
2857
2858 auto afdp = std::make_shared<SocketFDEntry>(host_fd, sfdp->_domain,
2859 sfdp->_type, sfdp->_protocol);
2860 return p->fds->allocFD(afdp);
2861}
2862
2863#endif // __SIM_SYSCALL_EMUL_HH__