syscall_emul.hh (3079:13d9c24a7bba) syscall_emul.hh (3113:a6811aaea654)
1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 32 unchanged lines hidden (view full) ---

41/// This file defines objects used to emulate syscalls from the target
42/// application on the host machine.
43
44#include <errno.h>
45#include <string>
46#ifdef __CYGWIN32__
47#include <sys/fcntl.h> // for O_BINARY
48#endif
1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 32 unchanged lines hidden (view full) ---

41/// This file defines objects used to emulate syscalls from the target
42/// application on the host machine.
43
44#include <errno.h>
45#include <string>
46#ifdef __CYGWIN32__
47#include <sys/fcntl.h> // for O_BINARY
48#endif
49#include <sys/stat.h>
50#include <fcntl.h>
49#include <sys/uio.h>
50
51#include <sys/uio.h>
52
51#include "arch/isa_traits.hh" // for Addr
53#include "sim/host.hh" // for Addr
52#include "base/chunk_generator.hh"
53#include "base/intmath.hh" // for RoundUp
54#include "base/misc.hh"
55#include "base/trace.hh"
56#include "cpu/base.hh"
57#include "cpu/thread_context.hh"
58#include "mem/translating_port.hh"
59#include "mem/page_table.hh"

--- 240 unchanged lines hidden (view full) ---

300SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num,
301 Process *p, ThreadContext *tc);
302
303/// Target getgidPseudo() handler.
304SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num,
305 Process *p, ThreadContext *tc);
306
307
54#include "base/chunk_generator.hh"
55#include "base/intmath.hh" // for RoundUp
56#include "base/misc.hh"
57#include "base/trace.hh"
58#include "cpu/base.hh"
59#include "cpu/thread_context.hh"
60#include "mem/translating_port.hh"
61#include "mem/page_table.hh"

--- 240 unchanged lines hidden (view full) ---

302SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num,
303 Process *p, ThreadContext *tc);
304
305/// Target getgidPseudo() handler.
306SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num,
307 Process *p, ThreadContext *tc);
308
309
308/// This struct is used to build an target-OS-dependent table that
309/// maps the target's open() flags to the host open() flags.
310struct OpenFlagTransTable {
311 int tgtFlag; //!< Target system flag value.
312 int hostFlag; //!< Corresponding host system flag value.
313};
314
315
316
317/// A readable name for 1,000,000, for converting microseconds to seconds.
318const int one_million = 1000000;
319
320/// Approximate seconds since the epoch (1/1/1970). About a billion,
321/// by my reckoning. We want to keep this a constant (not use the
322/// real-world time) to keep simulations repeatable.
323const unsigned seconds_since_epoch = 1000000000;
324

--- 10 unchanged lines hidden (view full) ---

335
336//////////////////////////////////////////////////////////////////////
337//
338// The following emulation functions are generic, but need to be
339// templated to account for differences in types, constants, etc.
340//
341//////////////////////////////////////////////////////////////////////
342
310/// A readable name for 1,000,000, for converting microseconds to seconds.
311const int one_million = 1000000;
312
313/// Approximate seconds since the epoch (1/1/1970). About a billion,
314/// by my reckoning. We want to keep this a constant (not use the
315/// real-world time) to keep simulations repeatable.
316const unsigned seconds_since_epoch = 1000000000;
317

--- 10 unchanged lines hidden (view full) ---

328
329//////////////////////////////////////////////////////////////////////
330//
331// The following emulation functions are generic, but need to be
332// templated to account for differences in types, constants, etc.
333//
334//////////////////////////////////////////////////////////////////////
335
336#if NO_STAT64
337 typedef struct stat hst_stat;
338 typedef struct stat hst_stat64;
339#else
340 typedef struct stat hst_stat;
341 typedef struct stat64 hst_stat64;
342#endif
343
344//// Helper function to convert a host stat buffer to a target stat
345//// buffer. Also copies the target buffer out to the simulated
346//// memory space. Used by stat(), fstat(), and lstat().
347
348template <typename target_stat, typename host_stat>
349static void
350convertStatBuf(target_stat &tgt, host_stat *host, bool fakeTTY = false)
351{
352 if (fakeTTY)
353 tgt->st_dev = 0xA;
354 else
355 tgt->st_dev = host->st_dev;
356 tgt->st_dev = htog(tgt->st_dev);
357 tgt->st_ino = host->st_ino;
358 tgt->st_ino = htog(tgt->st_ino);
359 if (fakeTTY)
360 tgt->st_rdev = 0x880d;
361 else
362 tgt->st_rdev = host->st_rdev;
363 tgt->st_rdev = htog(tgt->st_rdev);
364 tgt->st_size = host->st_size;
365 tgt->st_size = htog(tgt->st_size);
366 tgt->st_atimeX = host->st_atimeX;
367 tgt->st_atimeX = htog(tgt->st_atimeX);
368 tgt->st_mtimeX = host->st_mtimeX;
369 tgt->st_mtimeX = htog(tgt->st_mtimeX);
370 tgt->st_ctimeX = host->st_ctimeX;
371 tgt->st_ctimeX = htog(tgt->st_ctimeX);
372 tgt->st_blksize = host->st_blksize;
373 tgt->st_blksize = htog(tgt->st_blksize);
374 tgt->st_blocks = host->st_blocks;
375 tgt->st_blocks = htog(tgt->st_blocks);
376}
377
378// Same for stat64
379
380template <typename target_stat, typename host_stat64>
381static void
382convertStat64Buf(target_stat &tgt, host_stat64 *host, bool fakeTTY = false)
383{
384 convertStatBuf<target_stat, host_stat64>(tgt, host, fakeTTY);
385#if defined(STAT_HAVE_NSEC)
386 tgt->st_atime_nsec = host->st_atime_nsec;
387 tgt->st_atime_nsec = htog(tgt->st_atime_nsec);
388 tgt->st_mtime_nsec = host->st_mtime_nsec;
389 tgt->st_mtime_nsec = htog(tgt->st_mtime_nsec);
390 tgt->st_ctime_nsec = host->st_ctime_nsec;
391 tgt->st_ctime_nsec = htog(tgt->st_ctime_nsec);
392#else
393 tgt->st_atime_nsec = 0;
394 tgt->st_mtime_nsec = 0;
395 tgt->st_ctime_nsec = 0;
396#endif
397}
398
399//Here are a couple convenience functions
400template<class OS>
401static void
402copyOutStatBuf(TranslatingPort * mem, Addr addr,
403 hst_stat *host, bool fakeTTY = false)
404{
405 typedef TypedBufferArg<typename OS::tgt_stat> tgt_stat_buf;
406 tgt_stat_buf tgt(addr);
407 convertStatBuf<tgt_stat_buf, hst_stat>(tgt, host, fakeTTY);
408 tgt.copyOut(mem);
409}
410
411template<class OS>
412static void
413copyOutStat64Buf(TranslatingPort * mem, Addr addr,
414 hst_stat64 *host, bool fakeTTY = false)
415{
416 typedef TypedBufferArg<typename OS::tgt_stat64> tgt_stat_buf;
417 tgt_stat_buf tgt(addr);
418 convertStatBuf<tgt_stat_buf, hst_stat64>(tgt, host, fakeTTY);
419 tgt.copyOut(mem);
420}
421
343/// Target ioctl() handler. For the most part, programs call ioctl()
344/// only to find out if their stdout is a tty, to determine whether to
345/// do line or block buffering.
346template <class OS>
347SyscallReturn
348ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
349 ThreadContext *tc)
350{

--- 136 unchanged lines hidden (view full) ---

487 return -EFAULT;
488
489 struct stat hostBuf;
490 int result = stat(path.c_str(), &hostBuf);
491
492 if (result < 0)
493 return -errno;
494
422/// Target ioctl() handler. For the most part, programs call ioctl()
423/// only to find out if their stdout is a tty, to determine whether to
424/// do line or block buffering.
425template <class OS>
426SyscallReturn
427ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
428 ThreadContext *tc)
429{

--- 136 unchanged lines hidden (view full) ---

566 return -EFAULT;
567
568 struct stat hostBuf;
569 int result = stat(path.c_str(), &hostBuf);
570
571 if (result < 0)
572 return -errno;
573
495 OS::copyOutStatBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
574 copyOutStatBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
496
497 return 0;
498}
499
500
501/// Target fstat64() handler.
502template <class OS>
503SyscallReturn

--- 12 unchanged lines hidden (view full) ---

516#else
517 struct stat64 hostBuf;
518 int result = fstat64(process->sim_fd(fd), &hostBuf);
519#endif
520
521 if (result < 0)
522 return -errno;
523
575
576 return 0;
577}
578
579
580/// Target fstat64() handler.
581template <class OS>
582SyscallReturn

--- 12 unchanged lines hidden (view full) ---

595#else
596 struct stat64 hostBuf;
597 int result = fstat64(process->sim_fd(fd), &hostBuf);
598#endif
599
600 if (result < 0)
601 return -errno;
602
524 OS::copyOutStat64Buf(tc->getMemPort(), fd, tc->getSyscallArg(1), &hostBuf);
603 copyOutStat64Buf<OS>(tc->getMemPort(), fd, tc->getSyscallArg(1), &hostBuf);
525
526 return 0;
527}
528
529
530/// Target lstat() handler.
531template <class OS>
532SyscallReturn

--- 6 unchanged lines hidden (view full) ---

539 return -EFAULT;
540
541 struct stat hostBuf;
542 int result = lstat(path.c_str(), &hostBuf);
543
544 if (result < 0)
545 return -errno;
546
604
605 return 0;
606}
607
608
609/// Target lstat() handler.
610template <class OS>
611SyscallReturn

--- 6 unchanged lines hidden (view full) ---

618 return -EFAULT;
619
620 struct stat hostBuf;
621 int result = lstat(path.c_str(), &hostBuf);
622
623 if (result < 0)
624 return -errno;
625
547 OS::copyOutStatBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
626 copyOutStatBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
548
549 return 0;
550}
551
552/// Target lstat64() handler.
553template <class OS>
554SyscallReturn
555lstat64Func(SyscallDesc *desc, int callnum, Process *process,

--- 10 unchanged lines hidden (view full) ---

566#else
567 struct stat64 hostBuf;
568 int result = lstat64(path.c_str(), &hostBuf);
569#endif
570
571 if (result < 0)
572 return -errno;
573
627
628 return 0;
629}
630
631/// Target lstat64() handler.
632template <class OS>
633SyscallReturn
634lstat64Func(SyscallDesc *desc, int callnum, Process *process,

--- 10 unchanged lines hidden (view full) ---

645#else
646 struct stat64 hostBuf;
647 int result = lstat64(path.c_str(), &hostBuf);
648#endif
649
650 if (result < 0)
651 return -errno;
652
574 OS::copyOutStat64Buf(tc->getMemPort(), -1, tc->getSyscallArg(1), &hostBuf);
653 copyOutStat64Buf<OS>(tc->getMemPort(), -1, tc->getSyscallArg(1), &hostBuf);
575
576 return 0;
577}
578
579/// Target fstat() handler.
580template <class OS>
581SyscallReturn
582fstatFunc(SyscallDesc *desc, int callnum, Process *process,

--- 7 unchanged lines hidden (view full) ---

590 return -EBADF;
591
592 struct stat hostBuf;
593 int result = fstat(fd, &hostBuf);
594
595 if (result < 0)
596 return -errno;
597
654
655 return 0;
656}
657
658/// Target fstat() handler.
659template <class OS>
660SyscallReturn
661fstatFunc(SyscallDesc *desc, int callnum, Process *process,

--- 7 unchanged lines hidden (view full) ---

669 return -EBADF;
670
671 struct stat hostBuf;
672 int result = fstat(fd, &hostBuf);
673
674 if (result < 0)
675 return -errno;
676
598 OS::copyOutStatBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
677 copyOutStatBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
599
600 return 0;
601}
602
603
604/// Target statfs() handler.
605template <class OS>
606SyscallReturn

--- 6 unchanged lines hidden (view full) ---

613 return -EFAULT;
614
615 struct statfs hostBuf;
616 int result = statfs(path.c_str(), &hostBuf);
617
618 if (result < 0)
619 return -errno;
620
678
679 return 0;
680}
681
682
683/// Target statfs() handler.
684template <class OS>
685SyscallReturn

--- 6 unchanged lines hidden (view full) ---

692 return -EFAULT;
693
694 struct statfs hostBuf;
695 int result = statfs(path.c_str(), &hostBuf);
696
697 if (result < 0)
698 return -errno;
699
621 OS::copyOutStatfsBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
700 copyOutStatfsBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
622
623 return 0;
624}
625
626
627/// Target fstatfs() handler.
628template <class OS>
629SyscallReturn

--- 6 unchanged lines hidden (view full) ---

636 return -EBADF;
637
638 struct statfs hostBuf;
639 int result = fstatfs(fd, &hostBuf);
640
641 if (result < 0)
642 return -errno;
643
701
702 return 0;
703}
704
705
706/// Target fstatfs() handler.
707template <class OS>
708SyscallReturn

--- 6 unchanged lines hidden (view full) ---

715 return -EBADF;
716
717 struct statfs hostBuf;
718 int result = fstatfs(fd, &hostBuf);
719
720 if (result < 0)
721 return -errno;
722
644 OS::copyOutStatfsBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
723 copyOutStatfsBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
645
646 return 0;
647}
648
649
650/// Target writev() handler.
651template <class OS>
652SyscallReturn

--- 208 unchanged lines hidden --- 		724
725 return 0;
726}
727
728
729/// Target writev() handler.
730template <class OS>
731SyscallReturn

--- 208 unchanged lines hidden ---