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