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