1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Steve Reinhardt
29 * Ali Saidi
30 */
31
32#include <fcntl.h>
33#include <unistd.h>
34
35#include <cstdio>
36#include <iostream>
37#include <string>
38
39#include "sim/syscall_emul.hh"
40#include "base/chunk_generator.hh"
41#include "base/trace.hh"
42#include "config/the_isa.hh"
43#include "cpu/thread_context.hh"
44#include "cpu/base.hh"
45#include "mem/page_table.hh"
46#include "sim/process.hh"
47#include "sim/system.hh"
48#include "sim/sim_exit.hh"
49
50using namespace std;
51using namespace TheISA;
52
53void
54SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc)
55{
56#if TRACING_ON
57 int index = 0;
58#endif
59 DPRINTFR(SyscallVerbose,
60 "%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n",
61 curTick, tc->getCpuPtr()->name(), name,
62 process->getSyscallArg(tc, index),
63 process->getSyscallArg(tc, index),
64 process->getSyscallArg(tc, index),
65 process->getSyscallArg(tc, index));
66
67 SyscallReturn retval = (*funcPtr)(this, callnum, process, tc);
68
69 DPRINTFR(SyscallVerbose, "%d: %s: syscall %s returns %d\n",
70 curTick,tc->getCpuPtr()->name(), name, retval.value());
71
72 if (!(flags & SyscallDesc::SuppressReturnValue))
73 process->setSyscallReturn(tc, retval);
74}
75
76
77SyscallReturn
78unimplementedFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
79 ThreadContext *tc)
80{
81 fatal("syscall %s (#%d) unimplemented.", desc->name, callnum);
82
83 return 1;
84}
85
86
87SyscallReturn
88ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
89 ThreadContext *tc)
90{
91 int index = 0;
92 warn("ignoring syscall %s(%d, %d, ...)", desc->name,
93 process->getSyscallArg(tc, index), process->getSyscallArg(tc, index));
94
95 return 0;
96}
97
98
99SyscallReturn
100exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
101 ThreadContext *tc)
102{
103 if (process->system->numRunningContexts() == 1) {
104 // Last running context... exit simulator
105 int index = 0;
106 exitSimLoop("target called exit()",
107 process->getSyscallArg(tc, index) & 0xff);
108 } else {
109 // other running threads... just halt this one
110 tc->halt();
111 }
112
113 return 1;
114}
115
116
117SyscallReturn
118exitGroupFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
119 ThreadContext *tc)
120{
121 // really should just halt all thread contexts belonging to this
122 // process in case there's another process running...
123 int index = 0;
124 exitSimLoop("target called exit()",
125 process->getSyscallArg(tc, index) & 0xff);
126
127 return 1;
128}
129
130
131SyscallReturn
132getpagesizeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
133{
134 return (int)VMPageSize;
135}
136
137
138SyscallReturn
139brkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
140{
141 // change brk addr to first arg
142 int index = 0;
143 Addr new_brk = p->getSyscallArg(tc, index);
144
145 // in Linux at least, brk(0) returns the current break value
146 // (note that the syscall and the glibc function have different behavior)
147 if (new_brk == 0)
148 return p->brk_point;
149
150 if (new_brk > p->brk_point) {
151 // might need to allocate some new pages
152 for (ChunkGenerator gen(p->brk_point, new_brk - p->brk_point,
153 VMPageSize); !gen.done(); gen.next()) {
154 if (!p->pTable->translate(gen.addr()))
155 p->pTable->allocate(roundDown(gen.addr(), VMPageSize),
156 VMPageSize);
157
158 // if the address is already there, zero it out
159 else {
160 uint8_t zero = 0;
161 TranslatingPort *tp = tc->getMemPort();
162
163 // split non-page aligned accesses
164 Addr next_page = roundUp(gen.addr(), VMPageSize);
165 uint32_t size_needed = next_page - gen.addr();
166 tp->memsetBlob(gen.addr(), zero, size_needed);
167 if (gen.addr() + VMPageSize > next_page &&
168 next_page < new_brk &&
169 p->pTable->translate(next_page))
170 {
171 size_needed = VMPageSize - size_needed;
172 tp->memsetBlob(next_page, zero, size_needed);
173 }
174 }
175 }
176 }
177
178 p->brk_point = new_brk;
179 DPRINTF(SyscallVerbose, "Break Point changed to: %#X\n", p->brk_point);
180 return p->brk_point;
181}
182
183
184SyscallReturn
185closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
186{
187 int index = 0;
188 int target_fd = p->getSyscallArg(tc, index);
189 int status = close(p->sim_fd(target_fd));
190 if (status >= 0)
191 p->free_fd(target_fd);
192 return status;
193}
194
195
196SyscallReturn
197readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
198{
199 int index = 0;
200 int fd = p->sim_fd(p->getSyscallArg(tc, index));
201 Addr bufPtr = p->getSyscallArg(tc, index);
202 int nbytes = p->getSyscallArg(tc, index);
203 BufferArg bufArg(bufPtr, nbytes);
204
205 int bytes_read = read(fd, bufArg.bufferPtr(), nbytes);
206
207 if (bytes_read != -1)
208 bufArg.copyOut(tc->getMemPort());
209
210 return bytes_read;
211}
212
213SyscallReturn
214writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
215{
216 int index = 0;
217 int fd = p->sim_fd(p->getSyscallArg(tc, index));
218 Addr bufPtr = p->getSyscallArg(tc, index);
219 int nbytes = p->getSyscallArg(tc, index);
220 BufferArg bufArg(bufPtr, nbytes);
221
222 bufArg.copyIn(tc->getMemPort());
223
224 int bytes_written = write(fd, bufArg.bufferPtr(), nbytes);
225
226 fsync(fd);
227
228 return bytes_written;
229}
230
231
232SyscallReturn
233lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
234{
235 int index = 0;
236 int fd = p->sim_fd(p->getSyscallArg(tc, index));
237 uint64_t offs = p->getSyscallArg(tc, index);
238 int whence = p->getSyscallArg(tc, index);
239
240 off_t result = lseek(fd, offs, whence);
241
242 return (result == (off_t)-1) ? -errno : result;
243}
244
245
246SyscallReturn
247_llseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
248{
249 int index = 0;
250 int fd = p->sim_fd(p->getSyscallArg(tc, index));
251 uint64_t offset_high = p->getSyscallArg(tc, index);
252 uint32_t offset_low = p->getSyscallArg(tc, index);
253 Addr result_ptr = p->getSyscallArg(tc, index);
254 int whence = p->getSyscallArg(tc, index);
255
256 uint64_t offset = (offset_high << 32) | offset_low;
257
258 uint64_t result = lseek(fd, offset, whence);
259 result = TheISA::htog(result);
260
261 if (result == (off_t)-1) {
262 //The seek failed.
263 return -errno;
264 } else {
265 // The seek succeeded.
266 // Copy "result" to "result_ptr"
267 // XXX We'll assume that the size of loff_t is 64 bits on the
268 // target platform
269 BufferArg result_buf(result_ptr, sizeof(result));
270 memcpy(result_buf.bufferPtr(), &result, sizeof(result));
271 result_buf.copyOut(tc->getMemPort());
272 return 0;
273 }
274
275
276 return (result == (off_t)-1) ? -errno : result;
277}
278
279
280SyscallReturn
281munmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
282{
283 // given that we don't really implement mmap, munmap is really easy
284 return 0;
285}
286
287
288const char *hostname = "m5.eecs.umich.edu";
289
290SyscallReturn
291gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
292{
293 int index = 0;
294 Addr bufPtr = p->getSyscallArg(tc, index);
295 int name_len = p->getSyscallArg(tc, index);
296 BufferArg name(bufPtr, name_len);
297
298 strncpy((char *)name.bufferPtr(), hostname, name_len);
299
300 name.copyOut(tc->getMemPort());
301
302 return 0;
303}
304
305SyscallReturn
306getcwdFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
307{
308 int result = 0;
| 1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Steve Reinhardt
29 * Ali Saidi
30 */
31
32#include <fcntl.h>
33#include <unistd.h>
34
35#include <cstdio>
36#include <iostream>
37#include <string>
38
39#include "sim/syscall_emul.hh"
40#include "base/chunk_generator.hh"
41#include "base/trace.hh"
42#include "config/the_isa.hh"
43#include "cpu/thread_context.hh"
44#include "cpu/base.hh"
45#include "mem/page_table.hh"
46#include "sim/process.hh"
47#include "sim/system.hh"
48#include "sim/sim_exit.hh"
49
50using namespace std;
51using namespace TheISA;
52
53void
54SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc)
55{
56#if TRACING_ON
57 int index = 0;
58#endif
59 DPRINTFR(SyscallVerbose,
60 "%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n",
61 curTick, tc->getCpuPtr()->name(), name,
62 process->getSyscallArg(tc, index),
63 process->getSyscallArg(tc, index),
64 process->getSyscallArg(tc, index),
65 process->getSyscallArg(tc, index));
66
67 SyscallReturn retval = (*funcPtr)(this, callnum, process, tc);
68
69 DPRINTFR(SyscallVerbose, "%d: %s: syscall %s returns %d\n",
70 curTick,tc->getCpuPtr()->name(), name, retval.value());
71
72 if (!(flags & SyscallDesc::SuppressReturnValue))
73 process->setSyscallReturn(tc, retval);
74}
75
76
77SyscallReturn
78unimplementedFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
79 ThreadContext *tc)
80{
81 fatal("syscall %s (#%d) unimplemented.", desc->name, callnum);
82
83 return 1;
84}
85
86
87SyscallReturn
88ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
89 ThreadContext *tc)
90{
91 int index = 0;
92 warn("ignoring syscall %s(%d, %d, ...)", desc->name,
93 process->getSyscallArg(tc, index), process->getSyscallArg(tc, index));
94
95 return 0;
96}
97
98
99SyscallReturn
100exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
101 ThreadContext *tc)
102{
103 if (process->system->numRunningContexts() == 1) {
104 // Last running context... exit simulator
105 int index = 0;
106 exitSimLoop("target called exit()",
107 process->getSyscallArg(tc, index) & 0xff);
108 } else {
109 // other running threads... just halt this one
110 tc->halt();
111 }
112
113 return 1;
114}
115
116
117SyscallReturn
118exitGroupFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
119 ThreadContext *tc)
120{
121 // really should just halt all thread contexts belonging to this
122 // process in case there's another process running...
123 int index = 0;
124 exitSimLoop("target called exit()",
125 process->getSyscallArg(tc, index) & 0xff);
126
127 return 1;
128}
129
130
131SyscallReturn
132getpagesizeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
133{
134 return (int)VMPageSize;
135}
136
137
138SyscallReturn
139brkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
140{
141 // change brk addr to first arg
142 int index = 0;
143 Addr new_brk = p->getSyscallArg(tc, index);
144
145 // in Linux at least, brk(0) returns the current break value
146 // (note that the syscall and the glibc function have different behavior)
147 if (new_brk == 0)
148 return p->brk_point;
149
150 if (new_brk > p->brk_point) {
151 // might need to allocate some new pages
152 for (ChunkGenerator gen(p->brk_point, new_brk - p->brk_point,
153 VMPageSize); !gen.done(); gen.next()) {
154 if (!p->pTable->translate(gen.addr()))
155 p->pTable->allocate(roundDown(gen.addr(), VMPageSize),
156 VMPageSize);
157
158 // if the address is already there, zero it out
159 else {
160 uint8_t zero = 0;
161 TranslatingPort *tp = tc->getMemPort();
162
163 // split non-page aligned accesses
164 Addr next_page = roundUp(gen.addr(), VMPageSize);
165 uint32_t size_needed = next_page - gen.addr();
166 tp->memsetBlob(gen.addr(), zero, size_needed);
167 if (gen.addr() + VMPageSize > next_page &&
168 next_page < new_brk &&
169 p->pTable->translate(next_page))
170 {
171 size_needed = VMPageSize - size_needed;
172 tp->memsetBlob(next_page, zero, size_needed);
173 }
174 }
175 }
176 }
177
178 p->brk_point = new_brk;
179 DPRINTF(SyscallVerbose, "Break Point changed to: %#X\n", p->brk_point);
180 return p->brk_point;
181}
182
183
184SyscallReturn
185closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
186{
187 int index = 0;
188 int target_fd = p->getSyscallArg(tc, index);
189 int status = close(p->sim_fd(target_fd));
190 if (status >= 0)
191 p->free_fd(target_fd);
192 return status;
193}
194
195
196SyscallReturn
197readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
198{
199 int index = 0;
200 int fd = p->sim_fd(p->getSyscallArg(tc, index));
201 Addr bufPtr = p->getSyscallArg(tc, index);
202 int nbytes = p->getSyscallArg(tc, index);
203 BufferArg bufArg(bufPtr, nbytes);
204
205 int bytes_read = read(fd, bufArg.bufferPtr(), nbytes);
206
207 if (bytes_read != -1)
208 bufArg.copyOut(tc->getMemPort());
209
210 return bytes_read;
211}
212
213SyscallReturn
214writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
215{
216 int index = 0;
217 int fd = p->sim_fd(p->getSyscallArg(tc, index));
218 Addr bufPtr = p->getSyscallArg(tc, index);
219 int nbytes = p->getSyscallArg(tc, index);
220 BufferArg bufArg(bufPtr, nbytes);
221
222 bufArg.copyIn(tc->getMemPort());
223
224 int bytes_written = write(fd, bufArg.bufferPtr(), nbytes);
225
226 fsync(fd);
227
228 return bytes_written;
229}
230
231
232SyscallReturn
233lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
234{
235 int index = 0;
236 int fd = p->sim_fd(p->getSyscallArg(tc, index));
237 uint64_t offs = p->getSyscallArg(tc, index);
238 int whence = p->getSyscallArg(tc, index);
239
240 off_t result = lseek(fd, offs, whence);
241
242 return (result == (off_t)-1) ? -errno : result;
243}
244
245
246SyscallReturn
247_llseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
248{
249 int index = 0;
250 int fd = p->sim_fd(p->getSyscallArg(tc, index));
251 uint64_t offset_high = p->getSyscallArg(tc, index);
252 uint32_t offset_low = p->getSyscallArg(tc, index);
253 Addr result_ptr = p->getSyscallArg(tc, index);
254 int whence = p->getSyscallArg(tc, index);
255
256 uint64_t offset = (offset_high << 32) | offset_low;
257
258 uint64_t result = lseek(fd, offset, whence);
259 result = TheISA::htog(result);
260
261 if (result == (off_t)-1) {
262 //The seek failed.
263 return -errno;
264 } else {
265 // The seek succeeded.
266 // Copy "result" to "result_ptr"
267 // XXX We'll assume that the size of loff_t is 64 bits on the
268 // target platform
269 BufferArg result_buf(result_ptr, sizeof(result));
270 memcpy(result_buf.bufferPtr(), &result, sizeof(result));
271 result_buf.copyOut(tc->getMemPort());
272 return 0;
273 }
274
275
276 return (result == (off_t)-1) ? -errno : result;
277}
278
279
280SyscallReturn
281munmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
282{
283 // given that we don't really implement mmap, munmap is really easy
284 return 0;
285}
286
287
288const char *hostname = "m5.eecs.umich.edu";
289
290SyscallReturn
291gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
292{
293 int index = 0;
294 Addr bufPtr = p->getSyscallArg(tc, index);
295 int name_len = p->getSyscallArg(tc, index);
296 BufferArg name(bufPtr, name_len);
297
298 strncpy((char *)name.bufferPtr(), hostname, name_len);
299
300 name.copyOut(tc->getMemPort());
301
302 return 0;
303}
304
305SyscallReturn
306getcwdFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
307{
308 int result = 0;
|
310 Addr bufPtr = p->getSyscallArg(tc, index);
311 unsigned long size = p->getSyscallArg(tc, index);
312 BufferArg buf(bufPtr, size);
313
314 // Is current working directory defined?
315 string cwd = p->getcwd();
316 if (!cwd.empty()) {
317 if (cwd.length() >= size) {
318 // Buffer too small
319 return -ERANGE;
320 }
321 strncpy((char *)buf.bufferPtr(), cwd.c_str(), size);
322 result = cwd.length();
323 }
324 else {
325 if (getcwd((char *)buf.bufferPtr(), size) != NULL) {
326 result = strlen((char *)buf.bufferPtr());
327 }
328 else {
329 result = -1;
330 }
331 }
332
333 buf.copyOut(tc->getMemPort());
334
335 return (result == -1) ? -errno : result;
336}
337
338
339SyscallReturn
340readlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
341{
342 string path;
343
344 int index = 0;
345 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
346 return (TheISA::IntReg)-EFAULT;
347
348 // Adjust path for current working directory
349 path = p->fullPath(path);
350
351 Addr bufPtr = p->getSyscallArg(tc, index);
352 size_t bufsiz = p->getSyscallArg(tc, index);
353
354 BufferArg buf(bufPtr, bufsiz);
355
356 int result = readlink(path.c_str(), (char *)buf.bufferPtr(), bufsiz);
357
358 buf.copyOut(tc->getMemPort());
359
360 return (result == -1) ? -errno : result;
361}
362
363SyscallReturn
364unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
365{
366 string path;
367
368 int index = 0;
369 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
370 return (TheISA::IntReg)-EFAULT;
371
372 // Adjust path for current working directory
373 path = p->fullPath(path);
374
375 int result = unlink(path.c_str());
376 return (result == -1) ? -errno : result;
377}
378
379
380SyscallReturn
381mkdirFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
382{
383 string path;
384
385 int index = 0;
386 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
387 return (TheISA::IntReg)-EFAULT;
388
389 // Adjust path for current working directory
390 path = p->fullPath(path);
391
392 mode_t mode = p->getSyscallArg(tc, index);
393
394 int result = mkdir(path.c_str(), mode);
395 return (result == -1) ? -errno : result;
396}
397
398SyscallReturn
399renameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
400{
401 string old_name;
402
403 int index = 0;
404 if (!tc->getMemPort()->tryReadString(old_name, p->getSyscallArg(tc, index)))
405 return -EFAULT;
406
407 string new_name;
408
409 if (!tc->getMemPort()->tryReadString(new_name, p->getSyscallArg(tc, index)))
410 return -EFAULT;
411
412 // Adjust path for current working directory
413 old_name = p->fullPath(old_name);
414 new_name = p->fullPath(new_name);
415
416 int64_t result = rename(old_name.c_str(), new_name.c_str());
417 return (result == -1) ? -errno : result;
418}
419
420SyscallReturn
421truncateFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
422{
423 string path;
424
425 int index = 0;
426 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
427 return -EFAULT;
428
429 off_t length = p->getSyscallArg(tc, index);
430
431 // Adjust path for current working directory
432 path = p->fullPath(path);
433
434 int result = truncate(path.c_str(), length);
435 return (result == -1) ? -errno : result;
436}
437
438SyscallReturn
439ftruncateFunc(SyscallDesc *desc, int num,
440 LiveProcess *process, ThreadContext *tc)
441{
442 int index = 0;
443 int fd = process->sim_fd(process->getSyscallArg(tc, index));
444
445 if (fd < 0)
446 return -EBADF;
447
448 off_t length = process->getSyscallArg(tc, index);
449
450 int result = ftruncate(fd, length);
451 return (result == -1) ? -errno : result;
452}
453
454SyscallReturn
455truncate64Func(SyscallDesc *desc, int num,
456 LiveProcess *process, ThreadContext *tc)
457{
458 int index = 0;
459 string path;
460
461 if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, index)))
462 return -EFAULT;
463
464 loff_t length = process->getSyscallArg(tc, index, 64);
465
466 // Adjust path for current working directory
467 path = process->fullPath(path);
468
469 int result = truncate64(path.c_str(), length);
470 return (result == -1) ? -errno : result;
471}
472
473SyscallReturn
474ftruncate64Func(SyscallDesc *desc, int num,
475 LiveProcess *process, ThreadContext *tc)
476{
477 int index = 0;
478 int fd = process->sim_fd(process->getSyscallArg(tc, index));
479
480 if (fd < 0)
481 return -EBADF;
482
483 loff_t length = process->getSyscallArg(tc, index, 64);
484
485 int result = ftruncate64(fd, length);
486 return (result == -1) ? -errno : result;
487}
488
489SyscallReturn
490umaskFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
491{
492 // Letting the simulated program change the simulator's umask seems like
493 // a bad idea. Compromise by just returning the current umask but not
494 // changing anything.
495 mode_t oldMask = umask(0);
496 umask(oldMask);
497 return (int)oldMask;
498}
499
500SyscallReturn
501chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
502{
503 string path;
504
505 int index = 0;
506 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
507 return -EFAULT;
508
509 /* XXX endianess */
510 uint32_t owner = p->getSyscallArg(tc, index);
511 uid_t hostOwner = owner;
512 uint32_t group = p->getSyscallArg(tc, index);
513 gid_t hostGroup = group;
514
515 // Adjust path for current working directory
516 path = p->fullPath(path);
517
518 int result = chown(path.c_str(), hostOwner, hostGroup);
519 return (result == -1) ? -errno : result;
520}
521
522SyscallReturn
523fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
524{
525 int index = 0;
526 int fd = process->sim_fd(process->getSyscallArg(tc, index));
527
528 if (fd < 0)
529 return -EBADF;
530
531 /* XXX endianess */
532 uint32_t owner = process->getSyscallArg(tc, index);
533 uid_t hostOwner = owner;
534 uint32_t group = process->getSyscallArg(tc, index);
535 gid_t hostGroup = group;
536
537 int result = fchown(fd, hostOwner, hostGroup);
538 return (result == -1) ? -errno : result;
539}
540
541
542SyscallReturn
543dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
544{
545 int index = 0;
546 int fd = process->sim_fd(process->getSyscallArg(tc, index));
547 if (fd < 0)
548 return -EBADF;
549
550 Process::FdMap *fdo = process->sim_fd_obj(fd);
551
552 int result = dup(fd);
553 return (result == -1) ? -errno :
554 process->alloc_fd(result, fdo->filename, fdo->flags, fdo->mode, false);
555}
556
557
558SyscallReturn
559fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process,
560 ThreadContext *tc)
561{
562 int index = 0;
563 int fd = process->getSyscallArg(tc, index);
564
565 if (fd < 0 || process->sim_fd(fd) < 0)
566 return -EBADF;
567
568 int cmd = process->getSyscallArg(tc, index);
569 switch (cmd) {
570 case 0: // F_DUPFD
571 // if we really wanted to support this, we'd need to do it
572 // in the target fd space.
573 warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd);
574 return -EMFILE;
575
576 case 1: // F_GETFD (get close-on-exec flag)
577 case 2: // F_SETFD (set close-on-exec flag)
578 return 0;
579
580 case 3: // F_GETFL (get file flags)
581 case 4: // F_SETFL (set file flags)
582 // not sure if this is totally valid, but we'll pass it through
583 // to the underlying OS
584 warn("fcntl(%d, %d) passed through to host\n", fd, cmd);
585 return fcntl(process->sim_fd(fd), cmd);
586 // return 0;
587
588 case 7: // F_GETLK (get lock)
589 case 8: // F_SETLK (set lock)
590 case 9: // F_SETLKW (set lock and wait)
591 // don't mess with file locking... just act like it's OK
592 warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd);
593 return 0;
594
595 default:
596 warn("Unknown fcntl command %d\n", cmd);
597 return 0;
598 }
599}
600
601SyscallReturn
602fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process,
603 ThreadContext *tc)
604{
605 int index = 0;
606 int fd = process->getSyscallArg(tc, index);
607
608 if (fd < 0 || process->sim_fd(fd) < 0)
609 return -EBADF;
610
611 int cmd = process->getSyscallArg(tc, index);
612 switch (cmd) {
613 case 33: //F_GETLK64
614 warn("fcntl64(%d, F_GETLK64) not supported, error returned\n", fd);
615 return -EMFILE;
616
617 case 34: // F_SETLK64
618 case 35: // F_SETLKW64
619 warn("fcntl64(%d, F_SETLK(W)64) not supported, error returned\n", fd);
620 return -EMFILE;
621
622 default:
623 // not sure if this is totally valid, but we'll pass it through
624 // to the underlying OS
625 warn("fcntl64(%d, %d) passed through to host\n", fd, cmd);
626 return fcntl(process->sim_fd(fd), cmd);
627 // return 0;
628 }
629}
630
631SyscallReturn
632pipePseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
633 ThreadContext *tc)
634{
635 int fds[2], sim_fds[2];
636 int pipe_retval = pipe(fds);
637
638 if (pipe_retval < 0) {
639 // error
640 return pipe_retval;
641 }
642
643 sim_fds[0] = process->alloc_fd(fds[0], "PIPE-READ", O_WRONLY, -1, true);
644 sim_fds[1] = process->alloc_fd(fds[1], "PIPE-WRITE", O_RDONLY, -1, true);
645
646 process->setReadPipeSource(sim_fds[0], sim_fds[1]);
647 // Alpha Linux convention for pipe() is that fd[0] is returned as
648 // the return value of the function, and fd[1] is returned in r20.
649 tc->setIntReg(SyscallPseudoReturnReg, sim_fds[1]);
650 return sim_fds[0];
651}
652
653
654SyscallReturn
655getpidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
656 ThreadContext *tc)
657{
658 // Make up a PID. There's no interprocess communication in
659 // fake_syscall mode, so there's no way for a process to know it's
660 // not getting a unique value.
661
662 tc->setIntReg(SyscallPseudoReturnReg, process->ppid());
663 return process->pid();
664}
665
666
667SyscallReturn
668getuidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
669 ThreadContext *tc)
670{
671 // Make up a UID and EUID... it shouldn't matter, and we want the
672 // simulation to be deterministic.
673
674 // EUID goes in r20.
675 tc->setIntReg(SyscallPseudoReturnReg, process->euid()); //EUID
676 return process->uid(); // UID
677}
678
679
680SyscallReturn
681getgidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
682 ThreadContext *tc)
683{
684 // Get current group ID. EGID goes in r20.
685 tc->setIntReg(SyscallPseudoReturnReg, process->egid()); //EGID
686 return process->gid();
687}
688
689
690SyscallReturn
691setuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
692 ThreadContext *tc)
693{
694 // can't fathom why a benchmark would call this.
695 int index = 0;
696 warn("Ignoring call to setuid(%d)\n", process->getSyscallArg(tc, index));
697 return 0;
698}
699
700SyscallReturn
701getpidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
702 ThreadContext *tc)
703{
704 // Make up a PID. There's no interprocess communication in
705 // fake_syscall mode, so there's no way for a process to know it's
706 // not getting a unique value.
707
708 tc->setIntReg(SyscallPseudoReturnReg, process->ppid()); //PID
709 return process->pid();
710}
711
712SyscallReturn
713getppidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
714 ThreadContext *tc)
715{
716 return process->ppid();
717}
718
719SyscallReturn
720getuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
721 ThreadContext *tc)
722{
723 return process->uid(); // UID
724}
725
726SyscallReturn
727geteuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
728 ThreadContext *tc)
729{
730 return process->euid(); // UID
731}
732
733SyscallReturn
734getgidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
735 ThreadContext *tc)
736{
737 return process->gid();
738}
739
740SyscallReturn
741getegidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
742 ThreadContext *tc)
743{
744 return process->egid();
745}
746
747
748SyscallReturn
749cloneFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
750 ThreadContext *tc)
751{
752 int index = 0;
753 IntReg flags = process->getSyscallArg(tc, index);
754 IntReg newStack = process->getSyscallArg(tc, index);
755
756 DPRINTF(SyscallVerbose, "In sys_clone:\n");
757 DPRINTF(SyscallVerbose, " Flags=%llx\n", flags);
758 DPRINTF(SyscallVerbose, " Child stack=%llx\n", newStack);
759
760
761 if (flags != 0x10f00) {
762 warn("This sys_clone implementation assumes flags "
763 "CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD "
764 "(0x10f00), and may not work correctly with given flags "
765 "0x%llx\n", flags);
766 }
767
768 ThreadContext* ctc; // child thread context
769 if ( ( ctc = process->findFreeContext() ) != NULL ) {
770 DPRINTF(SyscallVerbose, " Found unallocated thread context\n");
771
772 ctc->clearArchRegs();
773
774 // Arch-specific cloning code
775 #if THE_ISA == ALPHA_ISA or THE_ISA == X86_ISA
776 // Cloning the misc. regs for these archs is enough
777 TheISA::copyMiscRegs(tc, ctc);
778 #elif THE_ISA == SPARC_ISA
779 TheISA::copyRegs(tc, ctc);
780
781 // TODO: Explain what this code actually does :-)
782 ctc->setIntReg(NumIntArchRegs + 6, 0);
783 ctc->setIntReg(NumIntArchRegs + 4, 0);
784 ctc->setIntReg(NumIntArchRegs + 3, NWindows - 2);
785 ctc->setIntReg(NumIntArchRegs + 5, NWindows);
786 ctc->setMiscReg(MISCREG_CWP, 0);
787 ctc->setIntReg(NumIntArchRegs + 7, 0);
788 ctc->setMiscRegNoEffect(MISCREG_TL, 0);
789 ctc->setMiscRegNoEffect(MISCREG_ASI, ASI_PRIMARY);
790
791 for (int y = 8; y < 32; y++)
792 ctc->setIntReg(y, tc->readIntReg(y));
793 #else
794 fatal("sys_clone is not implemented for this ISA\n");
795 #endif
796
797 // Set up stack register
798 ctc->setIntReg(TheISA::StackPointerReg, newStack);
799
800 // Set up syscall return values in parent and child
801 ctc->setIntReg(ReturnValueReg, 0); // return value, child
802
803 // Alpha needs SyscallSuccessReg=0 in child
804 #if THE_ISA == ALPHA_ISA
805 ctc->setIntReg(TheISA::SyscallSuccessReg, 0);
806 #endif
807
808 // In SPARC/Linux, clone returns 0 on pseudo-return register if
809 // parent, non-zero if child
810 #if THE_ISA == SPARC_ISA
811 tc->setIntReg(TheISA::SyscallPseudoReturnReg, 0);
812 ctc->setIntReg(TheISA::SyscallPseudoReturnReg, 1);
813 #endif
814
815 ctc->setPC(tc->readNextPC());
816 ctc->setNextPC(tc->readNextPC() + sizeof(TheISA::MachInst));
817 ctc->setNextNPC(tc->readNextNPC() + sizeof(TheISA::MachInst));
818
819 ctc->activate();
820
821 // Should return nonzero child TID in parent's syscall return register,
822 // but for our pthread library any non-zero value will work
823 return 1;
824 } else {
825 fatal("Called sys_clone, but no unallocated thread contexts found!\n");
826 return 0;
827 }
828}
829
| 310 Addr bufPtr = p->getSyscallArg(tc, index);
311 unsigned long size = p->getSyscallArg(tc, index);
312 BufferArg buf(bufPtr, size);
313
314 // Is current working directory defined?
315 string cwd = p->getcwd();
316 if (!cwd.empty()) {
317 if (cwd.length() >= size) {
318 // Buffer too small
319 return -ERANGE;
320 }
321 strncpy((char *)buf.bufferPtr(), cwd.c_str(), size);
322 result = cwd.length();
323 }
324 else {
325 if (getcwd((char *)buf.bufferPtr(), size) != NULL) {
326 result = strlen((char *)buf.bufferPtr());
327 }
328 else {
329 result = -1;
330 }
331 }
332
333 buf.copyOut(tc->getMemPort());
334
335 return (result == -1) ? -errno : result;
336}
337
338
339SyscallReturn
340readlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
341{
342 string path;
343
344 int index = 0;
345 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
346 return (TheISA::IntReg)-EFAULT;
347
348 // Adjust path for current working directory
349 path = p->fullPath(path);
350
351 Addr bufPtr = p->getSyscallArg(tc, index);
352 size_t bufsiz = p->getSyscallArg(tc, index);
353
354 BufferArg buf(bufPtr, bufsiz);
355
356 int result = readlink(path.c_str(), (char *)buf.bufferPtr(), bufsiz);
357
358 buf.copyOut(tc->getMemPort());
359
360 return (result == -1) ? -errno : result;
361}
362
363SyscallReturn
364unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
365{
366 string path;
367
368 int index = 0;
369 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
370 return (TheISA::IntReg)-EFAULT;
371
372 // Adjust path for current working directory
373 path = p->fullPath(path);
374
375 int result = unlink(path.c_str());
376 return (result == -1) ? -errno : result;
377}
378
379
380SyscallReturn
381mkdirFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
382{
383 string path;
384
385 int index = 0;
386 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
387 return (TheISA::IntReg)-EFAULT;
388
389 // Adjust path for current working directory
390 path = p->fullPath(path);
391
392 mode_t mode = p->getSyscallArg(tc, index);
393
394 int result = mkdir(path.c_str(), mode);
395 return (result == -1) ? -errno : result;
396}
397
398SyscallReturn
399renameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
400{
401 string old_name;
402
403 int index = 0;
404 if (!tc->getMemPort()->tryReadString(old_name, p->getSyscallArg(tc, index)))
405 return -EFAULT;
406
407 string new_name;
408
409 if (!tc->getMemPort()->tryReadString(new_name, p->getSyscallArg(tc, index)))
410 return -EFAULT;
411
412 // Adjust path for current working directory
413 old_name = p->fullPath(old_name);
414 new_name = p->fullPath(new_name);
415
416 int64_t result = rename(old_name.c_str(), new_name.c_str());
417 return (result == -1) ? -errno : result;
418}
419
420SyscallReturn
421truncateFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
422{
423 string path;
424
425 int index = 0;
426 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
427 return -EFAULT;
428
429 off_t length = p->getSyscallArg(tc, index);
430
431 // Adjust path for current working directory
432 path = p->fullPath(path);
433
434 int result = truncate(path.c_str(), length);
435 return (result == -1) ? -errno : result;
436}
437
438SyscallReturn
439ftruncateFunc(SyscallDesc *desc, int num,
440 LiveProcess *process, ThreadContext *tc)
441{
442 int index = 0;
443 int fd = process->sim_fd(process->getSyscallArg(tc, index));
444
445 if (fd < 0)
446 return -EBADF;
447
448 off_t length = process->getSyscallArg(tc, index);
449
450 int result = ftruncate(fd, length);
451 return (result == -1) ? -errno : result;
452}
453
454SyscallReturn
455truncate64Func(SyscallDesc *desc, int num,
456 LiveProcess *process, ThreadContext *tc)
457{
458 int index = 0;
459 string path;
460
461 if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, index)))
462 return -EFAULT;
463
464 loff_t length = process->getSyscallArg(tc, index, 64);
465
466 // Adjust path for current working directory
467 path = process->fullPath(path);
468
469 int result = truncate64(path.c_str(), length);
470 return (result == -1) ? -errno : result;
471}
472
473SyscallReturn
474ftruncate64Func(SyscallDesc *desc, int num,
475 LiveProcess *process, ThreadContext *tc)
476{
477 int index = 0;
478 int fd = process->sim_fd(process->getSyscallArg(tc, index));
479
480 if (fd < 0)
481 return -EBADF;
482
483 loff_t length = process->getSyscallArg(tc, index, 64);
484
485 int result = ftruncate64(fd, length);
486 return (result == -1) ? -errno : result;
487}
488
489SyscallReturn
490umaskFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
491{
492 // Letting the simulated program change the simulator's umask seems like
493 // a bad idea. Compromise by just returning the current umask but not
494 // changing anything.
495 mode_t oldMask = umask(0);
496 umask(oldMask);
497 return (int)oldMask;
498}
499
500SyscallReturn
501chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
502{
503 string path;
504
505 int index = 0;
506 if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
507 return -EFAULT;
508
509 /* XXX endianess */
510 uint32_t owner = p->getSyscallArg(tc, index);
511 uid_t hostOwner = owner;
512 uint32_t group = p->getSyscallArg(tc, index);
513 gid_t hostGroup = group;
514
515 // Adjust path for current working directory
516 path = p->fullPath(path);
517
518 int result = chown(path.c_str(), hostOwner, hostGroup);
519 return (result == -1) ? -errno : result;
520}
521
522SyscallReturn
523fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
524{
525 int index = 0;
526 int fd = process->sim_fd(process->getSyscallArg(tc, index));
527
528 if (fd < 0)
529 return -EBADF;
530
531 /* XXX endianess */
532 uint32_t owner = process->getSyscallArg(tc, index);
533 uid_t hostOwner = owner;
534 uint32_t group = process->getSyscallArg(tc, index);
535 gid_t hostGroup = group;
536
537 int result = fchown(fd, hostOwner, hostGroup);
538 return (result == -1) ? -errno : result;
539}
540
541
542SyscallReturn
543dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
544{
545 int index = 0;
546 int fd = process->sim_fd(process->getSyscallArg(tc, index));
547 if (fd < 0)
548 return -EBADF;
549
550 Process::FdMap *fdo = process->sim_fd_obj(fd);
551
552 int result = dup(fd);
553 return (result == -1) ? -errno :
554 process->alloc_fd(result, fdo->filename, fdo->flags, fdo->mode, false);
555}
556
557
558SyscallReturn
559fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process,
560 ThreadContext *tc)
561{
562 int index = 0;
563 int fd = process->getSyscallArg(tc, index);
564
565 if (fd < 0 || process->sim_fd(fd) < 0)
566 return -EBADF;
567
568 int cmd = process->getSyscallArg(tc, index);
569 switch (cmd) {
570 case 0: // F_DUPFD
571 // if we really wanted to support this, we'd need to do it
572 // in the target fd space.
573 warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd);
574 return -EMFILE;
575
576 case 1: // F_GETFD (get close-on-exec flag)
577 case 2: // F_SETFD (set close-on-exec flag)
578 return 0;
579
580 case 3: // F_GETFL (get file flags)
581 case 4: // F_SETFL (set file flags)
582 // not sure if this is totally valid, but we'll pass it through
583 // to the underlying OS
584 warn("fcntl(%d, %d) passed through to host\n", fd, cmd);
585 return fcntl(process->sim_fd(fd), cmd);
586 // return 0;
587
588 case 7: // F_GETLK (get lock)
589 case 8: // F_SETLK (set lock)
590 case 9: // F_SETLKW (set lock and wait)
591 // don't mess with file locking... just act like it's OK
592 warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd);
593 return 0;
594
595 default:
596 warn("Unknown fcntl command %d\n", cmd);
597 return 0;
598 }
599}
600
601SyscallReturn
602fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process,
603 ThreadContext *tc)
604{
605 int index = 0;
606 int fd = process->getSyscallArg(tc, index);
607
608 if (fd < 0 || process->sim_fd(fd) < 0)
609 return -EBADF;
610
611 int cmd = process->getSyscallArg(tc, index);
612 switch (cmd) {
613 case 33: //F_GETLK64
614 warn("fcntl64(%d, F_GETLK64) not supported, error returned\n", fd);
615 return -EMFILE;
616
617 case 34: // F_SETLK64
618 case 35: // F_SETLKW64
619 warn("fcntl64(%d, F_SETLK(W)64) not supported, error returned\n", fd);
620 return -EMFILE;
621
622 default:
623 // not sure if this is totally valid, but we'll pass it through
624 // to the underlying OS
625 warn("fcntl64(%d, %d) passed through to host\n", fd, cmd);
626 return fcntl(process->sim_fd(fd), cmd);
627 // return 0;
628 }
629}
630
631SyscallReturn
632pipePseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
633 ThreadContext *tc)
634{
635 int fds[2], sim_fds[2];
636 int pipe_retval = pipe(fds);
637
638 if (pipe_retval < 0) {
639 // error
640 return pipe_retval;
641 }
642
643 sim_fds[0] = process->alloc_fd(fds[0], "PIPE-READ", O_WRONLY, -1, true);
644 sim_fds[1] = process->alloc_fd(fds[1], "PIPE-WRITE", O_RDONLY, -1, true);
645
646 process->setReadPipeSource(sim_fds[0], sim_fds[1]);
647 // Alpha Linux convention for pipe() is that fd[0] is returned as
648 // the return value of the function, and fd[1] is returned in r20.
649 tc->setIntReg(SyscallPseudoReturnReg, sim_fds[1]);
650 return sim_fds[0];
651}
652
653
654SyscallReturn
655getpidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
656 ThreadContext *tc)
657{
658 // Make up a PID. There's no interprocess communication in
659 // fake_syscall mode, so there's no way for a process to know it's
660 // not getting a unique value.
661
662 tc->setIntReg(SyscallPseudoReturnReg, process->ppid());
663 return process->pid();
664}
665
666
667SyscallReturn
668getuidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
669 ThreadContext *tc)
670{
671 // Make up a UID and EUID... it shouldn't matter, and we want the
672 // simulation to be deterministic.
673
674 // EUID goes in r20.
675 tc->setIntReg(SyscallPseudoReturnReg, process->euid()); //EUID
676 return process->uid(); // UID
677}
678
679
680SyscallReturn
681getgidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
682 ThreadContext *tc)
683{
684 // Get current group ID. EGID goes in r20.
685 tc->setIntReg(SyscallPseudoReturnReg, process->egid()); //EGID
686 return process->gid();
687}
688
689
690SyscallReturn
691setuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
692 ThreadContext *tc)
693{
694 // can't fathom why a benchmark would call this.
695 int index = 0;
696 warn("Ignoring call to setuid(%d)\n", process->getSyscallArg(tc, index));
697 return 0;
698}
699
700SyscallReturn
701getpidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
702 ThreadContext *tc)
703{
704 // Make up a PID. There's no interprocess communication in
705 // fake_syscall mode, so there's no way for a process to know it's
706 // not getting a unique value.
707
708 tc->setIntReg(SyscallPseudoReturnReg, process->ppid()); //PID
709 return process->pid();
710}
711
712SyscallReturn
713getppidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
714 ThreadContext *tc)
715{
716 return process->ppid();
717}
718
719SyscallReturn
720getuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
721 ThreadContext *tc)
722{
723 return process->uid(); // UID
724}
725
726SyscallReturn
727geteuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
728 ThreadContext *tc)
729{
730 return process->euid(); // UID
731}
732
733SyscallReturn
734getgidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
735 ThreadContext *tc)
736{
737 return process->gid();
738}
739
740SyscallReturn
741getegidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
742 ThreadContext *tc)
743{
744 return process->egid();
745}
746
747
748SyscallReturn
749cloneFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
750 ThreadContext *tc)
751{
752 int index = 0;
753 IntReg flags = process->getSyscallArg(tc, index);
754 IntReg newStack = process->getSyscallArg(tc, index);
755
756 DPRINTF(SyscallVerbose, "In sys_clone:\n");
757 DPRINTF(SyscallVerbose, " Flags=%llx\n", flags);
758 DPRINTF(SyscallVerbose, " Child stack=%llx\n", newStack);
759
760
761 if (flags != 0x10f00) {
762 warn("This sys_clone implementation assumes flags "
763 "CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD "
764 "(0x10f00), and may not work correctly with given flags "
765 "0x%llx\n", flags);
766 }
767
768 ThreadContext* ctc; // child thread context
769 if ( ( ctc = process->findFreeContext() ) != NULL ) {
770 DPRINTF(SyscallVerbose, " Found unallocated thread context\n");
771
772 ctc->clearArchRegs();
773
774 // Arch-specific cloning code
775 #if THE_ISA == ALPHA_ISA or THE_ISA == X86_ISA
776 // Cloning the misc. regs for these archs is enough
777 TheISA::copyMiscRegs(tc, ctc);
778 #elif THE_ISA == SPARC_ISA
779 TheISA::copyRegs(tc, ctc);
780
781 // TODO: Explain what this code actually does :-)
782 ctc->setIntReg(NumIntArchRegs + 6, 0);
783 ctc->setIntReg(NumIntArchRegs + 4, 0);
784 ctc->setIntReg(NumIntArchRegs + 3, NWindows - 2);
785 ctc->setIntReg(NumIntArchRegs + 5, NWindows);
786 ctc->setMiscReg(MISCREG_CWP, 0);
787 ctc->setIntReg(NumIntArchRegs + 7, 0);
788 ctc->setMiscRegNoEffect(MISCREG_TL, 0);
789 ctc->setMiscRegNoEffect(MISCREG_ASI, ASI_PRIMARY);
790
791 for (int y = 8; y < 32; y++)
792 ctc->setIntReg(y, tc->readIntReg(y));
793 #else
794 fatal("sys_clone is not implemented for this ISA\n");
795 #endif
796
797 // Set up stack register
798 ctc->setIntReg(TheISA::StackPointerReg, newStack);
799
800 // Set up syscall return values in parent and child
801 ctc->setIntReg(ReturnValueReg, 0); // return value, child
802
803 // Alpha needs SyscallSuccessReg=0 in child
804 #if THE_ISA == ALPHA_ISA
805 ctc->setIntReg(TheISA::SyscallSuccessReg, 0);
806 #endif
807
808 // In SPARC/Linux, clone returns 0 on pseudo-return register if
809 // parent, non-zero if child
810 #if THE_ISA == SPARC_ISA
811 tc->setIntReg(TheISA::SyscallPseudoReturnReg, 0);
812 ctc->setIntReg(TheISA::SyscallPseudoReturnReg, 1);
813 #endif
814
815 ctc->setPC(tc->readNextPC());
816 ctc->setNextPC(tc->readNextPC() + sizeof(TheISA::MachInst));
817 ctc->setNextNPC(tc->readNextNPC() + sizeof(TheISA::MachInst));
818
819 ctc->activate();
820
821 // Should return nonzero child TID in parent's syscall return register,
822 // but for our pthread library any non-zero value will work
823 return 1;
824 } else {
825 fatal("Called sys_clone, but no unallocated thread contexts found!\n");
826 return 0;
827 }
828}
829
|