src/sim/syscall_emul.hh

105 #include "sim/process.hh"
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);
372             futex_map.suspend(uaddr, process->tgid(), tc);
374             futex_map.suspend_bitset(uaddr, process->tgid(), tc, val3);
379         return futex_map.wakeup(uaddr, process->tgid(), val);
381         return futex_map.wakeup_bitset(uaddr, process->tgid(), val3);
395         return futex_map.requeue(uaddr, process->tgid(), val, timeout, uaddr2);
446         int woken1 = futex_map.wakeup(uaddr, process->tgid(), val);
464             woken2 = futex_map.wakeup(uaddr2, process->tgid(), timeout);
767      * descriptor from the simulated process.
773      * Retrieve the simulated process' memory proxy and then read in the path
807      * If the simulated process called open or openat with AT_FDCWD specified,
809      * process class as a Python parameter and append the current path to
835      * the process class through Python; this allows us to create a file
871      * simulated process. If running a debug trace, also notify the user that
901      * process' file descriptor array so that it can be retrieved later.
905      * process to act as a handle for the opened file.
937     auto process = tc->getProcessPtr();
938     int dirfd = process->getSyscallArg(tc, index);
951     auto process = tc->getProcessPtr();
952     int dirfd = process->getSyscallArg(tc, index);
964     auto process = tc->getProcessPtr();
965     int dirfd = process->getSyscallArg(tc, index);
977     auto process = tc->getProcessPtr();
979     int olddirfd = process->getSyscallArg(tc, index);
986                                          process->getSyscallArg(tc, index)))
989     int newdirfd = process->getSyscallArg(tc, index);
996                                          process->getSyscallArg(tc, index)))
1000     old_name = process->checkPathRedirect(old_name);
1001     new_name = process->checkPathRedirect(new_name);
1013     auto process = tc->getProcessPtr();
1016         sysinfo(process->getSyscallArg(tc, index));
1019     sysinfo->totalram = process->system->memSize();
1033     auto process = tc->getProcessPtr();
1037                 process->getSyscallArg(tc, index))) {
1041     uint32_t mode = process->getSyscallArg(tc, index);
1048     path = process->checkPathRedirect(path);
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);
1182         std::shared_ptr<MemState> mem_state = process->memState;
1190             process->allocateMem(mmap_end, diff);
1200                     new_start = process->mmapGrowsDown() ?
1202                     mmap_end = process->mmapGrowsDown() ?
1207                 process->pTable->remap(start, old_length, new_start);
1212                 process->allocateMem(new_start + old_length,
1217                       !process->mmapGrowsDown()) ||
1219                       process->mmapGrowsDown()))) {
1230             process->pTable->remap(start, new_length, provided_address);
1231         process->pTable->unmap(start + new_length, old_length - new_length);
1242     auto process = tc->getProcessPtr();
1246                 process->getSyscallArg(tc, index))) {
1249     Addr bufPtr = process->getSyscallArg(tc, index);
1252     path = process->checkPathRedirect(path);
1272     auto process = tc->getProcessPtr();
1276                 process->getSyscallArg(tc, index)))
1278     Addr bufPtr = process->getSyscallArg(tc, index);
1281     path = process->checkPathRedirect(path);
1306     auto process = tc->getProcessPtr();
1307     int dirfd = process->getSyscallArg(tc, index);
1313                 process->getSyscallArg(tc, index)))
1315     Addr bufPtr = process->getSyscallArg(tc, index);
1318     path = process->checkPathRedirect(path);
1375     auto process = tc->getProcessPtr();
1379                 process->getSyscallArg(tc, index))) {
1382     Addr bufPtr = process->getSyscallArg(tc, index);
1385     path = process->checkPathRedirect(path);
1404     auto process = tc->getProcessPtr();
1408                 process->getSyscallArg(tc, index))) {
1411     Addr bufPtr = process->getSyscallArg(tc, index);
1414     path = process->checkPathRedirect(path);
1467     auto process = tc->getProcessPtr();
1471                 process->getSyscallArg(tc, index))) {
1474     Addr bufPtr = process->getSyscallArg(tc, index);
1477     path = process->checkPathRedirect(path);
1960     auto process = tc->getProcessPtr();
1961     unsigned resource = process->getSyscallArg(tc, index);
1962     TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, index));
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);
2081     auto process = tc->getProcessPtr();
2082     TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, index));
2101     auto process = tc->getProcessPtr();
2105                 process->getSyscallArg(tc, index))) {
2110         tp(process->getSyscallArg(tc, index));
2120     path = process->checkPathRedirect(path);
2185      * Prevent process object creation with identical PIDs (which will trip
2187      * take over the currently executing process' identity but replace
2188      * whatever it is doing with a new process image. Instead of hijacking
2189      * the process object in the simulator, we create a new process object
2190      * and bind to the previous process' thread below (hijacking the thread).
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));
2280     auto process = tc->getProcessPtr();
2281     TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, index));
2310     auto process = tc->getProcessPtr();
2311     Addr taddr = (Addr)process->getSyscallArg(tc, index);
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);
2461      * descriptor set. This involves both our internal process fd array
2582      * descriptor set. This involves both our internal process fd array