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