syscall_emul.hh (11812:30aada507f03) | syscall_emul.hh (11851:824055fe6b30) |
---|---|
1/* 2 * Copyright (c) 2012-2013, 2015 ARM Limited 3 * Copyright (c) 2015 Advanced Micro Devices, Inc. 4 * All rights reserved 5 * 6 * The license below extends only to copyright in the software and shall 7 * not be construed as granting a license to any other intellectual 8 * property including but not limited to intellectual property relating --- 94 unchanged lines hidden (view full) --- 103// don't need to be recompiled for different emulated OS's. They are 104// defined in sim/syscall_emul.cc. 105// 106////////////////////////////////////////////////////////////////////// 107 108 109/// Handler for unimplemented syscalls that we haven't thought about. 110SyscallReturn unimplementedFunc(SyscallDesc *desc, int num, | 1/* 2 * Copyright (c) 2012-2013, 2015 ARM Limited 3 * Copyright (c) 2015 Advanced Micro Devices, Inc. 4 * All rights reserved 5 * 6 * The license below extends only to copyright in the software and shall 7 * not be construed as granting a license to any other intellectual 8 * property including but not limited to intellectual property relating --- 94 unchanged lines hidden (view full) --- 103// don't need to be recompiled for different emulated OS's. They are 104// defined in sim/syscall_emul.cc. 105// 106////////////////////////////////////////////////////////////////////// 107 108 109/// Handler for unimplemented syscalls that we haven't thought about. 110SyscallReturn unimplementedFunc(SyscallDesc *desc, int num, |
111 LiveProcess *p, ThreadContext *tc); | 111 Process *p, ThreadContext *tc); |
112 113/// Handler for unimplemented syscalls that we never intend to 114/// implement (signal handling, etc.) and should not affect the correct 115/// behavior of the program. Print a warning only if the appropriate 116/// trace flag is enabled. Return success to the target program. 117SyscallReturn ignoreFunc(SyscallDesc *desc, int num, | 112 113/// Handler for unimplemented syscalls that we never intend to 114/// implement (signal handling, etc.) and should not affect the correct 115/// behavior of the program. Print a warning only if the appropriate 116/// trace flag is enabled. Return success to the target program. 117SyscallReturn ignoreFunc(SyscallDesc *desc, int num, |
118 LiveProcess *p, ThreadContext *tc); | 118 Process *p, ThreadContext *tc); |
119 120// Target fallocateFunc() handler. 121SyscallReturn fallocateFunc(SyscallDesc *desc, int num, | 119 120// Target fallocateFunc() handler. 121SyscallReturn fallocateFunc(SyscallDesc *desc, int num, |
122 LiveProcess *p, ThreadContext *tc); | 122 Process *p, ThreadContext *tc); |
123 124/// Target exit() handler: terminate current context. 125SyscallReturn exitFunc(SyscallDesc *desc, int num, | 123 124/// Target exit() handler: terminate current context. 125SyscallReturn exitFunc(SyscallDesc *desc, int num, |
126 LiveProcess *p, ThreadContext *tc); | 126 Process *p, ThreadContext *tc); |
127 128/// Target exit_group() handler: terminate simulation. (exit all threads) 129SyscallReturn exitGroupFunc(SyscallDesc *desc, int num, | 127 128/// Target exit_group() handler: terminate simulation. (exit all threads) 129SyscallReturn exitGroupFunc(SyscallDesc *desc, int num, |
130 LiveProcess *p, ThreadContext *tc); | 130 Process *p, ThreadContext *tc); |
131 132/// Target getpagesize() handler. 133SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num, | 131 132/// Target getpagesize() handler. 133SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num, |
134 LiveProcess *p, ThreadContext *tc); | 134 Process *p, ThreadContext *tc); |
135 136/// Target brk() handler: set brk address. 137SyscallReturn brkFunc(SyscallDesc *desc, int num, | 135 136/// Target brk() handler: set brk address. 137SyscallReturn brkFunc(SyscallDesc *desc, int num, |
138 LiveProcess *p, ThreadContext *tc); | 138 Process *p, ThreadContext *tc); |
139 140/// Target close() handler. 141SyscallReturn closeFunc(SyscallDesc *desc, int num, | 139 140/// Target close() handler. 141SyscallReturn closeFunc(SyscallDesc *desc, int num, |
142 LiveProcess *p, ThreadContext *tc); | 142 Process *p, ThreadContext *tc); |
143 144/// Target read() handler. 145SyscallReturn readFunc(SyscallDesc *desc, int num, | 143 144/// Target read() handler. 145SyscallReturn readFunc(SyscallDesc *desc, int num, |
146 LiveProcess *p, ThreadContext *tc); | 146 Process *p, ThreadContext *tc); |
147 148/// Target write() handler. 149SyscallReturn writeFunc(SyscallDesc *desc, int num, | 147 148/// Target write() handler. 149SyscallReturn writeFunc(SyscallDesc *desc, int num, |
150 LiveProcess *p, ThreadContext *tc); | 150 Process *p, ThreadContext *tc); |
151 152/// Target lseek() handler. 153SyscallReturn lseekFunc(SyscallDesc *desc, int num, | 151 152/// Target lseek() handler. 153SyscallReturn lseekFunc(SyscallDesc *desc, int num, |
154 LiveProcess *p, ThreadContext *tc); | 154 Process *p, ThreadContext *tc); |
155 156/// Target _llseek() handler. 157SyscallReturn _llseekFunc(SyscallDesc *desc, int num, | 155 156/// Target _llseek() handler. 157SyscallReturn _llseekFunc(SyscallDesc *desc, int num, |
158 LiveProcess *p, ThreadContext *tc); | 158 Process *p, ThreadContext *tc); |
159 160/// Target munmap() handler. 161SyscallReturn munmapFunc(SyscallDesc *desc, int num, | 159 160/// Target munmap() handler. 161SyscallReturn munmapFunc(SyscallDesc *desc, int num, |
162 LiveProcess *p, ThreadContext *tc); | 162 Process *p, ThreadContext *tc); |
163 164/// Target gethostname() handler. 165SyscallReturn gethostnameFunc(SyscallDesc *desc, int num, | 163 164/// Target gethostname() handler. 165SyscallReturn gethostnameFunc(SyscallDesc *desc, int num, |
166 LiveProcess *p, ThreadContext *tc); | 166 Process *p, ThreadContext *tc); |
167 168/// Target getcwd() handler. 169SyscallReturn getcwdFunc(SyscallDesc *desc, int num, | 167 168/// Target getcwd() handler. 169SyscallReturn getcwdFunc(SyscallDesc *desc, int num, |
170 LiveProcess *p, ThreadContext *tc); | 170 Process *p, ThreadContext *tc); |
171 172/// Target readlink() handler. 173SyscallReturn readlinkFunc(SyscallDesc *desc, int num, | 171 172/// Target readlink() handler. 173SyscallReturn readlinkFunc(SyscallDesc *desc, int num, |
174 LiveProcess *p, ThreadContext *tc, | 174 Process *p, ThreadContext *tc, |
175 int index = 0); 176SyscallReturn readlinkFunc(SyscallDesc *desc, int num, | 175 int index = 0); 176SyscallReturn readlinkFunc(SyscallDesc *desc, int num, |
177 LiveProcess *p, ThreadContext *tc); | 177 Process *p, ThreadContext *tc); |
178 179/// Target unlink() handler. 180SyscallReturn unlinkHelper(SyscallDesc *desc, int num, | 178 179/// Target unlink() handler. 180SyscallReturn unlinkHelper(SyscallDesc *desc, int num, |
181 LiveProcess *p, ThreadContext *tc, | 181 Process *p, ThreadContext *tc, |
182 int index); 183SyscallReturn unlinkFunc(SyscallDesc *desc, int num, | 182 int index); 183SyscallReturn unlinkFunc(SyscallDesc *desc, int num, |
184 LiveProcess *p, ThreadContext *tc); | 184 Process *p, ThreadContext *tc); |
185 186/// Target mkdir() handler. 187SyscallReturn mkdirFunc(SyscallDesc *desc, int num, | 185 186/// Target mkdir() handler. 187SyscallReturn mkdirFunc(SyscallDesc *desc, int num, |
188 LiveProcess *p, ThreadContext *tc); | 188 Process *p, ThreadContext *tc); |
189 190/// Target rename() handler. 191SyscallReturn renameFunc(SyscallDesc *desc, int num, | 189 190/// Target rename() handler. 191SyscallReturn renameFunc(SyscallDesc *desc, int num, |
192 LiveProcess *p, ThreadContext *tc); | 192 Process *p, ThreadContext *tc); |
193 194 195/// Target truncate() handler. 196SyscallReturn truncateFunc(SyscallDesc *desc, int num, | 193 194 195/// Target truncate() handler. 196SyscallReturn truncateFunc(SyscallDesc *desc, int num, |
197 LiveProcess *p, ThreadContext *tc); | 197 Process *p, ThreadContext *tc); |
198 199 200/// Target ftruncate() handler. 201SyscallReturn ftruncateFunc(SyscallDesc *desc, int num, | 198 199 200/// Target ftruncate() handler. 201SyscallReturn ftruncateFunc(SyscallDesc *desc, int num, |
202 LiveProcess *p, ThreadContext *tc); | 202 Process *p, ThreadContext *tc); |
203 204 205/// Target truncate64() handler. 206SyscallReturn truncate64Func(SyscallDesc *desc, int num, | 203 204 205/// Target truncate64() handler. 206SyscallReturn truncate64Func(SyscallDesc *desc, int num, |
207 LiveProcess *p, ThreadContext *tc); | 207 Process *p, ThreadContext *tc); |
208 209/// Target ftruncate64() handler. 210SyscallReturn ftruncate64Func(SyscallDesc *desc, int num, | 208 209/// Target ftruncate64() handler. 210SyscallReturn ftruncate64Func(SyscallDesc *desc, int num, |
211 LiveProcess *p, ThreadContext *tc); | 211 Process *p, ThreadContext *tc); |
212 213 214/// Target umask() handler. 215SyscallReturn umaskFunc(SyscallDesc *desc, int num, | 212 213 214/// Target umask() handler. 215SyscallReturn umaskFunc(SyscallDesc *desc, int num, |
216 LiveProcess *p, ThreadContext *tc); | 216 Process *p, ThreadContext *tc); |
217 218 219/// Target chown() handler. 220SyscallReturn chownFunc(SyscallDesc *desc, int num, | 217 218 219/// Target chown() handler. 220SyscallReturn chownFunc(SyscallDesc *desc, int num, |
221 LiveProcess *p, ThreadContext *tc); | 221 Process *p, ThreadContext *tc); |
222 223 224/// Target fchown() handler. 225SyscallReturn fchownFunc(SyscallDesc *desc, int num, | 222 223 224/// Target fchown() handler. 225SyscallReturn fchownFunc(SyscallDesc *desc, int num, |
226 LiveProcess *p, ThreadContext *tc); | 226 Process *p, ThreadContext *tc); |
227 228/// Target dup() handler. 229SyscallReturn dupFunc(SyscallDesc *desc, int num, | 227 228/// Target dup() handler. 229SyscallReturn dupFunc(SyscallDesc *desc, int num, |
230 LiveProcess *process, ThreadContext *tc); | 230 Process *process, ThreadContext *tc); |
231 232/// Target fnctl() handler. 233SyscallReturn fcntlFunc(SyscallDesc *desc, int num, | 231 232/// Target fnctl() handler. 233SyscallReturn fcntlFunc(SyscallDesc *desc, int num, |
234 LiveProcess *process, ThreadContext *tc); | 234 Process *process, ThreadContext *tc); |
235 236/// Target fcntl64() handler. 237SyscallReturn fcntl64Func(SyscallDesc *desc, int num, | 235 236/// Target fcntl64() handler. 237SyscallReturn fcntl64Func(SyscallDesc *desc, int num, |
238 LiveProcess *process, ThreadContext *tc); | 238 Process *process, ThreadContext *tc); |
239 240/// Target setuid() handler. 241SyscallReturn setuidFunc(SyscallDesc *desc, int num, | 239 240/// Target setuid() handler. 241SyscallReturn setuidFunc(SyscallDesc *desc, int num, |
242 LiveProcess *p, ThreadContext *tc); | 242 Process *p, ThreadContext *tc); |
243 244/// Target getpid() handler. 245SyscallReturn getpidFunc(SyscallDesc *desc, int num, | 243 244/// Target getpid() handler. 245SyscallReturn getpidFunc(SyscallDesc *desc, int num, |
246 LiveProcess *p, ThreadContext *tc); | 246 Process *p, ThreadContext *tc); |
247 248/// Target getuid() handler. 249SyscallReturn getuidFunc(SyscallDesc *desc, int num, | 247 248/// Target getuid() handler. 249SyscallReturn getuidFunc(SyscallDesc *desc, int num, |
250 LiveProcess *p, ThreadContext *tc); | 250 Process *p, ThreadContext *tc); |
251 252/// Target getgid() handler. 253SyscallReturn getgidFunc(SyscallDesc *desc, int num, | 251 252/// Target getgid() handler. 253SyscallReturn getgidFunc(SyscallDesc *desc, int num, |
254 LiveProcess *p, ThreadContext *tc); | 254 Process *p, ThreadContext *tc); |
255 256/// Target getppid() handler. 257SyscallReturn getppidFunc(SyscallDesc *desc, int num, | 255 256/// Target getppid() handler. 257SyscallReturn getppidFunc(SyscallDesc *desc, int num, |
258 LiveProcess *p, ThreadContext *tc); | 258 Process *p, ThreadContext *tc); |
259 260/// Target geteuid() handler. 261SyscallReturn geteuidFunc(SyscallDesc *desc, int num, | 259 260/// Target geteuid() handler. 261SyscallReturn geteuidFunc(SyscallDesc *desc, int num, |
262 LiveProcess *p, ThreadContext *tc); | 262 Process *p, ThreadContext *tc); |
263 264/// Target getegid() handler. 265SyscallReturn getegidFunc(SyscallDesc *desc, int num, | 263 264/// Target getegid() handler. 265SyscallReturn getegidFunc(SyscallDesc *desc, int num, |
266 LiveProcess *p, ThreadContext *tc); | 266 Process *p, ThreadContext *tc); |
267 268/// Target clone() handler. 269SyscallReturn cloneFunc(SyscallDesc *desc, int num, | 267 268/// Target clone() handler. 269SyscallReturn cloneFunc(SyscallDesc *desc, int num, |
270 LiveProcess *p, ThreadContext *tc); | 270 Process *p, ThreadContext *tc); |
271 272/// Target access() handler 273SyscallReturn accessFunc(SyscallDesc *desc, int num, | 271 272/// Target access() handler 273SyscallReturn accessFunc(SyscallDesc *desc, int num, |
274 LiveProcess *p, ThreadContext *tc); | 274 Process *p, ThreadContext *tc); |
275SyscallReturn accessFunc(SyscallDesc *desc, int num, | 275SyscallReturn accessFunc(SyscallDesc *desc, int num, |
276 LiveProcess *p, ThreadContext *tc, 277 int index); | 276 Process *p, ThreadContext *tc, 277 int index); |
278 279/// Futex system call 280/// Implemented by Daniel Sanchez 281/// Used by printf's in multi-threaded apps 282template <class OS> 283SyscallReturn | 278 279/// Futex system call 280/// Implemented by Daniel Sanchez 281/// Used by printf's in multi-threaded apps 282template <class OS> 283SyscallReturn |
284futexFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 284futexFunc(SyscallDesc *desc, int callnum, Process *process, |
285 ThreadContext *tc) 286{ 287 int index_uaddr = 0; 288 int index_op = 1; 289 int index_val = 2; 290 int index_timeout = 3; 291 292 uint64_t uaddr = process->getSyscallArg(tc, index_uaddr); --- 64 unchanged lines hidden (view full) --- 357 } 358 359} 360 361 362/// Pseudo Funcs - These functions use a different return convension, 363/// returning a second value in a register other than the normal return register 364SyscallReturn pipePseudoFunc(SyscallDesc *desc, int num, | 285 ThreadContext *tc) 286{ 287 int index_uaddr = 0; 288 int index_op = 1; 289 int index_val = 2; 290 int index_timeout = 3; 291 292 uint64_t uaddr = process->getSyscallArg(tc, index_uaddr); --- 64 unchanged lines hidden (view full) --- 357 } 358 359} 360 361 362/// Pseudo Funcs - These functions use a different return convension, 363/// returning a second value in a register other than the normal return register 364SyscallReturn pipePseudoFunc(SyscallDesc *desc, int num, |
365 LiveProcess *process, ThreadContext *tc); | 365 Process *process, ThreadContext *tc); |
366 367/// Target getpidPseudo() handler. 368SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num, | 366 367/// Target getpidPseudo() handler. 368SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num, |
369 LiveProcess *p, ThreadContext *tc); | 369 Process *p, ThreadContext *tc); |
370 371/// Target getuidPseudo() handler. 372SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num, | 370 371/// Target getuidPseudo() handler. 372SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num, |
373 LiveProcess *p, ThreadContext *tc); | 373 Process *p, ThreadContext *tc); |
374 375/// Target getgidPseudo() handler. 376SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num, | 374 375/// Target getgidPseudo() handler. 376SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num, |
377 LiveProcess *p, ThreadContext *tc); | 377 Process *p, ThreadContext *tc); |
378 379 380/// A readable name for 1,000,000, for converting microseconds to seconds. 381const int one_million = 1000000; 382/// A readable name for 1,000,000,000, for converting nanoseconds to seconds. 383const int one_billion = 1000000000; 384 385/// Approximate seconds since the epoch (1/1/1970). About a billion, --- 179 unchanged lines hidden (view full) --- 565} 566 567/// Target ioctl() handler. For the most part, programs call ioctl() 568/// only to find out if their stdout is a tty, to determine whether to 569/// do line or block buffering. We always claim that output fds are 570/// not TTYs to provide repeatable results. 571template <class OS> 572SyscallReturn | 378 379 380/// A readable name for 1,000,000, for converting microseconds to seconds. 381const int one_million = 1000000; 382/// A readable name for 1,000,000,000, for converting nanoseconds to seconds. 383const int one_billion = 1000000000; 384 385/// Approximate seconds since the epoch (1/1/1970). About a billion, --- 179 unchanged lines hidden (view full) --- 565} 566 567/// Target ioctl() handler. For the most part, programs call ioctl() 568/// only to find out if their stdout is a tty, to determine whether to 569/// do line or block buffering. We always claim that output fds are 570/// not TTYs to provide repeatable results. 571template <class OS> 572SyscallReturn |
573ioctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 573ioctlFunc(SyscallDesc *desc, int callnum, Process *process, |
574 ThreadContext *tc) 575{ 576 int index = 0; 577 int tgt_fd = process->getSyscallArg(tc, index); 578 unsigned req = process->getSyscallArg(tc, index); 579 580 DPRINTF(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", tgt_fd, req); 581 --- 14 unchanged lines hidden (view full) --- 596 597 warn("Unsupported ioctl call: ioctl(%d, 0x%x, ...) @ \n", 598 tgt_fd, req, tc->pcState()); 599 return -ENOTTY; 600} 601 602template <class OS> 603static SyscallReturn | 574 ThreadContext *tc) 575{ 576 int index = 0; 577 int tgt_fd = process->getSyscallArg(tc, index); 578 unsigned req = process->getSyscallArg(tc, index); 579 580 DPRINTF(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", tgt_fd, req); 581 --- 14 unchanged lines hidden (view full) --- 596 597 warn("Unsupported ioctl call: ioctl(%d, 0x%x, ...) @ \n", 598 tgt_fd, req, tc->pcState()); 599 return -ENOTTY; 600} 601 602template <class OS> 603static SyscallReturn |
604openFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 604openFunc(SyscallDesc *desc, int callnum, Process *process, |
605 ThreadContext *tc, int index) 606{ 607 std::string path; 608 609 if (!tc->getMemProxy().tryReadString(path, 610 process->getSyscallArg(tc, index))) 611 return -EFAULT; 612 --- 59 unchanged lines hidden (view full) --- 672 return -local_errno; 673 674 return process->allocFD(fd, path.c_str(), hostFlags, mode, false); 675} 676 677/// Target open() handler. 678template <class OS> 679SyscallReturn | 605 ThreadContext *tc, int index) 606{ 607 std::string path; 608 609 if (!tc->getMemProxy().tryReadString(path, 610 process->getSyscallArg(tc, index))) 611 return -EFAULT; 612 --- 59 unchanged lines hidden (view full) --- 672 return -local_errno; 673 674 return process->allocFD(fd, path.c_str(), hostFlags, mode, false); 675} 676 677/// Target open() handler. 678template <class OS> 679SyscallReturn |
680openFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 680openFunc(SyscallDesc *desc, int callnum, Process *process, |
681 ThreadContext *tc) 682{ 683 return openFunc<OS>(desc, callnum, process, tc, 0); 684} 685 686/// Target openat() handler. 687template <class OS> 688SyscallReturn | 681 ThreadContext *tc) 682{ 683 return openFunc<OS>(desc, callnum, process, tc, 0); 684} 685 686/// Target openat() handler. 687template <class OS> 688SyscallReturn |
689openatFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 690 ThreadContext *tc) | 689openatFunc(SyscallDesc *desc, int callnum, Process *process, 690 ThreadContext *tc) |
691{ 692 int index = 0; 693 int dirfd = process->getSyscallArg(tc, index); 694 if (dirfd != OS::TGT_AT_FDCWD) 695 warn("openat: first argument not AT_FDCWD; unlikely to work"); 696 return openFunc<OS>(desc, callnum, process, tc, 1); 697} 698 699/// Target unlinkat() handler. 700template <class OS> 701SyscallReturn | 691{ 692 int index = 0; 693 int dirfd = process->getSyscallArg(tc, index); 694 if (dirfd != OS::TGT_AT_FDCWD) 695 warn("openat: first argument not AT_FDCWD; unlikely to work"); 696 return openFunc<OS>(desc, callnum, process, tc, 1); 697} 698 699/// Target unlinkat() handler. 700template <class OS> 701SyscallReturn |
702unlinkatFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 702unlinkatFunc(SyscallDesc *desc, int callnum, Process *process, |
703 ThreadContext *tc) 704{ 705 int index = 0; 706 int dirfd = process->getSyscallArg(tc, index); 707 if (dirfd != OS::TGT_AT_FDCWD) 708 warn("unlinkat: first argument not AT_FDCWD; unlikely to work"); 709 710 return unlinkHelper(desc, callnum, process, tc, 1); 711} 712 713/// Target facessat() handler 714template <class OS> 715SyscallReturn | 703 ThreadContext *tc) 704{ 705 int index = 0; 706 int dirfd = process->getSyscallArg(tc, index); 707 if (dirfd != OS::TGT_AT_FDCWD) 708 warn("unlinkat: first argument not AT_FDCWD; unlikely to work"); 709 710 return unlinkHelper(desc, callnum, process, tc, 1); 711} 712 713/// Target facessat() handler 714template <class OS> 715SyscallReturn |
716faccessatFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 717 ThreadContext *tc) | 716faccessatFunc(SyscallDesc *desc, int callnum, Process *process, 717 ThreadContext *tc) |
718{ 719 int index = 0; 720 int dirfd = process->getSyscallArg(tc, index); 721 if (dirfd != OS::TGT_AT_FDCWD) 722 warn("faccessat: first argument not AT_FDCWD; unlikely to work"); 723 return accessFunc(desc, callnum, process, tc, 1); 724} 725 726/// Target readlinkat() handler 727template <class OS> 728SyscallReturn | 718{ 719 int index = 0; 720 int dirfd = process->getSyscallArg(tc, index); 721 if (dirfd != OS::TGT_AT_FDCWD) 722 warn("faccessat: first argument not AT_FDCWD; unlikely to work"); 723 return accessFunc(desc, callnum, process, tc, 1); 724} 725 726/// Target readlinkat() handler 727template <class OS> 728SyscallReturn |
729readlinkatFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 730 ThreadContext *tc) | 729readlinkatFunc(SyscallDesc *desc, int callnum, Process *process, 730 ThreadContext *tc) |
731{ 732 int index = 0; 733 int dirfd = process->getSyscallArg(tc, index); 734 if (dirfd != OS::TGT_AT_FDCWD) 735 warn("openat: first argument not AT_FDCWD; unlikely to work"); 736 return readlinkFunc(desc, callnum, process, tc, 1); 737} 738 739/// Target renameat() handler. 740template <class OS> 741SyscallReturn | 731{ 732 int index = 0; 733 int dirfd = process->getSyscallArg(tc, index); 734 if (dirfd != OS::TGT_AT_FDCWD) 735 warn("openat: first argument not AT_FDCWD; unlikely to work"); 736 return readlinkFunc(desc, callnum, process, tc, 1); 737} 738 739/// Target renameat() handler. 740template <class OS> 741SyscallReturn |
742renameatFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 742renameatFunc(SyscallDesc *desc, int callnum, Process *process, |
743 ThreadContext *tc) 744{ 745 int index = 0; 746 747 int olddirfd = process->getSyscallArg(tc, index); 748 if (olddirfd != OS::TGT_AT_FDCWD) 749 warn("renameat: first argument not AT_FDCWD; unlikely to work"); 750 --- 19 unchanged lines hidden (view full) --- 770 771 int result = rename(old_name.c_str(), new_name.c_str()); 772 return (result == -1) ? -errno : result; 773} 774 775/// Target sysinfo() handler. 776template <class OS> 777SyscallReturn | 743 ThreadContext *tc) 744{ 745 int index = 0; 746 747 int olddirfd = process->getSyscallArg(tc, index); 748 if (olddirfd != OS::TGT_AT_FDCWD) 749 warn("renameat: first argument not AT_FDCWD; unlikely to work"); 750 --- 19 unchanged lines hidden (view full) --- 770 771 int result = rename(old_name.c_str(), new_name.c_str()); 772 return (result == -1) ? -errno : result; 773} 774 775/// Target sysinfo() handler. 776template <class OS> 777SyscallReturn |
778sysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 779 ThreadContext *tc) | 778sysinfoFunc(SyscallDesc *desc, int callnum, Process *process, 779 ThreadContext *tc) |
780{ 781 782 int index = 0; 783 TypedBufferArg<typename OS::tgt_sysinfo> 784 sysinfo(process->getSyscallArg(tc, index)); 785 786 sysinfo->uptime = seconds_since_epoch; 787 sysinfo->totalram = process->system->memSize(); 788 sysinfo->mem_unit = 1; 789 790 sysinfo.copyOut(tc->getMemProxy()); 791 792 return 0; 793} 794 795/// Target chmod() handler. 796template <class OS> 797SyscallReturn | 780{ 781 782 int index = 0; 783 TypedBufferArg<typename OS::tgt_sysinfo> 784 sysinfo(process->getSyscallArg(tc, index)); 785 786 sysinfo->uptime = seconds_since_epoch; 787 sysinfo->totalram = process->system->memSize(); 788 sysinfo->mem_unit = 1; 789 790 sysinfo.copyOut(tc->getMemProxy()); 791 792 return 0; 793} 794 795/// Target chmod() handler. 796template <class OS> 797SyscallReturn |
798chmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 798chmodFunc(SyscallDesc *desc, int callnum, Process *process, |
799 ThreadContext *tc) 800{ 801 std::string path; 802 803 int index = 0; 804 if (!tc->getMemProxy().tryReadString(path, 805 process->getSyscallArg(tc, index))) { 806 return -EFAULT; --- 15 unchanged lines hidden (view full) --- 822 823 return 0; 824} 825 826 827/// Target fchmod() handler. 828template <class OS> 829SyscallReturn | 799 ThreadContext *tc) 800{ 801 std::string path; 802 803 int index = 0; 804 if (!tc->getMemProxy().tryReadString(path, 805 process->getSyscallArg(tc, index))) { 806 return -EFAULT; --- 15 unchanged lines hidden (view full) --- 822 823 return 0; 824} 825 826 827/// Target fchmod() handler. 828template <class OS> 829SyscallReturn |
830fchmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 830fchmodFunc(SyscallDesc *desc, int callnum, Process *process, |
831 ThreadContext *tc) 832{ 833 int index = 0; 834 int tgt_fd = process->getSyscallArg(tc, index); 835 uint32_t mode = process->getSyscallArg(tc, index); 836 837 int sim_fd = process->getSimFD(tgt_fd); 838 if (sim_fd < 0) --- 10 unchanged lines hidden (view full) --- 849 return -errno; 850 851 return 0; 852} 853 854/// Target mremap() handler. 855template <class OS> 856SyscallReturn | 831 ThreadContext *tc) 832{ 833 int index = 0; 834 int tgt_fd = process->getSyscallArg(tc, index); 835 uint32_t mode = process->getSyscallArg(tc, index); 836 837 int sim_fd = process->getSimFD(tgt_fd); 838 if (sim_fd < 0) --- 10 unchanged lines hidden (view full) --- 849 return -errno; 850 851 return 0; 852} 853 854/// Target mremap() handler. 855template <class OS> 856SyscallReturn |
857mremapFunc(SyscallDesc *desc, int callnum, LiveProcess *process, ThreadContext *tc) | 857mremapFunc(SyscallDesc *desc, int callnum, Process *process, ThreadContext *tc) |
858{ 859 int index = 0; 860 Addr start = process->getSyscallArg(tc, index); 861 uint64_t old_length = process->getSyscallArg(tc, index); 862 uint64_t new_length = process->getSyscallArg(tc, index); 863 uint64_t flags = process->getSyscallArg(tc, index); 864 uint64_t provided_address = 0; 865 bool use_provided_address = flags & OS::TGT_MREMAP_FIXED; --- 49 unchanged lines hidden (view full) --- 915 process->pTable->unmap(start + new_length, old_length - new_length); 916 return use_provided_address ? provided_address : start; 917 } 918} 919 920/// Target stat() handler. 921template <class OS> 922SyscallReturn | 858{ 859 int index = 0; 860 Addr start = process->getSyscallArg(tc, index); 861 uint64_t old_length = process->getSyscallArg(tc, index); 862 uint64_t new_length = process->getSyscallArg(tc, index); 863 uint64_t flags = process->getSyscallArg(tc, index); 864 uint64_t provided_address = 0; 865 bool use_provided_address = flags & OS::TGT_MREMAP_FIXED; --- 49 unchanged lines hidden (view full) --- 915 process->pTable->unmap(start + new_length, old_length - new_length); 916 return use_provided_address ? provided_address : start; 917 } 918} 919 920/// Target stat() handler. 921template <class OS> 922SyscallReturn |
923statFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 923statFunc(SyscallDesc *desc, int callnum, Process *process, |
924 ThreadContext *tc) 925{ 926 std::string path; 927 928 int index = 0; 929 if (!tc->getMemProxy().tryReadString(path, 930 process->getSyscallArg(tc, index))) { 931 return -EFAULT; --- 13 unchanged lines hidden (view full) --- 945 946 return 0; 947} 948 949 950/// Target stat64() handler. 951template <class OS> 952SyscallReturn | 924 ThreadContext *tc) 925{ 926 std::string path; 927 928 int index = 0; 929 if (!tc->getMemProxy().tryReadString(path, 930 process->getSyscallArg(tc, index))) { 931 return -EFAULT; --- 13 unchanged lines hidden (view full) --- 945 946 return 0; 947} 948 949 950/// Target stat64() handler. 951template <class OS> 952SyscallReturn |
953stat64Func(SyscallDesc *desc, int callnum, LiveProcess *process, | 953stat64Func(SyscallDesc *desc, int callnum, Process *process, |
954 ThreadContext *tc) 955{ 956 std::string path; 957 958 int index = 0; 959 if (!tc->getMemProxy().tryReadString(path, 960 process->getSyscallArg(tc, index))) 961 return -EFAULT; --- 17 unchanged lines hidden (view full) --- 979 980 return 0; 981} 982 983 984/// Target fstatat64() handler. 985template <class OS> 986SyscallReturn | 954 ThreadContext *tc) 955{ 956 std::string path; 957 958 int index = 0; 959 if (!tc->getMemProxy().tryReadString(path, 960 process->getSyscallArg(tc, index))) 961 return -EFAULT; --- 17 unchanged lines hidden (view full) --- 979 980 return 0; 981} 982 983 984/// Target fstatat64() handler. 985template <class OS> 986SyscallReturn |
987fstatat64Func(SyscallDesc *desc, int callnum, LiveProcess *process, | 987fstatat64Func(SyscallDesc *desc, int callnum, Process *process, |
988 ThreadContext *tc) 989{ 990 int index = 0; 991 int dirfd = process->getSyscallArg(tc, index); 992 if (dirfd != OS::TGT_AT_FDCWD) 993 warn("fstatat64: first argument not AT_FDCWD; unlikely to work"); 994 995 std::string path; --- 20 unchanged lines hidden (view full) --- 1016 1017 return 0; 1018} 1019 1020 1021/// Target fstat64() handler. 1022template <class OS> 1023SyscallReturn | 988 ThreadContext *tc) 989{ 990 int index = 0; 991 int dirfd = process->getSyscallArg(tc, index); 992 if (dirfd != OS::TGT_AT_FDCWD) 993 warn("fstatat64: first argument not AT_FDCWD; unlikely to work"); 994 995 std::string path; --- 20 unchanged lines hidden (view full) --- 1016 1017 return 0; 1018} 1019 1020 1021/// Target fstat64() handler. 1022template <class OS> 1023SyscallReturn |
1024fstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process, | 1024fstat64Func(SyscallDesc *desc, int callnum, Process *process, |
1025 ThreadContext *tc) 1026{ 1027 int index = 0; 1028 int tgt_fd = process->getSyscallArg(tc, index); 1029 Addr bufPtr = process->getSyscallArg(tc, index); 1030 1031 int sim_fd = process->getSimFD(tgt_fd); 1032 if (sim_fd < 0) --- 14 unchanged lines hidden (view full) --- 1047 1048 return 0; 1049} 1050 1051 1052/// Target lstat() handler. 1053template <class OS> 1054SyscallReturn | 1025 ThreadContext *tc) 1026{ 1027 int index = 0; 1028 int tgt_fd = process->getSyscallArg(tc, index); 1029 Addr bufPtr = process->getSyscallArg(tc, index); 1030 1031 int sim_fd = process->getSimFD(tgt_fd); 1032 if (sim_fd < 0) --- 14 unchanged lines hidden (view full) --- 1047 1048 return 0; 1049} 1050 1051 1052/// Target lstat() handler. 1053template <class OS> 1054SyscallReturn |
1055lstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 1055lstatFunc(SyscallDesc *desc, int callnum, Process *process, |
1056 ThreadContext *tc) 1057{ 1058 std::string path; 1059 1060 int index = 0; 1061 if (!tc->getMemProxy().tryReadString(path, 1062 process->getSyscallArg(tc, index))) { 1063 return -EFAULT; --- 12 unchanged lines hidden (view full) --- 1076 copyOutStatBuf<OS>(tc->getMemProxy(), bufPtr, &hostBuf); 1077 1078 return 0; 1079} 1080 1081/// Target lstat64() handler. 1082template <class OS> 1083SyscallReturn | 1056 ThreadContext *tc) 1057{ 1058 std::string path; 1059 1060 int index = 0; 1061 if (!tc->getMemProxy().tryReadString(path, 1062 process->getSyscallArg(tc, index))) { 1063 return -EFAULT; --- 12 unchanged lines hidden (view full) --- 1076 copyOutStatBuf<OS>(tc->getMemProxy(), bufPtr, &hostBuf); 1077 1078 return 0; 1079} 1080 1081/// Target lstat64() handler. 1082template <class OS> 1083SyscallReturn |
1084lstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process, | 1084lstat64Func(SyscallDesc *desc, int callnum, Process *process, |
1085 ThreadContext *tc) 1086{ 1087 std::string path; 1088 1089 int index = 0; 1090 if (!tc->getMemProxy().tryReadString(path, 1091 process->getSyscallArg(tc, index))) { 1092 return -EFAULT; --- 17 unchanged lines hidden (view full) --- 1110 copyOutStat64Buf<OS>(tc->getMemProxy(), bufPtr, &hostBuf); 1111 1112 return 0; 1113} 1114 1115/// Target fstat() handler. 1116template <class OS> 1117SyscallReturn | 1085 ThreadContext *tc) 1086{ 1087 std::string path; 1088 1089 int index = 0; 1090 if (!tc->getMemProxy().tryReadString(path, 1091 process->getSyscallArg(tc, index))) { 1092 return -EFAULT; --- 17 unchanged lines hidden (view full) --- 1110 copyOutStat64Buf<OS>(tc->getMemProxy(), bufPtr, &hostBuf); 1111 1112 return 0; 1113} 1114 1115/// Target fstat() handler. 1116template <class OS> 1117SyscallReturn |
1118fstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 1118fstatFunc(SyscallDesc *desc, int callnum, Process *process, |
1119 ThreadContext *tc) 1120{ 1121 int index = 0; 1122 int tgt_fd = process->getSyscallArg(tc, index); 1123 Addr bufPtr = process->getSyscallArg(tc, index); 1124 1125 DPRINTF_SYSCALL(Verbose, "fstat(%d, ...)\n", tgt_fd); 1126 --- 11 unchanged lines hidden (view full) --- 1138 1139 return 0; 1140} 1141 1142 1143/// Target statfs() handler. 1144template <class OS> 1145SyscallReturn | 1119 ThreadContext *tc) 1120{ 1121 int index = 0; 1122 int tgt_fd = process->getSyscallArg(tc, index); 1123 Addr bufPtr = process->getSyscallArg(tc, index); 1124 1125 DPRINTF_SYSCALL(Verbose, "fstat(%d, ...)\n", tgt_fd); 1126 --- 11 unchanged lines hidden (view full) --- 1138 1139 return 0; 1140} 1141 1142 1143/// Target statfs() handler. 1144template <class OS> 1145SyscallReturn |
1146statfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 1146statfsFunc(SyscallDesc *desc, int callnum, Process *process, |
1147 ThreadContext *tc) 1148{ 1149#if NO_STATFS 1150 warn("Host OS cannot support calls to statfs. Ignoring syscall"); 1151#else 1152 std::string path; 1153 1154 int index = 0; --- 16 unchanged lines hidden (view full) --- 1171#endif 1172 return 0; 1173} 1174 1175 1176/// Target fstatfs() handler. 1177template <class OS> 1178SyscallReturn | 1147 ThreadContext *tc) 1148{ 1149#if NO_STATFS 1150 warn("Host OS cannot support calls to statfs. Ignoring syscall"); 1151#else 1152 std::string path; 1153 1154 int index = 0; --- 16 unchanged lines hidden (view full) --- 1171#endif 1172 return 0; 1173} 1174 1175 1176/// Target fstatfs() handler. 1177template <class OS> 1178SyscallReturn |
1179fstatfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 1179fstatfsFunc(SyscallDesc *desc, int callnum, Process *process, |
1180 ThreadContext *tc) 1181{ 1182 int index = 0; 1183 int tgt_fd = process->getSyscallArg(tc, index); 1184 Addr bufPtr = process->getSyscallArg(tc, index); 1185 1186 int sim_fd = process->getSimFD(tgt_fd); 1187 if (sim_fd < 0) --- 9 unchanged lines hidden (view full) --- 1197 1198 return 0; 1199} 1200 1201 1202/// Target writev() handler. 1203template <class OS> 1204SyscallReturn | 1180 ThreadContext *tc) 1181{ 1182 int index = 0; 1183 int tgt_fd = process->getSyscallArg(tc, index); 1184 Addr bufPtr = process->getSyscallArg(tc, index); 1185 1186 int sim_fd = process->getSimFD(tgt_fd); 1187 if (sim_fd < 0) --- 9 unchanged lines hidden (view full) --- 1197 1198 return 0; 1199} 1200 1201 1202/// Target writev() handler. 1203template <class OS> 1204SyscallReturn |
1205writevFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 1205writevFunc(SyscallDesc *desc, int callnum, Process *process, |
1206 ThreadContext *tc) 1207{ 1208 int index = 0; 1209 int tgt_fd = process->getSyscallArg(tc, index); 1210 1211 int sim_fd = process->getSimFD(tgt_fd); 1212 if (sim_fd < 0) 1213 return -EBADF; --- 22 unchanged lines hidden (view full) --- 1236 return -errno; 1237 1238 return result; 1239} 1240 1241/// Real mmap handler. 1242template <class OS> 1243SyscallReturn | 1206 ThreadContext *tc) 1207{ 1208 int index = 0; 1209 int tgt_fd = process->getSyscallArg(tc, index); 1210 1211 int sim_fd = process->getSimFD(tgt_fd); 1212 if (sim_fd < 0) 1213 return -EBADF; --- 22 unchanged lines hidden (view full) --- 1236 return -errno; 1237 1238 return result; 1239} 1240 1241/// Real mmap handler. 1242template <class OS> 1243SyscallReturn |
1244mmapImpl(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc, | 1244mmapImpl(SyscallDesc *desc, int num, Process *p, ThreadContext *tc, |
1245 bool is_mmap2) 1246{ 1247 int index = 0; 1248 Addr start = p->getSyscallArg(tc, index); 1249 uint64_t length = p->getSyscallArg(tc, index); 1250 int prot = p->getSyscallArg(tc, index); 1251 int tgt_flags = p->getSyscallArg(tc, index); 1252 int tgt_fd = p->getSyscallArg(tc, index); --- 156 unchanged lines hidden (view full) --- 1409 // execution (hopefully). 1410 } 1411 1412 return start; 1413} 1414 1415template <class OS> 1416SyscallReturn | 1245 bool is_mmap2) 1246{ 1247 int index = 0; 1248 Addr start = p->getSyscallArg(tc, index); 1249 uint64_t length = p->getSyscallArg(tc, index); 1250 int prot = p->getSyscallArg(tc, index); 1251 int tgt_flags = p->getSyscallArg(tc, index); 1252 int tgt_fd = p->getSyscallArg(tc, index); --- 156 unchanged lines hidden (view full) --- 1409 // execution (hopefully). 1410 } 1411 1412 return start; 1413} 1414 1415template <class OS> 1416SyscallReturn |
1417pwrite64Func(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) | 1417pwrite64Func(SyscallDesc *desc, int num, Process *p, ThreadContext *tc) |
1418{ 1419 int index = 0; 1420 int tgt_fd = p->getSyscallArg(tc, index); 1421 Addr bufPtr = p->getSyscallArg(tc, index); 1422 int nbytes = p->getSyscallArg(tc, index); 1423 int offset = p->getSyscallArg(tc, index); 1424 1425 int sim_fd = p->getSimFD(tgt_fd); --- 6 unchanged lines hidden (view full) --- 1432 int bytes_written = pwrite(sim_fd, bufArg.bufferPtr(), nbytes, offset); 1433 1434 return (bytes_written == -1) ? -errno : bytes_written; 1435} 1436 1437/// Target mmap() handler. 1438template <class OS> 1439SyscallReturn | 1418{ 1419 int index = 0; 1420 int tgt_fd = p->getSyscallArg(tc, index); 1421 Addr bufPtr = p->getSyscallArg(tc, index); 1422 int nbytes = p->getSyscallArg(tc, index); 1423 int offset = p->getSyscallArg(tc, index); 1424 1425 int sim_fd = p->getSimFD(tgt_fd); --- 6 unchanged lines hidden (view full) --- 1432 int bytes_written = pwrite(sim_fd, bufArg.bufferPtr(), nbytes, offset); 1433 1434 return (bytes_written == -1) ? -errno : bytes_written; 1435} 1436 1437/// Target mmap() handler. 1438template <class OS> 1439SyscallReturn |
1440mmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) | 1440mmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc) |
1441{ 1442 return mmapImpl<OS>(desc, num, p, tc, false); 1443} 1444 1445/// Target mmap2() handler. 1446template <class OS> 1447SyscallReturn | 1441{ 1442 return mmapImpl<OS>(desc, num, p, tc, false); 1443} 1444 1445/// Target mmap2() handler. 1446template <class OS> 1447SyscallReturn |
1448mmap2Func(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) | 1448mmap2Func(SyscallDesc *desc, int num, Process *p, ThreadContext *tc) |
1449{ 1450 return mmapImpl<OS>(desc, num, p, tc, true); 1451} 1452 1453/// Target getrlimit() handler. 1454template <class OS> 1455SyscallReturn | 1449{ 1450 return mmapImpl<OS>(desc, num, p, tc, true); 1451} 1452 1453/// Target getrlimit() handler. 1454template <class OS> 1455SyscallReturn |
1456getrlimitFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 1457 ThreadContext *tc) | 1456getrlimitFunc(SyscallDesc *desc, int callnum, Process *process, 1457 ThreadContext *tc) |
1458{ 1459 int index = 0; 1460 unsigned resource = process->getSyscallArg(tc, index); 1461 TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, index)); 1462 1463 switch (resource) { 1464 case OS::TGT_RLIMIT_STACK: 1465 // max stack size in bytes: make up a number (8MB for now) --- 17 unchanged lines hidden (view full) --- 1483 1484 rlp.copyOut(tc->getMemProxy()); 1485 return 0; 1486} 1487 1488/// Target clock_gettime() function. 1489template <class OS> 1490SyscallReturn | 1458{ 1459 int index = 0; 1460 unsigned resource = process->getSyscallArg(tc, index); 1461 TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, index)); 1462 1463 switch (resource) { 1464 case OS::TGT_RLIMIT_STACK: 1465 // max stack size in bytes: make up a number (8MB for now) --- 17 unchanged lines hidden (view full) --- 1483 1484 rlp.copyOut(tc->getMemProxy()); 1485 return 0; 1486} 1487 1488/// Target clock_gettime() function. 1489template <class OS> 1490SyscallReturn |
1491clock_gettimeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) | 1491clock_gettimeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc) |
1492{ 1493 int index = 1; 1494 //int clk_id = p->getSyscallArg(tc, index); 1495 TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index)); 1496 1497 getElapsedTimeNano(tp->tv_sec, tp->tv_nsec); 1498 tp->tv_sec += seconds_since_epoch; 1499 tp->tv_sec = TheISA::htog(tp->tv_sec); 1500 tp->tv_nsec = TheISA::htog(tp->tv_nsec); 1501 1502 tp.copyOut(tc->getMemProxy()); 1503 1504 return 0; 1505} 1506 1507/// Target clock_getres() function. 1508template <class OS> 1509SyscallReturn | 1492{ 1493 int index = 1; 1494 //int clk_id = p->getSyscallArg(tc, index); 1495 TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index)); 1496 1497 getElapsedTimeNano(tp->tv_sec, tp->tv_nsec); 1498 tp->tv_sec += seconds_since_epoch; 1499 tp->tv_sec = TheISA::htog(tp->tv_sec); 1500 tp->tv_nsec = TheISA::htog(tp->tv_nsec); 1501 1502 tp.copyOut(tc->getMemProxy()); 1503 1504 return 0; 1505} 1506 1507/// Target clock_getres() function. 1508template <class OS> 1509SyscallReturn |
1510clock_getresFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) | 1510clock_getresFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc) |
1511{ 1512 int index = 1; 1513 TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index)); 1514 1515 // Set resolution at ns, which is what clock_gettime() returns 1516 tp->tv_sec = 0; 1517 tp->tv_nsec = 1; 1518 1519 tp.copyOut(tc->getMemProxy()); 1520 1521 return 0; 1522} 1523 1524/// Target gettimeofday() handler. 1525template <class OS> 1526SyscallReturn | 1511{ 1512 int index = 1; 1513 TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index)); 1514 1515 // Set resolution at ns, which is what clock_gettime() returns 1516 tp->tv_sec = 0; 1517 tp->tv_nsec = 1; 1518 1519 tp.copyOut(tc->getMemProxy()); 1520 1521 return 0; 1522} 1523 1524/// Target gettimeofday() handler. 1525template <class OS> 1526SyscallReturn |
1527gettimeofdayFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 1528 ThreadContext *tc) | 1527gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process, 1528 ThreadContext *tc) |
1529{ 1530 int index = 0; 1531 TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, index)); 1532 1533 getElapsedTimeMicro(tp->tv_sec, tp->tv_usec); 1534 tp->tv_sec += seconds_since_epoch; 1535 tp->tv_sec = TheISA::htog(tp->tv_sec); 1536 tp->tv_usec = TheISA::htog(tp->tv_usec); 1537 1538 tp.copyOut(tc->getMemProxy()); 1539 1540 return 0; 1541} 1542 1543 1544/// Target utimes() handler. 1545template <class OS> 1546SyscallReturn | 1529{ 1530 int index = 0; 1531 TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, index)); 1532 1533 getElapsedTimeMicro(tp->tv_sec, tp->tv_usec); 1534 tp->tv_sec += seconds_since_epoch; 1535 tp->tv_sec = TheISA::htog(tp->tv_sec); 1536 tp->tv_usec = TheISA::htog(tp->tv_usec); 1537 1538 tp.copyOut(tc->getMemProxy()); 1539 1540 return 0; 1541} 1542 1543 1544/// Target utimes() handler. 1545template <class OS> 1546SyscallReturn |
1547utimesFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 1547utimesFunc(SyscallDesc *desc, int callnum, Process *process, |
1548 ThreadContext *tc) 1549{ 1550 std::string path; 1551 1552 int index = 0; 1553 if (!tc->getMemProxy().tryReadString(path, 1554 process->getSyscallArg(tc, index))) { 1555 return -EFAULT; --- 18 unchanged lines hidden (view full) --- 1574 if (result < 0) 1575 return -errno; 1576 1577 return 0; 1578} 1579/// Target getrusage() function. 1580template <class OS> 1581SyscallReturn | 1548 ThreadContext *tc) 1549{ 1550 std::string path; 1551 1552 int index = 0; 1553 if (!tc->getMemProxy().tryReadString(path, 1554 process->getSyscallArg(tc, index))) { 1555 return -EFAULT; --- 18 unchanged lines hidden (view full) --- 1574 if (result < 0) 1575 return -errno; 1576 1577 return 0; 1578} 1579/// Target getrusage() function. 1580template <class OS> 1581SyscallReturn |
1582getrusageFunc(SyscallDesc *desc, int callnum, LiveProcess *process, | 1582getrusageFunc(SyscallDesc *desc, int callnum, Process *process, |
1583 ThreadContext *tc) 1584{ 1585 int index = 0; 1586 int who = process->getSyscallArg(tc, index); // THREAD, SELF, or CHILDREN 1587 TypedBufferArg<typename OS::rusage> rup(process->getSyscallArg(tc, index)); 1588 1589 rup->ru_utime.tv_sec = 0; 1590 rup->ru_utime.tv_usec = 0; --- 35 unchanged lines hidden (view full) --- 1626 rup.copyOut(tc->getMemProxy()); 1627 1628 return 0; 1629} 1630 1631/// Target times() function. 1632template <class OS> 1633SyscallReturn | 1583 ThreadContext *tc) 1584{ 1585 int index = 0; 1586 int who = process->getSyscallArg(tc, index); // THREAD, SELF, or CHILDREN 1587 TypedBufferArg<typename OS::rusage> rup(process->getSyscallArg(tc, index)); 1588 1589 rup->ru_utime.tv_sec = 0; 1590 rup->ru_utime.tv_usec = 0; --- 35 unchanged lines hidden (view full) --- 1626 rup.copyOut(tc->getMemProxy()); 1627 1628 return 0; 1629} 1630 1631/// Target times() function. 1632template <class OS> 1633SyscallReturn |
1634timesFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 1635 ThreadContext *tc) | 1634timesFunc(SyscallDesc *desc, int callnum, Process *process, 1635 ThreadContext *tc) |
1636{ 1637 int index = 0; 1638 TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, index)); 1639 1640 // Fill in the time structure (in clocks) 1641 int64_t clocks = curTick() * OS::M5_SC_CLK_TCK / SimClock::Int::s; 1642 bufp->tms_utime = clocks; 1643 bufp->tms_stime = 0; --- 8 unchanged lines hidden (view full) --- 1652 1653 // Return clock ticks since system boot 1654 return clocks; 1655} 1656 1657/// Target time() function. 1658template <class OS> 1659SyscallReturn | 1636{ 1637 int index = 0; 1638 TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, index)); 1639 1640 // Fill in the time structure (in clocks) 1641 int64_t clocks = curTick() * OS::M5_SC_CLK_TCK / SimClock::Int::s; 1642 bufp->tms_utime = clocks; 1643 bufp->tms_stime = 0; --- 8 unchanged lines hidden (view full) --- 1652 1653 // Return clock ticks since system boot 1654 return clocks; 1655} 1656 1657/// Target time() function. 1658template <class OS> 1659SyscallReturn |
1660timeFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 1661 ThreadContext *tc) | 1660timeFunc(SyscallDesc *desc, int callnum, Process *process, ThreadContext *tc) |
1662{ 1663 typename OS::time_t sec, usec; 1664 getElapsedTimeMicro(sec, usec); 1665 sec += seconds_since_epoch; 1666 1667 int index = 0; 1668 Addr taddr = (Addr)process->getSyscallArg(tc, index); 1669 if (taddr != 0) { 1670 typename OS::time_t t = sec; 1671 t = TheISA::htog(t); 1672 SETranslatingPortProxy &p = tc->getMemProxy(); 1673 p.writeBlob(taddr, (uint8_t*)&t, (int)sizeof(typename OS::time_t)); 1674 } 1675 return sec; 1676} 1677 1678 1679#endif // __SIM_SYSCALL_EMUL_HH__ | 1661{ 1662 typename OS::time_t sec, usec; 1663 getElapsedTimeMicro(sec, usec); 1664 sec += seconds_since_epoch; 1665 1666 int index = 0; 1667 Addr taddr = (Addr)process->getSyscallArg(tc, index); 1668 if (taddr != 0) { 1669 typename OS::time_t t = sec; 1670 t = TheISA::htog(t); 1671 SETranslatingPortProxy &p = tc->getMemProxy(); 1672 p.writeBlob(taddr, (uint8_t*)&t, (int)sizeof(typename OS::time_t)); 1673 } 1674 return sec; 1675} 1676 1677 1678#endif // __SIM_SYSCALL_EMUL_HH__ |