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