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 <string>
36#include <iostream>
37
38#include "sim/syscall_emul.hh"
39#include "base/chunk_generator.hh"
40#include "base/trace.hh"
41#include "cpu/thread_context.hh"
42#include "cpu/base.hh"
43#include "mem/page_table.hh"
44#include "sim/process.hh"
45
46#include "sim/sim_exit.hh"
47
48using namespace std;
49using namespace TheISA;
50
51void
52SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc)
53{
54 DPRINTFR(SyscallVerbose, "%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n",
55 curTick,tc->getCpuPtr()->name(), name,
56 tc->getSyscallArg(0),tc->getSyscallArg(1),
57 tc->getSyscallArg(2),tc->getSyscallArg(3));
58
59 SyscallReturn retval = (*funcPtr)(this, callnum, process, tc);
60
61 DPRINTFR(SyscallVerbose, "%d: %s: syscall %s returns %d\n",
62 curTick,tc->getCpuPtr()->name(), name, retval.value());
63
64 if (!(flags & SyscallDesc::SuppressReturnValue))
65 tc->setSyscallReturn(retval);
66}
67
68
69SyscallReturn
70unimplementedFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
71 ThreadContext *tc)
72{
73 fatal("syscall %s (#%d) unimplemented.", desc->name, callnum);
74
75 return 1;
76}
77
78
79SyscallReturn
80ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
81 ThreadContext *tc)
82{
83 warn("ignoring syscall %s(%d, %d, ...)", desc->name,
84 tc->getSyscallArg(0), tc->getSyscallArg(1));
85
86 return 0;
87}
88
89
90SyscallReturn
91exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
92 ThreadContext *tc)
93{
94 if (tc->exit()) {
95 exitSimLoop("target called exit()", tc->getSyscallArg(0) & 0xff);
96 }
97
98 return 1;
99}
100
101
102SyscallReturn
103getpagesizeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
104{
105 return (int)VMPageSize;
106}
107
108
109SyscallReturn
110brkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
111{
112 // change brk addr to first arg
113 Addr new_brk = tc->getSyscallArg(0);
114
115 // in Linux at least, brk(0) returns the current break value
116 // (note that the syscall and the glibc function have different behavior)
117 if (new_brk == 0)
118 return p->brk_point;
119
120 if (new_brk > p->brk_point) {
121 // might need to allocate some new pages
122 for (ChunkGenerator gen(p->brk_point, new_brk - p->brk_point,
123 VMPageSize); !gen.done(); gen.next()) {
124 if (!p->pTable->translate(gen.addr()))
125 p->pTable->allocate(roundDown(gen.addr(), VMPageSize),
126 VMPageSize);
127 }
128 }
129
130 p->brk_point = new_brk;
131 DPRINTF(SyscallVerbose, "Break Point changed to: %#X\n", p->brk_point);
132 return p->brk_point;
133}
134
135
136SyscallReturn
137closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
138{
139 int target_fd = tc->getSyscallArg(0);
140 int status = close(p->sim_fd(target_fd));
141 if (status >= 0)
142 p->free_fd(target_fd);
143 return status;
144}
145
146
147SyscallReturn
148readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
149{
150 int fd = p->sim_fd(tc->getSyscallArg(0));
151 int nbytes = tc->getSyscallArg(2);
152 BufferArg bufArg(tc->getSyscallArg(1), nbytes);
153
154 int bytes_read = read(fd, bufArg.bufferPtr(), nbytes);
155
156 if (bytes_read != -1)
157 bufArg.copyOut(tc->getMemPort());
158
159 return bytes_read;
160}
161
162SyscallReturn
163writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
164{
165 int fd = p->sim_fd(tc->getSyscallArg(0));
166 int nbytes = tc->getSyscallArg(2);
167 BufferArg bufArg(tc->getSyscallArg(1), nbytes);
168
169 bufArg.copyIn(tc->getMemPort());
170
171 int bytes_written = write(fd, bufArg.bufferPtr(), nbytes);
172
173 fsync(fd);
174
175 return bytes_written;
176}
177
178
179SyscallReturn
180lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
181{
182 int fd = p->sim_fd(tc->getSyscallArg(0));
183 uint64_t offs = tc->getSyscallArg(1);
184 int whence = tc->getSyscallArg(2);
185
186 off_t result = lseek(fd, offs, whence);
187
188 return (result == (off_t)-1) ? -errno : result;
189}
190
191
192SyscallReturn
193_llseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
194{
195 int fd = p->sim_fd(tc->getSyscallArg(0));
196 uint64_t offset_high = tc->getSyscallArg(1);
197 uint32_t offset_low = tc->getSyscallArg(2);
198 Addr result_ptr = tc->getSyscallArg(3);
199 int whence = tc->getSyscallArg(4);
200
201 uint64_t offset = (offset_high << 32) | offset_low;
202
203 uint64_t result = lseek(fd, offset, whence);
204 result = TheISA::htog(result);
205
206 if (result == (off_t)-1) {
207 //The seek failed.
208 return -errno;
209 } else {
210 //The seek succeeded.
211 //Copy "result" to "result_ptr"
212 //XXX We'll assume that the size of loff_t is 64 bits on the
213 //target platform
214 BufferArg result_buf(result_ptr, sizeof(result));
215 memcpy(result_buf.bufferPtr(), &result, sizeof(result));
216 result_buf.copyOut(tc->getMemPort());
217 return 0;
218 }
219
220
221 return (result == (off_t)-1) ? -errno : result;
222}
223
224
225SyscallReturn
226munmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
227{
228 // given that we don't really implement mmap, munmap is really easy
229 return 0;
230}
231
232
233const char *hostname = "m5.eecs.umich.edu";
234
235SyscallReturn
236gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
237{
238 int name_len = tc->getSyscallArg(1);
239 BufferArg name(tc->getSyscallArg(0), name_len);
240
241 strncpy((char *)name.bufferPtr(), hostname, name_len);
242
243 name.copyOut(tc->getMemPort());
244
245 return 0;
246}
247
248SyscallReturn
249getcwdFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
250{
251 int result = 0;
252 unsigned long size = tc->getSyscallArg(1);
253 BufferArg buf(tc->getSyscallArg(0), size);
254
255 // Is current working directory defined?
256 string cwd = p->getcwd();
257 if (!cwd.empty()) {
258 if (cwd.length() >= size) {
259 // Buffer too small
260 return -ERANGE;
261 }
262 strncpy((char *)buf.bufferPtr(), cwd.c_str(), size);
263 result = cwd.length();
264 }
265 else {
266 if (getcwd((char *)buf.bufferPtr(), size) != NULL) {
267 result = strlen((char *)buf.bufferPtr());
268 }
269 else {
270 result = -1;
271 }
272 }
273
274 buf.copyOut(tc->getMemPort());
275
276 return (result == -1) ? -errno : result;
277}
278
279
280SyscallReturn
281readlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
282{
283 string path;
284
285 if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
286 return (TheISA::IntReg)-EFAULT;
287
288 // Adjust path for current working directory
289 path = p->fullPath(path);
290
291 size_t bufsiz = tc->getSyscallArg(2);
292 BufferArg buf(tc->getSyscallArg(1), bufsiz);
293
294 int result = readlink(path.c_str(), (char *)buf.bufferPtr(), bufsiz);
295
296 buf.copyOut(tc->getMemPort());
297
298 return (result == -1) ? -errno : result;
299}
300
301SyscallReturn
302unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
303{
304 string path;
305
306 if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
307 return (TheISA::IntReg)-EFAULT;
308
309 // Adjust path for current working directory
310 path = p->fullPath(path);
311
312 int result = unlink(path.c_str());
313 return (result == -1) ? -errno : result;
314}
315
316
317SyscallReturn
318mkdirFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
319{
320 string path;
321
322 if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
323 return (TheISA::IntReg)-EFAULT;
324
325 // Adjust path for current working directory
326 path = p->fullPath(path);
327
328 mode_t mode = tc->getSyscallArg(1);
329
330 int result = mkdir(path.c_str(), mode);
331 return (result == -1) ? -errno : result;
332}
333
334SyscallReturn
335renameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
336{
337 string old_name;
338
339 if (!tc->getMemPort()->tryReadString(old_name, tc->getSyscallArg(0)))
340 return -EFAULT;
341
342 string new_name;
343
344 if (!tc->getMemPort()->tryReadString(new_name, tc->getSyscallArg(1)))
345 return -EFAULT;
346
347 // Adjust path for current working directory
348 old_name = p->fullPath(old_name);
349 new_name = p->fullPath(new_name);
350
351 int64_t result = rename(old_name.c_str(), new_name.c_str());
352 return (result == -1) ? -errno : result;
353}
354
355SyscallReturn
356truncateFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
357{
358 string path;
359
360 if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
361 return -EFAULT;
362
363 off_t length = tc->getSyscallArg(1);
364
365 // Adjust path for current working directory
366 path = p->fullPath(path);
367
368 int result = truncate(path.c_str(), length);
369 return (result == -1) ? -errno : result;
370}
371
372SyscallReturn
373ftruncateFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
374{
375 int fd = process->sim_fd(tc->getSyscallArg(0));
376
377 if (fd < 0)
378 return -EBADF;
379
380 off_t length = tc->getSyscallArg(1);
381
382 int result = ftruncate(fd, length);
383 return (result == -1) ? -errno : result;
384}
385
386SyscallReturn
387umaskFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
388{
389 // Letting the simulated program change the simulator's umask seems like
390 // a bad idea. Compromise by just returning the current umask but not
391 // changing anything.
392 mode_t oldMask = umask(0);
393 umask(oldMask);
394 return (int)oldMask;
395}
396
397SyscallReturn
398chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
399{
400 string path;
401
402 if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
403 return -EFAULT;
404
405 /* XXX endianess */
406 uint32_t owner = tc->getSyscallArg(1);
407 uid_t hostOwner = owner;
408 uint32_t group = tc->getSyscallArg(2);
409 gid_t hostGroup = group;
410
411 // Adjust path for current working directory
412 path = p->fullPath(path);
413
414 int result = chown(path.c_str(), hostOwner, hostGroup);
415 return (result == -1) ? -errno : result;
416}
417
418SyscallReturn
419fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
420{
421 int fd = process->sim_fd(tc->getSyscallArg(0));
422
423 if (fd < 0)
424 return -EBADF;
425
426 /* XXX endianess */
427 uint32_t owner = tc->getSyscallArg(1);
428 uid_t hostOwner = owner;
429 uint32_t group = tc->getSyscallArg(2);
430 gid_t hostGroup = group;
431
432 int result = fchown(fd, hostOwner, hostGroup);
433 return (result == -1) ? -errno : result;
434}
435
436
437SyscallReturn
438dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
439{
440 int fd = process->sim_fd(tc->getSyscallArg(0));
441 if (fd < 0)
442 return -EBADF;
443
444 Process::FdMap *fdo = process->sim_fd_obj(tc->getSyscallArg(0));
445
446 int result = dup(fd);
447 return (result == -1) ? -errno : process->alloc_fd(result, fdo->filename, fdo->flags, fdo->mode, false);
448}
449
450
451SyscallReturn
452fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process,
453 ThreadContext *tc)
454{
455 int fd = tc->getSyscallArg(0);
456
457 if (fd < 0 || process->sim_fd(fd) < 0)
458 return -EBADF;
459
460 int cmd = tc->getSyscallArg(1);
461 switch (cmd) {
462 case 0: // F_DUPFD
463 // if we really wanted to support this, we'd need to do it
464 // in the target fd space.
465 warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd);
466 return -EMFILE;
467
468 case 1: // F_GETFD (get close-on-exec flag)
469 case 2: // F_SETFD (set close-on-exec flag)
470 return 0;
471
472 case 3: // F_GETFL (get file flags)
473 case 4: // F_SETFL (set file flags)
474 // not sure if this is totally valid, but we'll pass it through
475 // to the underlying OS
476 warn("fcntl(%d, %d) passed through to host\n", fd, cmd);
477 return fcntl(process->sim_fd(fd), cmd);
478 // return 0;
479
480 case 7: // F_GETLK (get lock)
481 case 8: // F_SETLK (set lock)
482 case 9: // F_SETLKW (set lock and wait)
483 // don't mess with file locking... just act like it's OK
484 warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd);
485 return 0;
486
487 default:
488 warn("Unknown fcntl command %d\n", cmd);
489 return 0;
490 }
491}
492
493SyscallReturn
494fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process,
495 ThreadContext *tc)
496{
497 int fd = tc->getSyscallArg(0);
498
499 if (fd < 0 || process->sim_fd(fd) < 0)
500 return -EBADF;
501
502 int cmd = tc->getSyscallArg(1);
503 switch (cmd) {
504 case 33: //F_GETLK64
505 warn("fcntl64(%d, F_GETLK64) not supported, error returned\n", fd);
506 return -EMFILE;
507
508 case 34: // F_SETLK64
509 case 35: // F_SETLKW64
510 warn("fcntl64(%d, F_SETLK(W)64) not supported, error returned\n", fd);
511 return -EMFILE;
512
513 default:
514 // not sure if this is totally valid, but we'll pass it through
515 // to the underlying OS
516 warn("fcntl64(%d, %d) passed through to host\n", fd, cmd);
517 return fcntl(process->sim_fd(fd), cmd);
518 // return 0;
519 }
520}
521
522SyscallReturn
523pipePseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
524 ThreadContext *tc)
525{
526 int fds[2], sim_fds[2];
527 int pipe_retval = pipe(fds);
528
529 if (pipe_retval < 0) {
530 // error
531 return pipe_retval;
532 }
533
534 sim_fds[0] = process->alloc_fd(fds[0], "PIPE-READ", O_WRONLY, -1, true);
535 sim_fds[1] = process->alloc_fd(fds[1], "PIPE-WRITE", O_RDONLY, -1, true);
536
537 process->setReadPipeSource(sim_fds[0], sim_fds[1]);
538 // Alpha Linux convention for pipe() is that fd[0] is returned as
539 // the return value of the function, and fd[1] is returned in r20.
540 tc->setIntReg(SyscallPseudoReturnReg, sim_fds[1]);
541 return sim_fds[0];
542}
543
544
545SyscallReturn
546getpidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
547 ThreadContext *tc)
548{
549 // Make up a PID. There's no interprocess communication in
550 // fake_syscall mode, so there's no way for a process to know it's
551 // not getting a unique value.
552
553 tc->setIntReg(SyscallPseudoReturnReg, process->ppid());
554 return process->pid();
555}
556
557
558SyscallReturn
559getuidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
560 ThreadContext *tc)
561{
562 // Make up a UID and EUID... it shouldn't matter, and we want the
563 // simulation to be deterministic.
564
565 // EUID goes in r20.
566 tc->setIntReg(SyscallPseudoReturnReg, process->euid()); //EUID
567 return process->uid(); // UID
568}
569
570
571SyscallReturn
572getgidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
573 ThreadContext *tc)
574{
575 // Get current group ID. EGID goes in r20.
576 tc->setIntReg(SyscallPseudoReturnReg, process->egid()); //EGID
577 return process->gid();
578}
579
580
581SyscallReturn
582setuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
583 ThreadContext *tc)
584{
585 // can't fathom why a benchmark would call this.
586 warn("Ignoring call to setuid(%d)\n", tc->getSyscallArg(0));
587 return 0;
588}
589
590SyscallReturn
591getpidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
592 ThreadContext *tc)
593{
594 // Make up a PID. There's no interprocess communication in
595 // fake_syscall mode, so there's no way for a process to know it's
596 // not getting a unique value.
597
598 tc->setIntReg(SyscallPseudoReturnReg, process->ppid()); //PID
599 return process->pid();
600}
601
602SyscallReturn
603getppidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
604 ThreadContext *tc)
605{
606 return process->ppid();
607}
608
609SyscallReturn
610getuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
611 ThreadContext *tc)
612{
613 return process->uid(); // UID
614}
615
616SyscallReturn
617geteuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
618 ThreadContext *tc)
619{
620 return process->euid(); // UID
621}
622
623SyscallReturn
624getgidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
625 ThreadContext *tc)
626{
627 return process->gid();
628}
629
630SyscallReturn
631getegidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
632 ThreadContext *tc)
633{
634 return process->egid();
635}
636
637