src/sim/syscall_emul.hh

126 SyscallReturn unimplementedFunc(SyscallDesc *desc, int num, ThreadContext *tc);
132 SyscallReturn ignoreFunc(SyscallDesc *desc, int num, ThreadContext *tc);
135 SyscallReturn fallocateFunc(SyscallDesc *desc, int num, ThreadContext *tc);
138 SyscallReturn exitFunc(SyscallDesc *desc, int num, ThreadContext *tc);
141 SyscallReturn exitGroupFunc(SyscallDesc *desc, int num, ThreadContext *tc);
144 SyscallReturn setTidAddressFunc(SyscallDesc *desc, int num, ThreadContext *tc);
147 SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num, ThreadContext *tc);
150 SyscallReturn brkFunc(SyscallDesc *desc, int num, ThreadContext *tc);
153 SyscallReturn closeFunc(SyscallDesc *desc, int num, ThreadContext *tc);
156 SyscallReturn lseekFunc(SyscallDesc *desc, int num, ThreadContext *tc);
159 SyscallReturn _llseekFunc(SyscallDesc *desc, int num, ThreadContext *tc);
162 SyscallReturn munmapFunc(SyscallDesc *desc, int num, ThreadContext *tc);
165 SyscallReturn shutdownFunc(SyscallDesc *desc, int num, ThreadContext *tc);
168 SyscallReturn gethostnameFunc(SyscallDesc *desc, int num, ThreadContext *tc);
171 SyscallReturn getcwdFunc(SyscallDesc *desc, int num, ThreadContext *tc);
174 SyscallReturn readlinkFunc(SyscallDesc *desc, int num, ThreadContext *tc,
176 SyscallReturn readlinkFunc(SyscallDesc *desc, int num, ThreadContext *tc);
179 SyscallReturn unlinkHelper(SyscallDesc *desc, int num, ThreadContext *tc,
181 SyscallReturn unlinkFunc(SyscallDesc *desc, int num, ThreadContext *tc);
184 SyscallReturn linkFunc(SyscallDesc *desc, int num, ThreadContext *tc);
187 SyscallReturn symlinkFunc(SyscallDesc *desc, int num, ThreadContext *tc);
190 SyscallReturn mkdirFunc(SyscallDesc *desc, int num, ThreadContext *tc);
193 SyscallReturn mknodFunc(SyscallDesc *desc, int num, ThreadContext *tc);
196 SyscallReturn chdirFunc(SyscallDesc *desc, int num, ThreadContext *tc);
199 SyscallReturn rmdirFunc(SyscallDesc *desc, int num, ThreadContext *tc);
202 SyscallReturn renameFunc(SyscallDesc *desc, int num, ThreadContext *tc);
206 SyscallReturn truncateFunc(SyscallDesc *desc, int num, ThreadContext *tc);
210 SyscallReturn ftruncateFunc(SyscallDesc *desc, int num, ThreadContext *tc);
214 SyscallReturn truncate64Func(SyscallDesc *desc, int num, ThreadContext *tc);
217 SyscallReturn ftruncate64Func(SyscallDesc *desc, int num, ThreadContext *tc);
221 SyscallReturn umaskFunc(SyscallDesc *desc, int num, ThreadContext *tc);
224 SyscallReturn gettidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
227 SyscallReturn chownFunc(SyscallDesc *desc, int num, ThreadContext *tc);
230 SyscallReturn getpgrpFunc(SyscallDesc *desc, int num, ThreadContext *tc);
233 SyscallReturn setpgidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
236 SyscallReturn fchownFunc(SyscallDesc *desc, int num, ThreadContext *tc);
239 SyscallReturn dupFunc(SyscallDesc *desc, int num, ThreadContext *tc);
242 SyscallReturn dup2Func(SyscallDesc *desc, int num, ThreadContext *tc);
245 SyscallReturn fcntlFunc(SyscallDesc *desc, int num, ThreadContext *tc);
248 SyscallReturn fcntl64Func(SyscallDesc *desc, int num, ThreadContext *tc);
251 SyscallReturn setuidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
254 SyscallReturn pipeFunc(SyscallDesc *desc, int num, ThreadContext *tc);
257 SyscallReturn pipeImpl(SyscallDesc *desc, int num, ThreadContext *tc,
261 SyscallReturn pipe2Func(SyscallDesc *desc, int num, ThreadContext *tc);
264 SyscallReturn getpidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
267 SyscallReturn getpeernameFunc(SyscallDesc *desc, int num, ThreadContext *tc);
270 SyscallReturn bindFunc(SyscallDesc *desc, int num, ThreadContext *tc);
273 SyscallReturn listenFunc(SyscallDesc *desc, int num, ThreadContext *tc);
276 SyscallReturn connectFunc(SyscallDesc *desc, int num, ThreadContext *tc);
280 SyscallReturn getdentsFunc(SyscallDesc *desc, int num, ThreadContext *tc);
285 SyscallReturn getdents64Func(SyscallDesc *desc, int num, ThreadContext *tc);
289 SyscallReturn sendtoFunc(SyscallDesc *desc, int num, ThreadContext *tc);
292 SyscallReturn recvfromFunc(SyscallDesc *desc, int num, ThreadContext *tc);
295 SyscallReturn recvmsgFunc(SyscallDesc *desc, int num, ThreadContext *tc);
298 SyscallReturn sendmsgFunc(SyscallDesc *desc, int num, ThreadContext *tc);
301 SyscallReturn getuidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
304 SyscallReturn getgidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
307 SyscallReturn getppidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
310 SyscallReturn geteuidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
313 SyscallReturn getegidFunc(SyscallDesc *desc, int num, ThreadContext *tc);
316 SyscallReturn accessFunc(SyscallDesc *desc, int num, ThreadContext *tc);
317 SyscallReturn accessFunc(SyscallDesc *desc, int num, ThreadContext *tc,
321 SyscallReturn getsockoptFunc(SyscallDesc *desc, int num, ThreadContext *tc);
324 SyscallReturn setsockoptFunc(SyscallDesc *desc, int num, ThreadContext *tc);
327 SyscallReturn getsocknameFunc(SyscallDesc *desc, int num, ThreadContext *tc);
334 futexFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
339     auto process = tc->getProcessPtr();
341     Addr uaddr = process->getSyscallArg(tc, index);
342     int op = process->getSyscallArg(tc, index);
343     int val = process->getSyscallArg(tc, index);
344     int timeout M5_VAR_USED = process->getSyscallArg(tc, index);
345     Addr uaddr2 M5_VAR_USED = process->getSyscallArg(tc, index);
346     int val3 = process->getSyscallArg(tc, index);
355     FutexMap &futex_map = tc->getSystemPtr()->futexMap;
360         buf.copyIn(tc->getVirtProxy());
372             futex_map.suspend(uaddr, process->tgid(), tc);
374             futex_map.suspend_bitset(uaddr, process->tgid(), tc, val3);
387         buf.copyIn(tc->getVirtProxy());
420         buf.copyIn(tc->getVirtProxy());
444         buf.copyOut(tc->getVirtProxy());
475 SyscallReturn pipePseudoFunc(SyscallDesc *desc, int num, ThreadContext *tc);
478 SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num, ThreadContext *tc);
481 SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num, ThreadContext *tc);
484 SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num, ThreadContext *tc);
680 ioctlFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
683     auto p = tc->getProcessPtr();
685     int tgt_fd = p->getSyscallArg(tc, index);
686     unsigned req = p->getSyscallArg(tc, index);
697             return emul_driver->ioctl(tc, req);
706             Addr conf_addr = p->getSyscallArg(tc, index);
708             conf_arg.copyIn(tc->getVirtProxy());
713             ifc_buf_arg.copyIn(tc->getVirtProxy());
720                 ifc_buf_arg.copyOut(tc->getVirtProxy());
721                 conf_arg.copyOut(tc->getVirtProxy());
736             Addr req_addr = p->getSyscallArg(tc, index);
738             req_arg.copyIn(tc->getVirtProxy());
742                 req_arg.copyOut(tc->getVirtProxy());
753          tgt_fd, req, tc->pcState());
759 openImpl(SyscallDesc *desc, int callnum, ThreadContext *tc, bool isopenat)
762     auto p = tc->getProcessPtr();
770         tgt_dirfd = p->getSyscallArg(tc, index);
777     if (!tc->getVirtProxy().tryReadString(path, p->getSyscallArg(tc, index)))
789     int tgt_flags = p->getSyscallArg(tc, index);
804     int mode = p->getSyscallArg(tc, index);
845             return drv->open(tc, mode, host_flags);
883             sim_fd = OS::openSpecialFile(abs_path, p, tc);
918 openFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
920     return openImpl<OS>(desc, callnum, tc, false);
926 openatFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
928     return openImpl<OS>(desc, callnum, tc, true);
934 unlinkatFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
937     auto process = tc->getProcessPtr();
938     int dirfd = process->getSyscallArg(tc, index);
942     return unlinkHelper(desc, callnum, tc, 1);
948 faccessatFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
951     auto process = tc->getProcessPtr();
952     int dirfd = process->getSyscallArg(tc, index);
955     return accessFunc(desc, callnum, tc, 1);
961 readlinkatFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
964     auto process = tc->getProcessPtr();
965     int dirfd = process->getSyscallArg(tc, index);
968     return readlinkFunc(desc, callnum, tc, 1);
974 renameatFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
977     auto process = tc->getProcessPtr();
979     int olddirfd = process->getSyscallArg(tc, index);
985     if (!tc->getVirtProxy().tryReadString(old_name,
986                                          process->getSyscallArg(tc, index)))
989     int newdirfd = process->getSyscallArg(tc, index);
995     if (!tc->getVirtProxy().tryReadString(new_name,
996                                          process->getSyscallArg(tc, index)))
1010 sysinfoFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1013     auto process = tc->getProcessPtr();
1016         sysinfo(process->getSyscallArg(tc, index));
1022     sysinfo.copyOut(tc->getVirtProxy());
1030 chmodFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1033     auto process = tc->getProcessPtr();
1036     if (!tc->getVirtProxy().tryReadString(path,
1037                 process->getSyscallArg(tc, index))) {
1041     uint32_t mode = process->getSyscallArg(tc, index);
1060 pollFunc(SyscallDesc *desc, int num, ThreadContext *tc)
1063     auto p = tc->getProcessPtr();
1064     Addr fdsPtr = p->getSyscallArg(tc, index);
1065     int nfds = p->getSyscallArg(tc, index);
1066     int tmout = p->getSyscallArg(tc, index);
1069     fdsBuf.copyIn(tc->getVirtProxy());
1103             System *sysh = tc->getSystemPtr();
1129     fdsBuf.copyOut(tc->getVirtProxy());
1137 fchmodFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1140     auto p = tc->getProcessPtr();
1141     int tgt_fd = p->getSyscallArg(tc, index);
1142     uint32_t mode = p->getSyscallArg(tc, index);
1159 mremapFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1162     auto process = tc->getProcessPtr();
1163     Addr start = process->getSyscallArg(tc, index);
1164     uint64_t old_length = process->getSyscallArg(tc, index);
1165     uint64_t new_length = process->getSyscallArg(tc, index);
1166     uint64_t flags = process->getSyscallArg(tc, index);
1171         provided_address = process->getSyscallArg(tc, index);
1239 statFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1242     auto process = tc->getProcessPtr();
1245     if (!tc->getVirtProxy().tryReadString(path,
1246                 process->getSyscallArg(tc, index))) {
1249     Addr bufPtr = process->getSyscallArg(tc, index);
1260     copyOutStatBuf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf);
1269 stat64Func(SyscallDesc *desc, int callnum, ThreadContext *tc)
1272     auto process = tc->getProcessPtr();
1275     if (!tc->getVirtProxy().tryReadString(path,
1276                 process->getSyscallArg(tc, index)))
1278     Addr bufPtr = process->getSyscallArg(tc, index);
1294     copyOutStat64Buf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf);
1303 fstatat64Func(SyscallDesc *desc, int callnum, ThreadContext *tc)
1306     auto process = tc->getProcessPtr();
1307     int dirfd = process->getSyscallArg(tc, index);
1312     if (!tc->getVirtProxy().tryReadString(path,
1313                 process->getSyscallArg(tc, index)))
1315     Addr bufPtr = process->getSyscallArg(tc, index);
1331     copyOutStat64Buf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf);
1340 fstat64Func(SyscallDesc *desc, int callnum, ThreadContext *tc)
1343     auto p = tc->getProcessPtr();
1344     int tgt_fd = p->getSyscallArg(tc, index);
1345     Addr bufPtr = p->getSyscallArg(tc, index);
1363     copyOutStat64Buf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf, (sim_fd == 1));
1372 lstatFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1375     auto process = tc->getProcessPtr();
1378     if (!tc->getVirtProxy().tryReadString(path,
1379                 process->getSyscallArg(tc, index))) {
1382     Addr bufPtr = process->getSyscallArg(tc, index);
1393     copyOutStatBuf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf);
1401 lstat64Func(SyscallDesc *desc, int callnum, ThreadContext *tc)
1404     auto process = tc->getProcessPtr();
1407     if (!tc->getVirtProxy().tryReadString(path,
1408                 process->getSyscallArg(tc, index))) {
1411     Addr bufPtr = process->getSyscallArg(tc, index);
1427     copyOutStat64Buf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf);
1435 fstatFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1438     auto p = tc->getProcessPtr();
1439     int tgt_fd = p->getSyscallArg(tc, index);
1440     Addr bufPtr = p->getSyscallArg(tc, index);
1455     copyOutStatBuf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf, (sim_fd == 1));
1463 statfsFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1467     auto process = tc->getProcessPtr();
1470     if (!tc->getVirtProxy().tryReadString(path,
1471                 process->getSyscallArg(tc, index))) {
1474     Addr bufPtr = process->getSyscallArg(tc, index);
1485     copyOutStatfsBuf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf);
1495 cloneFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1499     auto p = tc->getProcessPtr();
1500     RegVal flags = p->getSyscallArg(tc, index);
1501     RegVal newStack = p->getSyscallArg(tc, index);
1502     Addr ptidPtr = p->getSyscallArg(tc, index);
1510     Addr tlsPtr = p->getSyscallArg(tc, index);
1511     Addr ctidPtr = p->getSyscallArg(tc, index);
1513     Addr ctidPtr = p->getSyscallArg(tc, index);
1514     Addr tlsPtr = p->getSyscallArg(tc, index);
1528                         "[cpu %d, thread %d]", tc->cpuId(), tc->threadId());
1576         ptidBuf.copyOut(tc->getVirtProxy());
1584     p->clone(tc, ctc, cp, flags);
1605     OS::archClone(flags, p, cp, tc, ctc, newStack, tlsPtr);
1612     tc->setIntReg(TheISA::SyscallPseudoReturnReg, 0);
1618         ctc->pcState(tc->readIntReg(TheISA::INTREG_RCX));
1623         TheISA::PCState cpc = tc->pcState();
1635 fstatfsFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1638     auto p = tc->getProcessPtr();
1639     int tgt_fd = p->getSyscallArg(tc, index);
1640     Addr bufPtr = p->getSyscallArg(tc, index);
1653     copyOutStatfsBuf<OS>(tc->getVirtProxy(), bufPtr, &hostBuf);
1661 readvFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1664     auto p = tc->getProcessPtr();
1665     int tgt_fd = p->getSyscallArg(tc, index);
1672     PortProxy &prox = tc->getVirtProxy();
1673     uint64_t tiov_base = p->getSyscallArg(tc, index);
1674     size_t count = p->getSyscallArg(tc, index);
1701 writevFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1704     auto p = tc->getProcessPtr();
1705     int tgt_fd = p->getSyscallArg(tc, index);
1712     PortProxy &prox = tc->getVirtProxy();
1713     uint64_t tiov_base = p->getSyscallArg(tc, index);
1714     size_t count = p->getSyscallArg(tc, index);
1738 mmapImpl(SyscallDesc *desc, int num, ThreadContext *tc, bool is_mmap2)
1741     auto p = tc->getProcessPtr();
1742     Addr start = p->getSyscallArg(tc, index);
1743     uint64_t length = p->getSyscallArg(tc, index);
1744     int prot = p->getSyscallArg(tc, index);
1745     int tgt_flags = p->getSyscallArg(tc, index);
1746     int tgt_fd = p->getSyscallArg(tc, index);
1747     int offset = p->getSyscallArg(tc, index);
1798             return emul_driver->mmap(tc, start, length, prot, tgt_flags,
1836         for (auto tc : p->system->threadContexts) {
1839             tc->getDTBPtr()->flushAll();
1840             tc->getITBPtr()->flushAll();
1850     PortProxy &tp = tc->getVirtProxy();
1892             Addr pc = tc->pcState().pc();
1916 pwrite64Func(SyscallDesc *desc, int num, ThreadContext *tc)
1919     auto p = tc->getProcessPtr();
1920     int tgt_fd = p->getSyscallArg(tc, index);
1921     Addr bufPtr = p->getSyscallArg(tc, index);
1922     int nbytes = p->getSyscallArg(tc, index);
1923     int offset = p->getSyscallArg(tc, index);
1931     bufArg.copyIn(tc->getVirtProxy());
1941 mmapFunc(SyscallDesc *desc, int num, ThreadContext *tc)
1943     return mmapImpl<OS>(desc, num, tc, false);
1949 mmap2Func(SyscallDesc *desc, int num, ThreadContext *tc)
1951     return mmapImpl<OS>(desc, num, tc, true);
1957 getrlimitFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
1960     auto process = tc->getProcessPtr();
1961     unsigned resource = process->getSyscallArg(tc, index);
1962     TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, index));
1980         rlp->rlim_cur = rlp->rlim_max = tc->getSystemPtr()->numContexts();
1991     rlp.copyOut(tc->getVirtProxy());
1997 prlimitFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
2000     auto process = tc->getProcessPtr();
2001     if (process->getSyscallArg(tc, index) != 0)
2006     int resource = process->getSyscallArg(tc, index);
2007     Addr n = process->getSyscallArg(tc, index);
2010     Addr o = process->getSyscallArg(tc, index);
2032         rlp.copyOut(tc->getVirtProxy());
2040 clock_gettimeFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2043     auto p = tc->getProcessPtr();
2044     //int clk_id = p->getSyscallArg(tc, index);
2045     TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index));
2052     tp.copyOut(tc->getVirtProxy());
2060 clock_getresFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2063     auto p = tc->getProcessPtr();
2064     TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index));
2070     tp.copyOut(tc->getVirtProxy());
2078 gettimeofdayFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
2081     auto process = tc->getProcessPtr();
2082     TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, index));
2089     tp.copyOut(tc->getVirtProxy());
2098 utimesFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
2101     auto process = tc->getProcessPtr();
2104     if (!tc->getVirtProxy().tryReadString(path,
2105                 process->getSyscallArg(tc, index))) {
2110         tp(process->getSyscallArg(tc, index));
2111     tp.copyIn(tc->getVirtProxy());
2132 execveFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
2135     auto p = tc->getProcessPtr();
2139     PortProxy & mem_proxy = tc->getVirtProxy();
2140     if (!mem_proxy.tryReadString(path, p->getSyscallArg(tc, index)))
2169     Addr argv_mem_loc = p->getSyscallArg(tc, index);
2171     Addr envp_mem_loc = p->getSyscallArg(tc, index);
2210     tc->clearArchRegs();
2211     tc->setProcessPtr(new_p);
2212     new_p->assignThreadContext(tc->contextId());
2214     tc->activate();
2215     TheISA::PCState pcState = tc->pcState();
2216     tc->setNPC(pcState.instAddr());
2225 getrusageFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
2228     auto process = tc->getProcessPtr();
2229     int who = process->getSyscallArg(tc, index); // THREAD, SELF, or CHILDREN
2230     TypedBufferArg<typename OS::rusage> rup(process->getSyscallArg(tc, index));
2269     rup.copyOut(tc->getVirtProxy());
2277 timesFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
2280     auto process = tc->getProcessPtr();
2281     TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, index));
2294     bufp.copyOut(tc->getVirtProxy());
2303 timeFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
2310     auto process = tc->getProcessPtr();
2311     Addr taddr = (Addr)process->getSyscallArg(tc, index);
2315         PortProxy &p = tc->getVirtProxy();
2323 tgkillFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2326     auto process = tc->getProcessPtr();
2327     int tgid = process->getSyscallArg(tc, index);
2328     int tid = process->getSyscallArg(tc, index);
2329     int sig = process->getSyscallArg(tc, index);
2346     System *sys = tc->getSystemPtr();
2366         exitGroupFunc(desc, 252, tc);
2373 socketFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2376     auto p = tc->getProcessPtr();
2377     int domain = p->getSyscallArg(tc, index);
2378     int type = p->getSyscallArg(tc, index);
2379     int prot = p->getSyscallArg(tc, index);
2393 socketpairFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2396     auto p = tc->getProcessPtr();
2397     int domain = p->getSyscallArg(tc, index);
2398     int type = p->getSyscallArg(tc, index);
2399     int prot = p->getSyscallArg(tc, index);
2400     Addr svPtr = p->getSyscallArg(tc, index);
2413     svBuf.copyOut(tc->getVirtProxy());
2420 selectFunc(SyscallDesc *desc, int callnum, ThreadContext *tc)
2425     auto p = tc->getProcessPtr();
2426     int nfds_t = p->getSyscallArg(tc, index);
2427     Addr fds_read_ptr = p->getSyscallArg(tc, index);
2428     Addr fds_writ_ptr = p->getSyscallArg(tc, index);
2429     Addr fds_excp_ptr = p->getSyscallArg(tc, index);
2430     Addr time_val_ptr = p->getSyscallArg(tc, index);
2453         rd_t.copyIn(tc->getVirtProxy());
2455         wr_t.copyIn(tc->getVirtProxy());
2457         ex_t.copyIn(tc->getVirtProxy());
2566             for (auto sig : tc->getSystemPtr()->signalList)
2603         rd_t.copyOut(tc->getVirtProxy());
2605         wr_t.copyOut(tc->getVirtProxy());
2607         ex_t.copyOut(tc->getVirtProxy());
2609         tp.copyOut(tc->getVirtProxy());
2616 readFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2619     auto p = tc->getProcessPtr();
2620     int tgt_fd = p->getSyscallArg(tc, index);
2621     Addr buf_ptr = p->getSyscallArg(tc, index);
2622     int nbytes = p->getSyscallArg(tc, index);
2640         buf_arg.copyOut(tc->getVirtProxy());
2647 writeFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2650     auto p = tc->getProcessPtr();
2651     int tgt_fd = p->getSyscallArg(tc, index);
2652     Addr buf_ptr = p->getSyscallArg(tc, index);
2653     int nbytes = p->getSyscallArg(tc, index);
2661     buf_arg.copyIn(tc->getVirtProxy());
2689 wait4Func(SyscallDesc *desc, int num, ThreadContext *tc)
2692     auto p = tc->getProcessPtr();
2693     pid_t pid = p->getSyscallArg(tc, index);
2694     Addr statPtr = p->getSyscallArg(tc, index);
2695     int options = p->getSyscallArg(tc, index);
2696     Addr rusagePtr = p->getSyscallArg(tc, index);
2711     System *sysh = tc->getSystemPtr();
2741     statusBuf.copyOut(tc->getVirtProxy());
2751 acceptFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2757     auto p = tc->getProcessPtr();
2758     int tgt_fd = p->getSyscallArg(tc, index);
2759     Addr addrPtr = p->getSyscallArg(tc, index);
2760     Addr lenPtr = p->getSyscallArg(tc, index);
2785         lenBufPtr->copyIn(tc->getVirtProxy());
2792         addrBufPtr->copyIn(tc->getVirtProxy());
2804         addrBufPtr->copyOut(tc->getVirtProxy());
2810         lenBufPtr->copyOut(tc->getVirtProxy());
2822 eventfdFunc(SyscallDesc *desc, int num, ThreadContext *tc)
2826     auto p = tc->getProcessPtr();
2827     unsigned initval = p->getSyscallArg(tc, index);
2828     int in_flags = p->getSyscallArg(tc, index);