00001 // 00002 // Copyright (c) 2005-2008 Kenichi Watanabe. 00003 // Copyright (c) 2005-2008 Yasuhiro Watari. 00004 // Copyright (c) 2005-2008 Hironori Ichibayashi. 00005 // Copyright (c) 2008-2009 Kazuo Horio. 00006 // Copyright (c) 2009-2013 Naruki Kurata. 00007 // Copyright (c) 2005-2013 Ryota Shioya. 00008 // Copyright (c) 2005-2013 Masahiro Goshima. 00009 // 00010 // This software is provided 'as-is', without any express or implied 00011 // warranty. In no event will the authors be held liable for any damages 00012 // arising from the use of this software. 00013 // 00014 // Permission is granted to anyone to use this software for any purpose, 00015 // including commercial applications, and to alter it and redistribute it 00016 // freely, subject to the following restrictions: 00017 // 00018 // 1. The origin of this software must not be misrepresented; you must not 00019 // claim that you wrote the original software. If you use this software 00020 // in a product, an acknowledgment in the product documentation would be 00021 // appreciated but is not required. 00022 // 00023 // 2. Altered source versions must be plainly marked as such, and must not be 00024 // misrepresented as being the original software. 00025 // 00026 // 3. This notice may not be removed or altered from any source 00027 // distribution. 00028 // 00029 // 00030 00031 00032 #ifndef __EMULATORUTILITY_LINUX64SYSCALLCONV_H__ 00033 #define __EMULATORUTILITY_LINUX64SYSCALLCONV_H__ 00034 00035 #include "Emu/Utility/System/Syscall/SyscallConvIF.h" 00036 #include "Emu/Utility/System/VirtualSystem.h" 00037 #include "Emu/Utility/System/ProcessState.h" 00038 00039 namespace Onikiri { 00040 class SystemIF; 00041 00042 namespace EmulatorUtility { 00043 class MemorySystem; 00044 class OpEmulationState; 00045 00046 class Linux64SyscallConv : public EmulatorUtility::SyscallConvIF 00047 { 00048 private: 00049 Linux64SyscallConv() {} 00050 public: 00051 Linux64SyscallConv(EmulatorUtility::ProcessState* processState); 00052 virtual ~Linux64SyscallConv(); 00053 00054 // VXeR[ (index) 00055 virtual void SetArg(int index, u64 value); 00056 00057 // SetArg ^]VXeR[s 00058 virtual void Execute(EmulatorUtility::OpEmulationState* opState) = 0; 00059 00060 // Exec 00061 virtual u64 GetResult(int index); 00062 virtual void SetSystem(SystemIF* system); 00063 00064 private: 00065 static const int MaxResultCount = 2; 00066 00067 std::vector<u64> m_args; 00068 std::vector<u64> m_results; 00069 EmulatorUtility::ProcessState* m_processState; 00070 SystemIF* m_simulatorSystem; 00071 00072 00073 protected: 00074 static const int MaxArgCount = 16; 00075 00076 u64 GetArg(int index) const 00077 { 00078 return m_args[index]; 00079 } 00080 00081 EmulatorUtility::ProcessState* GetProcessState() 00082 { 00083 return m_processState; 00084 } 00085 00086 EmulatorUtility::MemorySystem* GetMemorySystem() 00087 { 00088 return m_processState->GetMemorySystem(); 00089 } 00090 00091 EmulatorUtility::VirtualSystem* GetVirtualSystem() 00092 { 00093 return m_processState->GetVirtualSystem(); 00094 } 00095 00096 void SetResult(bool success, u64 result); 00097 00098 virtual void syscall_exit(EmulatorUtility::OpEmulationState* opState); 00099 00100 virtual void syscall_open(EmulatorUtility::OpEmulationState* opState); 00101 virtual void syscall_close(EmulatorUtility::OpEmulationState* opState); 00102 virtual void syscall_read(EmulatorUtility::OpEmulationState* opState); 00103 virtual void syscall_write(EmulatorUtility::OpEmulationState* opState); 00104 virtual void syscall_readv(EmulatorUtility::OpEmulationState* opState); 00105 virtual void syscall_writev(EmulatorUtility::OpEmulationState* opState); 00106 00107 virtual void syscall_lseek(EmulatorUtility::OpEmulationState* opState); 00108 virtual void syscall_unlink(EmulatorUtility::OpEmulationState* opState); 00109 virtual void syscall_rename(EmulatorUtility::OpEmulationState* opState); 00110 00111 virtual void syscall_mmap(EmulatorUtility::OpEmulationState* opState); 00112 virtual void syscall_munmap(EmulatorUtility::OpEmulationState* opState); 00113 virtual void syscall_mremap(EmulatorUtility::OpEmulationState* opState); 00114 virtual void syscall_mprotect(EmulatorUtility::OpEmulationState* opState); 00115 virtual void syscall_fcntl(EmulatorUtility::OpEmulationState* opState); 00116 virtual void syscall_uname(EmulatorUtility::OpEmulationState* opState); 00117 00118 virtual void syscall_brk(EmulatorUtility::OpEmulationState* opState); 00119 00120 virtual void syscall_getpid(EmulatorUtility::OpEmulationState* opState); 00121 virtual void syscall_getuid(EmulatorUtility::OpEmulationState* opState); 00122 virtual void syscall_geteuid(EmulatorUtility::OpEmulationState* opState); 00123 virtual void syscall_getgid(EmulatorUtility::OpEmulationState* opState); 00124 virtual void syscall_getegid(EmulatorUtility::OpEmulationState* opState); 00125 00126 //virtual void syscall_setuid(EmulatorUtility::OpEmulationState* opState); 00127 //virtual void syscall_seteuid(EmulatorUtility::OpEmulationState* opState); 00128 //virtual void syscall_setgid(EmulatorUtility::OpEmulationState* opState); 00129 //virtual void syscall_setegid(EmulatorUtility::OpEmulationState* opState); 00130 //virtual void syscall_setreuid(EmulatorUtility::OpEmulationState* opState); 00131 //virtual void syscall_setregid(EmulatorUtility::OpEmulationState* opState); 00132 00133 virtual void syscall_access(EmulatorUtility::OpEmulationState* opState); 00134 // virtual void syscall_fstat(EmulatorUtility::OpEmulationState* opState); 00135 virtual void syscall_stat64(EmulatorUtility::OpEmulationState* opState); 00136 virtual void syscall_lstat64(EmulatorUtility::OpEmulationState* opState); 00137 virtual void syscall_fstat64(EmulatorUtility::OpEmulationState* opState); 00138 00139 virtual void syscall_ioctl(EmulatorUtility::OpEmulationState* opState); 00140 // virtual void syscall_readlink(EmulatorUtility::OpEmulationState* opState); 00141 virtual void syscall_mkdir(EmulatorUtility::OpEmulationState* opState); 00142 00143 virtual void syscall_dup(EmulatorUtility::OpEmulationState* opState); 00144 virtual void syscall_truncate(EmulatorUtility::OpEmulationState* opState); 00145 virtual void syscall_ftruncate(EmulatorUtility::OpEmulationState* opState); 00146 00147 virtual void syscall_kill(EmulatorUtility::OpEmulationState* opState); 00148 virtual void syscall_tgkill(EmulatorUtility::OpEmulationState* opState); 00149 00150 void kill_helper(EmulatorUtility::OpEmulationState* opState, int pid, int sig); 00151 00152 virtual void syscall_ignore(EmulatorUtility::OpEmulationState* opState); 00153 virtual void syscall_time(EmulatorUtility::OpEmulationState* opState); 00154 virtual void syscall_times(EmulatorUtility::OpEmulationState* opState); 00155 virtual void syscall_gettimeofday(EmulatorUtility::OpEmulationState* opState); 00156 00157 virtual void syscall_getcwd(EmulatorUtility::OpEmulationState* opState); 00158 00159 // arch dependent 00160 00161 // concversion 00162 virtual void write_stat64(u64 dest, const EmulatorUtility::HostStat &src); 00163 virtual int Get_MAP_ANONYMOUS() = 0; 00164 virtual int Get_MREMAP_MAYMOVE() = 0; 00165 virtual int Get_CLK_TCK() = 0; 00166 00167 virtual u32 OpenFlagTargetToHost(u32 flag) = 0; 00168 virtual u32 SeekWhenceTargetToHost(u32 flag); 00169 virtual u32 AccessModeTargetToHost(u32 flag); 00170 }; 00171 00172 } // namespace AlphaLinux 00173 } // namespace Onikiri 00174 00175 #endif