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