"I am a person who works hard and plays hard."

---

Yuan Wei
Second Year Graduate Student Department of Computer Science
University of Virginia Charlottesville, VA 22903
Email: yw3f@cs.virginia.edu

---

Source Code Analysis
         

---

syscall.h File Reference

#include <sys/types.h>
#include <sys/time.h>
#include "host.h"
#include "misc.h"
#include "machine.h"

Include dependency graph for syscall.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

• void sys_syscall (struct regs_t *regs, mem_access_fn mem_fn, struct mem_t *mem, md_inst_t inst, int traceable)

---

Function Documentation

void sys_syscall (  struct regs_t *    regs, mem_access_fn    mem_fn, struct mem_t *    mem, md_inst_t    inst, int    traceable )

Definition at line 975 of file target-alpha/syscall.c. References eio_read_trace(), fatal(), MAXBUFSIZE, MD_OUTPUT_SYSCALL, MD_SWAPH, MD_SWAPW, mem_access_fn, mem_bcopy(), mem_strcpy(), NUM_IOCTL_BYTES, panic(), Read, regs_t::regs_R, ROUND_UP, ss_sgttyb::sg_erase, ss_sgttyb::sg_flags, ss_sgttyb::sg_ispeed, ss_sgttyb::sg_kill, ss_sgttyb::sg_ospeed, ss_flag_table, SS_IOCTL_TCGETA, SS_IOCTL_TCGETP, SS_IOCTL_TCSETAW, SS_IOCTL_TIOCGETC, SS_IOCTL_TIOCGETP, SS_IOCTL_TIOCGLTC, SS_IOCTL_TIOCGWINSZ, SS_IOCTL_TIOCLBIC, SS_IOCTL_TIOCLBIS, SS_IOCTL_TIOCLGET, SS_IOCTL_TIOCLSET, SS_IOCTL_TIOCSETC, SS_IOCTL_TIOCSETP, SS_IOCTL_TIOCSLTC, SS_NFLAGS, ss_statbuf::ss_pad, ss_statbuf::ss_pad1, ss_rlimit::ss_rlim_cur, ss_rlimit::ss_rlim_max, ss_rusage::ss_ru_idrss, ss_rusage::ss_ru_inblock, ss_rusage::ss_ru_isrss, ss_rusage::ss_ru_ixrss, ss_rusage::ss_ru_majflt, ss_rusage::ss_ru_maxrss, ss_rusage::ss_ru_minflt, ss_rusage::ss_ru_msgrcv, ss_rusage::ss_ru_msgsnd, ss_rusage::ss_ru_nivcsw, ss_rusage::ss_ru_nsignals, ss_rusage::ss_ru_nswap, ss_rusage::ss_ru_nvcsw, ss_rusage::ss_ru_oublock, ss_rusage::ss_ru_stime, ss_rusage::ss_ru_utime, ss_statbuf::ss_st_atime, ss_statbuf::ss_st_blksize, ss_statbuf::ss_st_blocks, ss_statbuf::ss_st_ctime, ss_statbuf::ss_st_dev, ss_statbuf::ss_st_gennum, ss_statbuf::ss_st_gid, ss_statbuf::ss_st_ino, ss_statbuf::ss_st_mode, ss_statbuf::ss_st_mtime, ss_statbuf::ss_st_nlink, ss_statbuf::ss_st_rdev, ss_statbuf::ss_st_size, ss_statbuf::ss_st_spare1, ss_statbuf::ss_st_spare2, ss_statbuf::ss_st_spare3, ss_statbuf::ss_st_spare4, ss_statbuf::ss_st_uid, SS_SYS_access, SS_SYS_brk, SS_SYS_chdir, SS_SYS_chmod, SS_SYS_chown, SS_SYS_close, SS_SYS_creat, SS_SYS_dup, SS_SYS_dup2, SS_SYS_exit, SS_SYS_fcntl, SS_SYS_fork, SS_SYS_fstat, SS_SYS_getdirentries, SS_SYS_getdtablesize, SS_SYS_getgid, SS_SYS_getpagesize, SS_SYS_getpid, SS_SYS_getrlimit, SS_SYS_getrusage, SS_SYS_gettimeofday, SS_SYS_getuid, SS_SYS_ioctl, SS_SYS_lseek, SS_SYS_lstat, SS_SYS_open, SS_SYS_pipe, SS_SYS_read, SS_SYS_select, SS_SYS_setitimer, SS_SYS_setrlimit, SS_SYS_sigblock, SS_SYS_sigsetmask, SS_SYS_sigstack, SS_SYS_sigvec, SS_SYS_stat, SS_SYS_unlink, SS_SYS_utimes, SS_SYS_vfork, SS_SYS_write, SS_SYS_writev, ss_timeval::ss_tv_sec, ss_timeval::ss_tv_usec, ss_timezone::ss_tz_dsttime, ss_timezone::ss_tz_minuteswest, warn(), word_t, and Write. Referenced by eio_read_trace(), and eio_write_trace(). { qword_t syscode = regs->regs_R[MD_REG_V0]; /* fix for syscall() which uses CALL_PAL CALLSYS for making system calls */ if (syscode == OSF_SYS_syscall) syscode = regs->regs_R[MD_REG_A0]; /* first, check if an EIO trace is being consumed... */ if (traceable && sim_eio_fd != NULL) { eio_read_trace(sim_eio_fd, sim_num_insn, regs, mem_fn, mem, inst); /* kludge fix for sigreturn(), it modifies all registers */ if (syscode == OSF_SYS_sigreturn) { int i; struct osf_sigcontext sc; md_addr_t sc_addr = regs->regs_R[MD_REG_A0]; mem_bcopy(mem_fn, mem, Read, sc_addr, &sc, sizeof(struct osf_sigcontext)); regs->regs_NPC = sc.sc_pc; for (i=0; i < 32; ++i) regs->regs_R[i] = sc.sc_regs[i]; for (i=0; i < 32; ++i) regs->regs_F.q[i] = sc.sc_fpregs[i]; regs->regs_C.fpcr = sc.sc_fpcr; } /* fini... */ return; } /* no, OK execute the live system call... */ switch (syscode) { case OSF_SYS_exit: /* exit jumps to the target set in main() */ longjmp(sim_exit_buf, /* exitcode + fudge */(regs->regs_R[MD_REG_A0] & 0xff) + 1); break; case OSF_SYS_read: { char *buf; /* allocate same-sized input buffer in host memory */ if (!(buf = (char *)calloc(/*nbytes*/regs->regs_R[MD_REG_A2], sizeof(char)))) fatal("out of memory in SYS_read"); /* read data from file */ do { /*nread*/regs->regs_R[MD_REG_V0] = read(/*fd*/regs->regs_R[MD_REG_A0], buf, /*nbytes*/regs->regs_R[MD_REG_A2]); } while (/*nread*/regs->regs_R[MD_REG_V0] == -1 && errno == EAGAIN); /* check for error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* copy results back into host memory */ mem_bcopy(mem_fn, mem, Write, /*buf*/regs->regs_R[MD_REG_A1], buf, /*nread*/regs->regs_R[MD_REG_A2]); /* done with input buffer */ free(buf); } break; case OSF_SYS_write: { char *buf; /* allocate same-sized output buffer in host memory */ if (!(buf = (char *)calloc(/*nbytes*/regs->regs_R[MD_REG_A2], sizeof(char)))) fatal("out of memory in SYS_write"); /* copy inputs into host memory */ mem_bcopy(mem_fn, mem, Read, /*buf*/regs->regs_R[MD_REG_A1], buf, /*nbytes*/regs->regs_R[MD_REG_A2]); /* write data to file */ if (sim_progfd && MD_OUTPUT_SYSCALL(regs)) { /* redirect program output to file */ /*nwritten*/regs->regs_R[MD_REG_V0] = fwrite(buf, 1, /*nbytes*/regs->regs_R[MD_REG_A2], sim_progfd); } else { /* perform program output request */ do { /*nwritten*/regs->regs_R[MD_REG_V0] = write(/*fd*/regs->regs_R[MD_REG_A0], buf, /*nbytes*/regs->regs_R[MD_REG_A2]); } while (/*nwritten*/regs->regs_R[MD_REG_V0] == -1 && errno == EAGAIN); } /* check for an error condition */ if (regs->regs_R[MD_REG_V0] == regs->regs_R[MD_REG_A2]) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* done with output buffer */ free(buf); } break; #if !defined(MIN_SYSCALL_MODE) /* ADDED BY CALDER 10/27/99 */ case OSF_SYS_getdomainname: /* get program scheduling priority */ { char *buf; buf = malloc(/* len */(size_t)regs->regs_R[MD_REG_A1]); if (!buf) fatal("out of virtual memory in gethostname()"); /* result */regs->regs_R[MD_REG_V0] = getdomainname(/* name */buf, /* len */(size_t)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* copy string back to simulated memory */ mem_bcopy(mem_fn, mem, Write, /* name */regs->regs_R[MD_REG_A0], buf, /* len */regs->regs_R[MD_REG_A1]); } break; #endif #if !defined(MIN_SYSCALL_MODE) /* ADDED BY CALDER 10/27/99 */ case OSF_SYS_flock: /* get flock() information on the file */ { regs->regs_R[MD_REG_V0] = flock(/*fd*/(int)regs->regs_R[MD_REG_A0], /*cmd*/(int)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif #if !defined(MIN_SYSCALL_MODE) /* ADDED BY CALDER 10/27/99 */ case OSF_SYS_bind: { const struct sockaddr a_sock; mem_bcopy(mem_fn, mem, Read, /* serv_addr */regs->regs_R[MD_REG_A1], &a_sock, /* addrlen */(int)regs->regs_R[MD_REG_A2]); regs->regs_R[MD_REG_V0] = bind((int) regs->regs_R[MD_REG_A0], &a_sock,(int) regs->regs_R[MD_REG_A2]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif #if !defined(MIN_SYSCALL_MODE) /* ADDED BY CALDER 10/27/99 */ case OSF_SYS_sendto: { char *buf = NULL; struct sockaddr d_sock; int buf_len = 0; buf_len = regs->regs_R[MD_REG_A2]; if (buf_len > 0) buf = (char *) malloc(buf_len*sizeof(char)); mem_bcopy(mem_fn, mem, Read, /* serv_addr */regs->regs_R[MD_REG_A1], buf, /* addrlen */(int)regs->regs_R[MD_REG_A2]); if (regs->regs_R[MD_REG_A5] > 0) mem_bcopy(mem_fn, mem, Read, regs->regs_R[MD_REG_A4], &d_sock, (int)regs->regs_R[MD_REG_A5]); regs->regs_R[MD_REG_V0] = sendto((int) regs->regs_R[MD_REG_A0], buf,(int) regs->regs_R[MD_REG_A2], (int) regs->regs_R[MD_REG_A3], &d_sock,(int) regs->regs_R[MD_REG_A5]); mem_bcopy(mem_fn, mem, Write, /* serv_addr */regs->regs_R[MD_REG_A1], buf, /* addrlen */(int)regs->regs_R[MD_REG_A2]); /* maybe copy back whole size of sockaddr */ if (regs->regs_R[MD_REG_A5] > 0) mem_bcopy(mem_fn, mem, Write, regs->regs_R[MD_REG_A4], &d_sock, (int)regs->regs_R[MD_REG_A5]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } if (buf != NULL) free(buf); } break; #endif #if !defined(MIN_SYSCALL_MODE) /* ADDED BY CALDER 10/27/99 */ case OSF_SYS_old_recvfrom: case OSF_SYS_recvfrom: { int addr_len; char *buf; struct sockaddr *a_sock; buf = (char *) malloc(sizeof(char)*regs->regs_R[MD_REG_A2]); mem_bcopy(mem_fn, mem, Read, /* serv_addr */regs->regs_R[MD_REG_A1], buf, /* addrlen */(int)regs->regs_R[MD_REG_A2]); mem_bcopy(mem_fn, mem, Read, /* serv_addr */regs->regs_R[MD_REG_A5], &addr_len, sizeof(int)); a_sock = (struct sockaddr *)malloc(addr_len); mem_bcopy(mem_fn, mem, Read, regs->regs_R[MD_REG_A4], a_sock, addr_len); regs->regs_R[MD_REG_V0] = recvfrom((int) regs->regs_R[MD_REG_A0], buf,(int) regs->regs_R[MD_REG_A2], (int) regs->regs_R[MD_REG_A3], a_sock,&addr_len); mem_bcopy(mem_fn, mem, Write, regs->regs_R[MD_REG_A1], buf, (int) regs->regs_R[MD_REG_V0]); mem_bcopy(mem_fn, mem, Write, /* serv_addr */regs->regs_R[MD_REG_A5], &addr_len, sizeof(int)); mem_bcopy(mem_fn, mem, Write, regs->regs_R[MD_REG_A4], a_sock, addr_len); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } if (buf != NULL) free(buf); } break; #endif case OSF_SYS_open: { char buf[MAXBUFSIZE]; unsigned int i; int osf_flags = regs->regs_R[MD_REG_A1], local_flags = 0; /* translate open(2) flags */ for (i=0; i < OSF_NFLAGS; i++) { if (osf_flags & osf_flag_table[i].osf_flag) { osf_flags &= ~osf_flag_table[i].osf_flag; local_flags |= osf_flag_table[i].local_flag; } } /* any target flags left? */ if (osf_flags != 0) fatal("syscall: open: cannot decode flags: 0x%08x", osf_flags); /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[MD_REG_A0], buf); /* open the file */ #ifdef __CYGWIN32__ /*fd*/regs->regs_R[MD_REG_V0] = open(buf, local_flags|O_BINARY, /*mode*/regs->regs_R[MD_REG_A2]); #else /* !__CYGWIN32__ */ /*fd*/regs->regs_R[MD_REG_V0] = open(buf, local_flags, /*mode*/regs->regs_R[MD_REG_A2]); #endif /* __CYGWIN32__ */ /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; case OSF_SYS_close: /* don't close stdin, stdout, or stderr as this messes up sim logs */ if (/*fd*/regs->regs_R[MD_REG_A0] == 0 || /*fd*/regs->regs_R[MD_REG_A0] == 1 || /*fd*/regs->regs_R[MD_REG_A0] == 2) { regs->regs_R[MD_REG_A3] = 0; break; } /* close the file */ regs->regs_R[MD_REG_V0] = close(/*fd*/regs->regs_R[MD_REG_A0]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #if 0 case OSF_SYS_creat: { char buf[MAXBUFSIZE]; /* copy filename to host memory */ mem_strcpy(mem_fn, Read, /*fname*/regs->regs_R[MD_REG_A0], buf); /* create the file */ /*fd*/regs->regs_R[MD_REG_V0] = creat(buf, /*mode*/regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif case OSF_SYS_unlink: { char buf[MAXBUFSIZE]; /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[MD_REG_A0], buf); /* delete the file */ /*result*/regs->regs_R[MD_REG_V0] = unlink(buf); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; case OSF_SYS_chdir: { char buf[MAXBUFSIZE]; /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[MD_REG_A0], buf); /* change the working directory */ /*result*/regs->regs_R[MD_REG_V0] = chdir(buf); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; case OSF_SYS_chmod: { char buf[MAXBUFSIZE]; /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[MD_REG_A0], buf); /* chmod the file */ /*result*/regs->regs_R[MD_REG_V0] = chmod(buf, /*mode*/regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; case OSF_SYS_chown: #ifdef _MSC_VER warn("syscall chown() not yet implemented for MSC..."); regs->regs_R[MD_REG_A3] = 0; #else /* !_MSC_VER */ { char buf[MAXBUFSIZE]; /* copy filename to host memory */ mem_strcpy(mem_fn, mem,Read, /*fname*/regs->regs_R[MD_REG_A0], buf); /* chown the file */ /*result*/regs->regs_R[MD_REG_V0] = chown(buf, /*owner*/regs->regs_R[MD_REG_A1], /*group*/regs->regs_R[MD_REG_A2]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } #endif /* _MSC_VER */ break; case OSF_SYS_sbrk: { sqword_t delta; md_addr_t addr; delta = regs->regs_R[MD_REG_A0]; addr = ld_brk_point + delta; if (verbose) myfprintf(stderr, "SYS_sbrk: delta: 0x%012p (%ld)\n", delta, delta); ld_brk_point = addr; regs->regs_R[MD_REG_V0] = ld_brk_point; regs->regs_R[MD_REG_A3] = 0; if (verbose) myfprintf(stderr, "ld_brk_point: 0x%012p\n", ld_brk_point); #if 0 /* check whether heap area has merged with stack area */ if (/* addr >= ld_brk_point && */ addr < regs->regs_R[MD_REG_SP]) { regs->regs_R[MD_REG_A3] = 0; ld_brk_point = addr; } else { /* out of address space, indicate error */ regs->regs_R[MD_REG_A3] = -1; } #endif } break; case OSF_SYS_obreak: { md_addr_t addr; /* round the new heap pointer to the its page boundary */ #if 0 addr = ROUND_UP(/*base*/regs->regs_R[MD_REG_A0], MD_PAGE_SIZE); #endif addr = /*base*/regs->regs_R[MD_REG_A0]; if (verbose) myfprintf(stderr, "SYS_obreak: addr: 0x%012p\n", addr); ld_brk_point = addr; regs->regs_R[MD_REG_V0] = ld_brk_point; regs->regs_R[MD_REG_A3] = 0; if (verbose) myfprintf(stderr, "ld_brk_point: 0x%012p\n", ld_brk_point); } break; case OSF_SYS_lseek: /* seek into file */ regs->regs_R[MD_REG_V0] = lseek(/*fd*/regs->regs_R[MD_REG_A0], /*off*/regs->regs_R[MD_REG_A1], /*dir*/regs->regs_R[MD_REG_A2]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; case OSF_SYS_getpid: /* get the simulator process id */ /*result*/regs->regs_R[MD_REG_V0] = getpid(); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; case OSF_SYS_getuid: #ifdef _MSC_VER warn("syscall getuid() not yet implemented for MSC..."); regs->regs_R[MD_REG_A3] = 0; #else /* !_MSC_VER */ /* get current user id */ /*first result*/regs->regs_R[MD_REG_V0] = getuid(); /*second result*/regs->regs_R[MD_REG_A4] = geteuid(); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } #endif /* _MSC_VER */ break; case OSF_SYS_access: { char buf[MAXBUFSIZE]; /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fName*/regs->regs_R[MD_REG_A0], buf); /* check access on the file */ /*result*/regs->regs_R[MD_REG_V0] = access(buf, /*mode*/regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; case OSF_SYS_stat: case OSF_SYS_lstat: { char buf[MAXBUFSIZE]; struct osf_statbuf osf_sbuf; #ifdef _MSC_VER struct _stat sbuf; #else /* !_MSC_VER */ struct stat sbuf; #endif /* _MSC_VER */ /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fName*/regs->regs_R[MD_REG_A0], buf); /* stat() the file */ if (syscode == OSF_SYS_stat) /*result*/regs->regs_R[MD_REG_V0] = stat(buf, &sbuf); else /* syscode == OSF_SYS_lstat */ { #ifdef _MSC_VER warn("syscall lstat() not yet implemented for MSC..."); regs->regs_R[MD_REG_A3] = 0; break; #else /* !_MSC_VER */ /*result*/regs->regs_R[MD_REG_V0] = lstat(buf, &sbuf); #endif /* _MSC_VER */ } /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* translate from host stat structure to target format */ osf_sbuf.osf_st_dev = MD_SWAPW(sbuf.st_dev); osf_sbuf.osf_st_ino = MD_SWAPW(sbuf.st_ino); osf_sbuf.osf_st_mode = MD_SWAPW(sbuf.st_mode); osf_sbuf.osf_st_nlink = MD_SWAPH(sbuf.st_nlink); osf_sbuf.osf_st_uid = MD_SWAPW(sbuf.st_uid); osf_sbuf.osf_st_gid = MD_SWAPW(sbuf.st_gid); osf_sbuf.osf_st_rdev = MD_SWAPW(sbuf.st_rdev); osf_sbuf.osf_st_size = MD_SWAPQ(sbuf.st_size); osf_sbuf.osf_st_atime = MD_SWAPW(sbuf.st_atime); osf_sbuf.osf_st_mtime = MD_SWAPW(sbuf.st_mtime); osf_sbuf.osf_st_ctime = MD_SWAPW(sbuf.st_ctime); #ifndef _MSC_VER osf_sbuf.osf_st_blksize = MD_SWAPW(sbuf.st_blksize); osf_sbuf.osf_st_blocks = MD_SWAPW(sbuf.st_blocks); #endif /* !_MSC_VER */ /* copy stat() results to simulator memory */ mem_bcopy(mem_fn, mem, Write, /*sbuf*/regs->regs_R[MD_REG_A1], &osf_sbuf, sizeof(struct osf_statbuf)); } break; case OSF_SYS_dup: /* dup() the file descriptor */ /*fd*/regs->regs_R[MD_REG_V0] = dup(/*fd*/regs->regs_R[MD_REG_A0]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #if 0 case OSF_SYS_pipe: { int fd[2]; /* copy pipe descriptors to host memory */; mem_bcopy(mem_fn, mem, Read, /*fd's*/regs->regs_R[MD_REG_A0], fd, sizeof(fd)); /* create a pipe */ /*result*/regs->regs_R[7] = pipe(fd); /* copy descriptor results to result registers */ /*pipe1*/regs->regs_R[MD_REG_V0] = fd[0]; /*pipe 2*/regs->regs_R[3] = fd[1]; /* check for an error condition */ if (regs->regs_R[7] == (qword_t)-1) { regs->regs_R[MD_REG_V0] = errno; regs->regs_R[7] = 1; } } break; #endif case OSF_SYS_getgid: #ifdef _MSC_VER warn("syscall getgid() not yet implemented for MSC..."); regs->regs_R[MD_REG_A3] = 0; #else /* !_MSC_VER */ /* get current group id */ /*first result*/regs->regs_R[MD_REG_V0] = getgid(); /*second result*/regs->regs_R[MD_REG_A4] = getegid(); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } #endif /* _MSC_VER */ break; case OSF_SYS_ioctl: switch (/* req */regs->regs_R[MD_REG_A1]) { #if !defined(TIOCGETP) && defined(linux) case OSF_TIOCGETP: /* <Out,TIOCGETP,6> */ { struct termios lbuf; struct osf_sgttyb buf; /* result */regs->regs_R[MD_REG_V0] = tcgetattr(/* fd */(int)regs->regs_R[MD_REG_A0], &lbuf); /* translate results */ buf.sg_ispeed = lbuf.c_ispeed; buf.sg_ospeed = lbuf.c_ospeed; buf.sg_erase = lbuf.c_cc[VERASE]; buf.sg_kill = lbuf.c_cc[VKILL]; buf.sg_flags = 0; /* FIXME: this is wrong... */ mem_bcopy(mem_fn, mem, Write, /* buf */regs->regs_R[MD_REG_A2], &buf, sizeof(struct osf_sgttyb)); if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* probably not a typewriter, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif #ifdef TIOCGETP case OSF_TIOCGETP: /* <Out,TIOCGETP,6> */ { struct sgttyb lbuf; struct osf_sgttyb buf; /* result */regs->regs_R[MD_REG_V0] = ioctl(/* fd */(int)regs->regs_R[MD_REG_A0], /* req */TIOCGETP, &lbuf); /* translate results */ buf.sg_ispeed = lbuf.sg_ispeed; buf.sg_ospeed = lbuf.sg_ospeed; buf.sg_erase = lbuf.sg_erase; buf.sg_kill = lbuf.sg_kill; buf.sg_flags = lbuf.sg_flags; mem_bcopy(mem_fn, mem, Write, /* buf */regs->regs_R[MD_REG_A2], &buf, sizeof(struct osf_sgttyb)); if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* not a typewriter, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif #ifdef FIONREAD case OSF_FIONREAD: { int nread; /* result */regs->regs_R[MD_REG_V0] = ioctl(/* fd */(int)regs->regs_R[MD_REG_A0], /* req */FIONREAD, /* arg */&nread); mem_bcopy(mem_fn, mem, Write, /* arg */regs->regs_R[MD_REG_A2], &nread, sizeof(nread)); if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* not a typewriter, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif #ifdef FIONBIO case /*FIXME*/FIONBIO: { int arg = 0; if (regs->regs_R[MD_REG_A2]) mem_bcopy(mem_fn, mem, Read, /* arg */regs->regs_R[MD_REG_A2], &arg, sizeof(arg)); #ifdef NOTNOW fprintf(stderr, "FIONBIO: %d, %d\n", (int)regs->regs_R[MD_REG_A0], arg); #endif /* result */regs->regs_R[MD_REG_V0] = ioctl(/* fd */(int)regs->regs_R[MD_REG_A0], /* req */FIONBIO, /* arg */&arg); if (regs->regs_R[MD_REG_A2]) mem_bcopy(mem_fn, mem, Write, /* arg */regs->regs_R[MD_REG_A2], &arg, sizeof(arg)); if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* not a typewriter, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif default: warn("unsupported ioctl call: ioctl(%ld, ...)", regs->regs_R[MD_REG_A1]); regs->regs_R[MD_REG_A3] = 0; break; } break; #if 0 { char buf[NUM_IOCTL_BYTES]; int local_req = 0; /* convert target ioctl() request to host ioctl() request values */ switch (/*req*/regs->regs_R[MD_REG_A1]) { /* #if !defined(__CYGWIN32__) */ case SS_IOCTL_TIOCGETP: local_req = TIOCGETP; break; case SS_IOCTL_TIOCSETP: local_req = TIOCSETP; break; case SS_IOCTL_TCGETP: local_req = TIOCGETP; break; /* #endif */ #ifdef TCGETA case SS_IOCTL_TCGETA: local_req = TCGETA; break; #endif #ifdef TIOCGLTC case SS_IOCTL_TIOCGLTC: local_req = TIOCGLTC; break; #endif #ifdef TIOCSLTC case SS_IOCTL_TIOCSLTC: local_req = TIOCSLTC; break; #endif case SS_IOCTL_TIOCGWINSZ: local_req = TIOCGWINSZ; break; #ifdef TCSETAW case SS_IOCTL_TCSETAW: local_req = TCSETAW; break; #endif #ifdef TIOCGETC case SS_IOCTL_TIOCGETC: local_req = TIOCGETC; break; #endif #ifdef TIOCSETC case SS_IOCTL_TIOCSETC: local_req = TIOCSETC; break; #endif #ifdef TIOCLBIC case SS_IOCTL_TIOCLBIC: local_req = TIOCLBIC; break; #endif #ifdef TIOCLBIS case SS_IOCTL_TIOCLBIS: local_req = TIOCLBIS; break; #endif #ifdef TIOCLGET case SS_IOCTL_TIOCLGET: local_req = TIOCLGET; break; #endif #ifdef TIOCLSET case SS_IOCTL_TIOCLSET: local_req = TIOCLSET; break; #endif } if (!local_req) { /* FIXME: could not translate the ioctl() request, just warn user and ignore the request */ warn("syscall: ioctl: ioctl code not supported d=%d, req=%d", regs->regs_R[MD_REG_A0], regs->regs_R[MD_REG_A1]); regs->regs_R[MD_REG_V0] = 0; regs->regs_R[7] = 0; } else { /* ioctl() code was successfully translated to a host code */ /* if arg ptr exists, copy NUM_IOCTL_BYTES bytes to host mem */ if (/*argp*/regs->regs_R[MD_REG_A2] != 0) mem_bcopy(mem_fn, mem, Read, /*argp*/regs->regs_R[MD_REG_A2], buf, NUM_IOCTL_BYTES); /* perform the ioctl() call */ /*result*/regs->regs_R[MD_REG_V0] = ioctl(/*fd*/regs->regs_R[MD_REG_A0], local_req, buf); /* if arg ptr exists, copy NUM_IOCTL_BYTES bytes from host mem */ if (/*argp*/regs->regs_R[MD_REG_A2] != 0) mem_bcopy(mem_fn, mem, Write, regs->regs_R[MD_REG_A2], buf, NUM_IOCTL_BYTES); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[7] = 0; else { /* got an error, return details */ regs->regs_R[MD_REG_V0] = errno; regs->regs_R[7] = 1; } } } break; #endif case OSF_SYS_fstat: { struct osf_statbuf osf_sbuf; #ifdef _MSC_VER struct _stat sbuf; #else /* !_MSC_VER */ struct stat sbuf; #endif /* _MSC_VER */ /* fstat() the file */ /*result*/regs->regs_R[MD_REG_V0] = fstat(/*fd*/regs->regs_R[MD_REG_A0], &sbuf); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* translate the stat structure to host format */ osf_sbuf.osf_st_dev = MD_SWAPW(sbuf.st_dev); osf_sbuf.osf_st_ino = MD_SWAPW(sbuf.st_ino); osf_sbuf.osf_st_mode = MD_SWAPW(sbuf.st_mode); osf_sbuf.osf_st_nlink = MD_SWAPH(sbuf.st_nlink); osf_sbuf.osf_st_uid = MD_SWAPW(sbuf.st_uid); osf_sbuf.osf_st_gid = MD_SWAPW(sbuf.st_gid); osf_sbuf.osf_st_rdev = MD_SWAPW(sbuf.st_rdev); osf_sbuf.osf_st_size = MD_SWAPQ(sbuf.st_size); osf_sbuf.osf_st_atime = MD_SWAPW(sbuf.st_atime); osf_sbuf.osf_st_mtime = MD_SWAPW(sbuf.st_mtime); osf_sbuf.osf_st_ctime = MD_SWAPW(sbuf.st_ctime); #ifndef _MSC_VER osf_sbuf.osf_st_blksize = MD_SWAPW(sbuf.st_blksize); osf_sbuf.osf_st_blocks = MD_SWAPW(sbuf.st_blocks); #endif /* !_MSC_VER */ /* copy fstat() results to simulator memory */ mem_bcopy(mem_fn, mem, Write, /*sbuf*/regs->regs_R[MD_REG_A1], &osf_sbuf, sizeof(struct osf_statbuf)); } break; case OSF_SYS_getpagesize: /* get target pagesize */ regs->regs_R[MD_REG_V0] = /* was: getpagesize() */MD_PAGE_SIZE; /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; case OSF_SYS_setitimer: /* FIXME: the sigvec system call is ignored */ warn("syscall: setitimer ignored"); regs->regs_R[MD_REG_A3] = 0; break; case OSF_SYS_table: { qword_t table_id, table_index, buf_addr, num_elem, size_elem; struct osf_tbl_sysinfo sysinfo; table_id = regs->regs_R[MD_REG_A1]; table_index = regs->regs_R[MD_REG_A2]; buf_addr = regs->regs_R[MD_REG_A3]; num_elem = regs->regs_R[MD_REG_A4]; size_elem = regs->regs_R[MD_REG_A5]; switch(table_id) { case OSF_TBL_SYSINFO: if (table_index != 0) { panic("table: table id TBL_SYSINFO requires 0 index, got %08d", table_index ); } else if (num_elem != 1) { panic("table: table id TBL_SYSINFO requires 1 elts, got %08d", num_elem ); } else { struct rusage rusage_info; /* use getrusage() to determine user & system time */ if (getrusage(RUSAGE_SELF, &rusage_info) < 0) { /* abort the system call */ regs->regs_R[MD_REG_A3] = -1; /* not kosher to pass off errno of getrusage() as errno of table(), but what the heck... */ regs->regs_R[MD_REG_V0] = errno; break; } /* use sysconf() to determine clock tick frequency */ sysinfo.si_hz = sysconf(_SC_CLK_TCK); /* convert user and system time into clock ticks */ sysinfo.si_user = rusage_info.ru_utime.tv_sec * sysinfo.si_hz + (rusage_info.ru_utime.tv_usec * sysinfo.si_hz) / 1000000UL; sysinfo.si_sys = rusage_info.ru_stime.tv_sec * sysinfo.si_hz + (rusage_info.ru_stime.tv_usec * sysinfo.si_hz) / 1000000UL; /* following can't be determined in a portable manner and are ignored */ sysinfo.si_nice = 0; sysinfo.si_idle = 0; sysinfo.si_phz = 0; sysinfo.si_boottime = 0; sysinfo.wait = 0; /* copy structure into simulator memory */ mem_bcopy(mem_fn, mem, Write, buf_addr, &sysinfo, sizeof(struct osf_tbl_sysinfo)); /* return success */ regs->regs_R[MD_REG_A3] = 0; } break; default: warn("table: unsupported table id %d requested, ignored", table_id); regs->regs_R[MD_REG_A3] = 0; } } break; case OSF_SYS_getdtablesize: #if defined(_AIX) || defined(__alpha) /* get descriptor table size */ regs->regs_R[MD_REG_V0] = getdtablesize(); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } #elif defined(ultrix) { /* no comparable system call found, try some reasonable defaults */ warn("syscall: called getdtablesize\n"); regs->regs_R[MD_REG_V0] = 16; regs->regs_R[MD_REG_A3] = 0; } #elif defined(MIN_SYSCALL_MODE) { /* no comparable system call found, try some reasonable defaults */ warn("syscall: called getdtablesize\n"); regs->regs_R[MD_REG_V0] = 16; regs->regs_R[MD_REG_A3] = 0; } #else { struct rlimit rl; /* get descriptor table size in rlimit structure */ if (getrlimit(RLIMIT_NOFILE, &rl) != (qword_t)-1) { regs->regs_R[MD_REG_V0] = rl.rlim_cur; regs->regs_R[MD_REG_A3] = 0; } else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } #endif break; case OSF_SYS_dup2: /* dup2() the file descriptor */ regs->regs_R[MD_REG_V0] = dup2(/*fd1*/regs->regs_R[MD_REG_A0], /*fd2*/regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; case OSF_SYS_fcntl: #ifdef _MSC_VER warn("syscall fcntl() not yet implemented for MSC..."); regs->regs_R[MD_REG_A3] = 0; #else /* !_MSC_VER */ /* get fcntl() information on the file */ regs->regs_R[MD_REG_V0] = fcntl(/*fd*/regs->regs_R[MD_REG_A0], /*cmd*/regs->regs_R[MD_REG_A1], /*arg*/regs->regs_R[MD_REG_A2]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } #endif /* _MSC_VER */ break; #if 0 case OSF_SYS_sigvec: /* FIXME: the sigvec system call is ignored */ warn("syscall: sigvec ignored"); regs->regs_R[MD_REG_A3] = 0; break; #endif #if 0 case OSF_SYS_sigblock: /* FIXME: the sigblock system call is ignored */ warn("syscall: sigblock ignored"); regs->regs_R[MD_REG_A3] = 0; break; #endif #if 0 case OSF_SYS_sigsetmask: /* FIXME: the sigsetmask system call is ignored */ warn("syscall: sigsetmask ignored"); regs->regs_R[MD_REG_A3] = 0; break; #endif case OSF_SYS_gettimeofday: #ifdef _MSC_VER warn("syscall gettimeofday() not yet implemented for MSC..."); regs->regs_R[MD_REG_A3] = 0; #else /* _MSC_VER */ { struct osf_timeval osf_tv; struct timeval tv, *tvp; struct osf_timezone osf_tz; struct timezone tz, *tzp; if (/*timeval*/regs->regs_R[MD_REG_A0] != 0) { /* copy timeval into host memory */ mem_bcopy(mem_fn, mem, Read, /*timeval*/regs->regs_R[MD_REG_A0], &osf_tv, sizeof(struct osf_timeval)); /* convert target timeval structure to host format */ tv.tv_sec = MD_SWAPW(osf_tv.osf_tv_sec); tv.tv_usec = MD_SWAPW(osf_tv.osf_tv_usec); tvp = &tv; } else tvp = NULL; if (/*timezone*/regs->regs_R[MD_REG_A1] != 0) { /* copy timezone into host memory */ mem_bcopy(mem_fn, mem, Read, /*timezone*/regs->regs_R[MD_REG_A1], &osf_tz, sizeof(struct osf_timezone)); /* convert target timezone structure to host format */ tz.tz_minuteswest = MD_SWAPW(osf_tz.osf_tz_minuteswest); tz.tz_dsttime = MD_SWAPW(osf_tz.osf_tz_dsttime); tzp = &tz; } else tzp = NULL; /* get time of day */ /*result*/regs->regs_R[MD_REG_V0] = gettimeofday(tvp, tzp); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } if (/*timeval*/regs->regs_R[MD_REG_A0] != 0) { /* convert host timeval structure to target format */ osf_tv.osf_tv_sec = MD_SWAPW(tv.tv_sec); osf_tv.osf_tv_usec = MD_SWAPW(tv.tv_usec); /* copy timeval to target memory */ mem_bcopy(mem_fn, mem, Write, /*timeval*/regs->regs_R[MD_REG_A0], &osf_tv, sizeof(struct osf_timeval)); } if (/*timezone*/regs->regs_R[MD_REG_A1] != 0) { /* convert host timezone structure to target format */ osf_tz.osf_tz_minuteswest = MD_SWAPW(tz.tz_minuteswest); osf_tz.osf_tz_dsttime = MD_SWAPW(tz.tz_dsttime); /* copy timezone to target memory */ mem_bcopy(mem_fn, mem, Write, /*timezone*/regs->regs_R[MD_REG_A1], &osf_tz, sizeof(struct osf_timezone)); } } #endif /* !_MSC_VER */ break; case OSF_SYS_getrusage: #if defined(__svr4__) || defined(__USLC__) || defined(hpux) || defined(__hpux) || defined(_AIX) { struct tms tms_buf; struct osf_rusage rusage; /* get user and system times */ if (times(&tms_buf) != (qword_t)-1) { /* no error */ regs->regs_R[MD_REG_V0] = 0; regs->regs_R[MD_REG_A3] = 0; } else /* got an error, indicate result */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* initialize target rusage result structure */ #if defined(__svr4__) memset(&rusage, '\0', sizeof(struct osf_rusage)); #else /* !defined(__svr4__) */ bzero(&rusage, sizeof(struct osf_rusage)); #endif /* convert from host rusage structure to target format */ rusage.osf_ru_utime.osf_tv_sec = MD_SWAPW(tms_buf.tms_utime/CLK_TCK); rusage.osf_ru_utime.osf_tv_sec = MD_SWAPW(rusage.osf_ru_utime.osf_tv_sec); rusage.osf_ru_utime.osf_tv_usec = 0; rusage.osf_ru_stime.osf_tv_sec = MD_SWAPW(tms_buf.tms_stime/CLK_TCK); rusage.osf_ru_stime.osf_tv_sec = MD_SWAPW(rusage.osf_ru_stime.osf_tv_sec); rusage.osf_ru_stime.osf_tv_usec = 0; /* copy rusage results into target memory */ mem_bcopy(mem_fn, mem, Write, /*rusage*/regs->regs_R[MD_REG_A1], &rusage, sizeof(struct osf_rusage)); } #elif defined(__unix__) { struct rusage local_rusage; struct osf_rusage rusage; /* get rusage information */ /*result*/regs->regs_R[MD_REG_V0] = getrusage(/*who*/regs->regs_R[MD_REG_A0], &local_rusage); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* convert from host rusage structure to target format */ rusage.osf_ru_utime.osf_tv_sec = MD_SWAPW(local_rusage.ru_utime.tv_sec); rusage.osf_ru_utime.osf_tv_usec = MD_SWAPW(local_rusage.ru_utime.tv_usec); rusage.osf_ru_utime.osf_tv_sec = MD_SWAPW(local_rusage.ru_utime.tv_sec); rusage.osf_ru_utime.osf_tv_usec = MD_SWAPW(local_rusage.ru_utime.tv_usec); rusage.osf_ru_stime.osf_tv_sec = MD_SWAPW(local_rusage.ru_stime.tv_sec); rusage.osf_ru_stime.osf_tv_usec = MD_SWAPW(local_rusage.ru_stime.tv_usec); rusage.osf_ru_stime.osf_tv_sec = MD_SWAPW(local_rusage.ru_stime.tv_sec); rusage.osf_ru_stime.osf_tv_usec = MD_SWAPW(local_rusage.ru_stime.tv_usec); rusage.osf_ru_maxrss = MD_SWAPW(local_rusage.ru_maxrss); rusage.osf_ru_ixrss = MD_SWAPW(local_rusage.ru_ixrss); rusage.osf_ru_idrss = MD_SWAPW(local_rusage.ru_idrss); rusage.osf_ru_isrss = MD_SWAPW(local_rusage.ru_isrss); rusage.osf_ru_minflt = MD_SWAPW(local_rusage.ru_minflt); rusage.osf_ru_majflt = MD_SWAPW(local_rusage.ru_majflt); rusage.osf_ru_nswap = MD_SWAPW(local_rusage.ru_nswap); rusage.osf_ru_inblock = MD_SWAPW(local_rusage.ru_inblock); rusage.osf_ru_oublock = MD_SWAPW(local_rusage.ru_oublock); rusage.osf_ru_msgsnd = MD_SWAPW(local_rusage.ru_msgsnd); rusage.osf_ru_msgrcv = MD_SWAPW(local_rusage.ru_msgrcv); rusage.osf_ru_nsignals = MD_SWAPW(local_rusage.ru_nsignals); rusage.osf_ru_nvcsw = MD_SWAPW(local_rusage.ru_nvcsw); rusage.osf_ru_nivcsw = MD_SWAPW(local_rusage.ru_nivcsw); /* copy rusage results into target memory */ mem_bcopy(mem_fn, mem, Write, /*rusage*/regs->regs_R[MD_REG_A1], &rusage, sizeof(struct osf_rusage)); } #elif defined(__CYGWIN32__) || defined(_MSC_VER) warn("syscall: called getrusage\n"); regs->regs_R[7] = 0; #else #error No getrusage() implementation! #endif break; case OSF_SYS_utimes: { char buf[MAXBUFSIZE]; /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[MD_REG_A0], buf); if (/*timeval*/regs->regs_R[MD_REG_A1] == 0) { #if defined(hpux) || defined(__hpux) || defined(__i386__) /* no utimes() in hpux, use utime() instead */ /*result*/regs->regs_R[MD_REG_V0] = utime(buf, NULL); #elif defined(_MSC_VER) /* no utimes() in MSC, use utime() instead */ /*result*/regs->regs_R[MD_REG_V0] = utime(buf, NULL); #elif defined(__svr4__) || defined(__USLC__) || defined(unix) || defined(_AIX) || defined(__alpha) /*result*/regs->regs_R[MD_REG_V0] = utimes(buf, NULL); #elif defined(__CYGWIN32__) warn("syscall: called utimes\n"); #else #error No utimes() implementation! #endif } else { struct osf_timeval osf_tval[2]; #ifndef _MSC_VER struct timeval tval[2]; #endif /* !_MSC_VER */ /* copy timeval structure to host memory */ mem_bcopy(mem_fn, mem, Read, /*timeout*/regs->regs_R[MD_REG_A1], osf_tval, 2*sizeof(struct osf_timeval)); #ifndef _MSC_VER /* convert timeval structure to host format */ tval[0].tv_sec = MD_SWAPW(osf_tval[0].osf_tv_sec); tval[0].tv_usec = MD_SWAPW(osf_tval[0].osf_tv_usec); tval[1].tv_sec = MD_SWAPW(osf_tval[1].osf_tv_sec); tval[1].tv_usec = MD_SWAPW(osf_tval[1].osf_tv_usec); #endif /* !_MSC_VER */ #if defined(hpux) || defined(__hpux) || defined(__svr4__) /* no utimes() in hpux, use utime() instead */ { struct utimbuf ubuf; ubuf.actime = MD_SWAPW(tval[0].tv_sec); ubuf.modtime = MD_SWAPW(tval[1].tv_sec); /* result */regs->regs_R[MD_REG_V0] = utime(buf, &ubuf); } #elif defined(_MSC_VER) /* no utimes() in hpux, use utime() instead */ { struct _utimbuf ubuf; ubuf.actime = MD_SWAPW(osf_tval[0].osf_tv_sec); ubuf.modtime = MD_SWAPW(osf_tval[1].osf_tv_sec); /* result */regs->regs_R[MD_REG_V0] = utime(buf, &ubuf); } #elif defined(__USLC__) || defined(unix) || defined(_AIX) || defined(__alpha) /* result */regs->regs_R[MD_REG_V0] = utimes(buf, tval); #elif defined(__CYGWIN32__) warn("syscall: called utimes\n"); #else #error No utimes() implementation! #endif } /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; case OSF_SYS_getrlimit: case OSF_SYS_setrlimit: #ifdef _MSC_VER warn("syscall get/setrlimit() not yet implemented for MSC..."); regs->regs_R[MD_REG_A3] = 0; #elif defined(__CYGWIN32__) { warn("syscall: called get/setrlimit\n"); regs->regs_R[MD_REG_A3] = 0; } #else { struct osf_rlimit osf_rl; struct rlimit rl; /* copy rlimit structure to host memory */ mem_bcopy(mem_fn, mem, Read, /*rlimit*/regs->regs_R[MD_REG_A1], &osf_rl, sizeof(struct osf_rlimit)); /* convert rlimit structure to host format */ rl.rlim_cur = MD_SWAPQ(osf_rl.osf_rlim_cur); rl.rlim_max = MD_SWAPQ(osf_rl.osf_rlim_max); /* get rlimit information */ if (syscode == OSF_SYS_getrlimit) /*result*/regs->regs_R[MD_REG_V0] = getrlimit(regs->regs_R[MD_REG_A0], &rl); else /* syscode == OSF_SYS_setrlimit */ /*result*/regs->regs_R[MD_REG_V0] = setrlimit(regs->regs_R[MD_REG_A0], &rl); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* convert rlimit structure to target format */ osf_rl.osf_rlim_cur = MD_SWAPQ(rl.rlim_cur); osf_rl.osf_rlim_max = MD_SWAPQ(rl.rlim_max); /* copy rlimit structure to target memory */ mem_bcopy(mem_fn, mem, Write, /*rlimit*/regs->regs_R[MD_REG_A1], &osf_rl, sizeof(struct osf_rlimit)); } #endif break; case OSF_SYS_sigprocmask: { static int first = TRUE; if (first) { warn("partially supported sigprocmask() call..."); first = FALSE; } /* from klauser@cs.colorado.edu: there are a couple bugs in the sigprocmask implementation; here is a fix: the problem comes from an impedance mismatch between application/libc interface and libc/syscall interface, the former of which you read about in the manpage, the latter of which you actually intercept here. The following is mostly correct, but does not capture some minor details, which you only get right if you really let the kernel handle it. (e.g. you can't really ever block sigkill etc.) */ regs->regs_R[MD_REG_V0] = sigmask; regs->regs_R[MD_REG_A3] = 0; switch (regs->regs_R[MD_REG_A0]) { case OSF_SIG_BLOCK: sigmask |= regs->regs_R[MD_REG_A1]; break; case OSF_SIG_UNBLOCK: sigmask &= ~regs->regs_R[MD_REG_A1]; break; case OSF_SIG_SETMASK: sigmask = regs->regs_R[MD_REG_A1]; break; default: regs->regs_R[MD_REG_V0] = EINVAL; regs->regs_R[MD_REG_A3] = 1; } #if 0 /* FIXME: obsolete... */ if (regs->regs_R[MD_REG_A2] > /* FIXME: why? */0x10000000) mem_bcopy(mem_fn, mem, Write, regs->regs_R[MD_REG_A2], &sigmask, sizeof(sigmask)); if (regs->regs_R[MD_REG_A1] != 0) { switch (regs->regs_R[MD_REG_A0]) { case OSF_SIG_BLOCK: sigmask |= regs->regs_R[MD_REG_A1]; break; case OSF_SIG_UNBLOCK: sigmask &= regs->regs_R[MD_REG_A1]; /* I think */ break; case OSF_SIG_SETMASK: sigmask = regs->regs_R[MD_REG_A1]; /* I think */ break; default: panic("illegal how value to sigprocmask()"); } } regs->regs_R[MD_REG_V0] = 0; regs->regs_R[MD_REG_A3] = 0; #endif } break; case OSF_SYS_sigaction: { int signum; static int first = TRUE; if (first) { warn("partially supported sigaction() call..."); first = FALSE; } signum = regs->regs_R[MD_REG_A0]; if (regs->regs_R[MD_REG_A1] != 0) sigaction_array[signum] = regs->regs_R[MD_REG_A1]; if (regs->regs_R[MD_REG_A2]) regs->regs_R[MD_REG_A2] = sigaction_array[signum]; regs->regs_R[MD_REG_V0] = 0; /* for some reason, __sigaction expects A3 to have a 0 return value */ regs->regs_R[MD_REG_A3] = 0; /* FIXME: still need to add code so that on a signal, the correct action is actually taken. */ /* FIXME: still need to add support for returning the correct error messages (EFAULT, EINVAL) */ } break; case OSF_SYS_sigstack: warn("unsupported sigstack() call..."); regs->regs_R[MD_REG_A3] = 0; break; case OSF_SYS_sigreturn: { int i; struct osf_sigcontext sc; static int first = TRUE; if (first) { warn("partially supported sigreturn() call..."); first = FALSE; } mem_bcopy(mem_fn, mem, Read, /* sc */regs->regs_R[MD_REG_A0], &sc, sizeof(struct osf_sigcontext)); sigmask = MD_SWAPQ(sc.sc_mask); /* was: prog_sigmask */ regs->regs_NPC = MD_SWAPQ(sc.sc_pc); /* FIXME: should check for the branch delay bit */ /* FIXME: current->nextpc = current->pc + 4; not sure about this... */ for (i=0; i < 32; ++i) regs->regs_R[i] = sc.sc_regs[i]; for (i=0; i < 32; ++i) regs->regs_F.q[i] = sc.sc_fpregs[i]; regs->regs_C.fpcr = sc.sc_fpcr; } break; case OSF_SYS_uswitch: warn("unsupported uswitch() call..."); regs->regs_R[MD_REG_V0] = regs->regs_R[MD_REG_A1]; break; case OSF_SYS_setsysinfo: warn("unsupported setsysinfo() call..."); regs->regs_R[MD_REG_V0] = 0; break; #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_getdirentries: { int i, cnt, osf_cnt; struct dirent *p; sword_t fd = regs->regs_R[MD_REG_A0]; md_addr_t osf_buf = regs->regs_R[MD_REG_A1]; char *buf; sword_t osf_nbytes = regs->regs_R[MD_REG_A2]; md_addr_t osf_pbase = regs->regs_R[MD_REG_A3]; sqword_t osf_base; long base = 0; /* number of entries in simulated memory */ if (!osf_nbytes) warn("attempting to get 0 directory entries..."); /* allocate local memory, whatever fits */ buf = calloc(1, osf_nbytes); if (!buf) fatal("out of virtual memory"); /* get directory entries */ #if defined(__svr4__) base = lseek ((int)fd, (off_t)0, SEEK_CUR); regs->regs_R[MD_REG_V0] = getdents((int)fd, (struct dirent *)buf, (size_t)osf_nbytes); #else /* !__svr4__ */ regs->regs_R[MD_REG_V0] = getdirentries((int)fd, buf, (size_t)osf_nbytes, &base); #endif /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) { regs->regs_R[MD_REG_A3] = 0; /* anything to copy back? */ if (regs->regs_R[MD_REG_V0] > 0) { /* copy all possible results to simulated space */ for (i=0, cnt=0, osf_cnt=0, p=(struct dirent *)buf; cnt < regs->regs_R[MD_REG_V0] && p->d_reclen > 0; i++, cnt += p->d_reclen, p=(struct dirent *)(buf+cnt)) { struct osf_dirent osf_dirent; osf_dirent.d_ino = MD_SWAPW(p->d_ino); osf_dirent.d_namlen = MD_SWAPH(strlen(p->d_name)); strcpy(osf_dirent.d_name, p->d_name); osf_dirent.d_reclen = MD_SWAPH(OSF_DIRENT_SZ(p->d_name)); mem_bcopy(mem_fn, mem, Write, osf_buf + osf_cnt, &osf_dirent, OSF_DIRENT_SZ(p->d_name)); osf_cnt += OSF_DIRENT_SZ(p->d_name); } if (osf_pbase != 0) { osf_base = (sqword_t)base; mem_bcopy(mem_fn, mem, Write, osf_pbase, &osf_base, sizeof(osf_base)); } /* update V0 to indicate translated read length */ regs->regs_R[MD_REG_V0] = osf_cnt; } } else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } free(buf); } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_truncate: { char buf[MAXBUFSIZE]; /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[MD_REG_A0], buf); /* truncate the file */ /*result*/regs->regs_R[MD_REG_V0] = truncate(buf, /* length */(size_t)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif #if !defined(__CYGWIN32__) && !defined(_MSC_VER) case OSF_SYS_ftruncate: /* truncate the file */ /*result*/regs->regs_R[MD_REG_V0] = ftruncate(/* fd */(int)regs->regs_R[MD_REG_A0], /* length */(size_t)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_statfs: { char buf[MAXBUFSIZE]; struct osf_statfs osf_sbuf; struct statfs sbuf; /* copy filename to host memory */ mem_strcpy(mem_fn, mem, Read, /*fName*/regs->regs_R[MD_REG_A0], buf); /* statfs() the fs */ /*result*/regs->regs_R[MD_REG_V0] = statfs(buf, &sbuf); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* translate from host stat structure to target format */ #if defined(__svr4__) || defined(__osf__) osf_sbuf.f_type = MD_SWAPH(0x6969) /* NFS, whatever... */; #else /* !__svr4__ */ osf_sbuf.f_type = MD_SWAPH(sbuf.f_type); #endif osf_sbuf.f_fsize = MD_SWAPW(sbuf.f_bsize); osf_sbuf.f_blocks = MD_SWAPW(sbuf.f_blocks); osf_sbuf.f_bfree = MD_SWAPW(sbuf.f_bfree); osf_sbuf.f_bavail = MD_SWAPW(sbuf.f_bavail); osf_sbuf.f_files = MD_SWAPW(sbuf.f_files); osf_sbuf.f_ffree = MD_SWAPW(sbuf.f_ffree); /* osf_sbuf.f_fsid = MD_SWAPW(sbuf.f_fsid); */ /* copy stat() results to simulator memory */ mem_bcopy(mem_fn, mem, Write, /*sbuf*/regs->regs_R[MD_REG_A1], &osf_sbuf, sizeof(struct osf_statbuf)); } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_setregid: /* set real and effective group ID */ /*result*/regs->regs_R[MD_REG_V0] = setregid(/* rgid */(gid_t)regs->regs_R[MD_REG_A0], /* egid */(gid_t)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_setreuid: /* set real and effective user ID */ /*result*/regs->regs_R[MD_REG_V0] = setreuid(/* ruid */(uid_t)regs->regs_R[MD_REG_A0], /* euid */(uid_t)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_socket: /* create an endpoint for communication */ /* result */regs->regs_R[MD_REG_V0] = socket(/* domain */xlate_arg((int)regs->regs_R[MD_REG_A0], family_map, N_ELT(family_map), "socket(family)"), /* type */xlate_arg((int)regs->regs_R[MD_REG_A1], socktype_map, N_ELT(socktype_map), "socket(type)"), /* protocol */xlate_arg((int)regs->regs_R[MD_REG_A2], family_map, N_ELT(family_map), "socket(proto)")); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_connect: { struct osf_sockaddr osf_sa; /* initiate a connection on a socket */ /* get the socket address */ if (regs->regs_R[MD_REG_A2] > sizeof(struct osf_sockaddr)) { fatal("sockaddr size overflow: addrlen = %d", regs->regs_R[MD_REG_A2]); } /* copy sockaddr structure to host memory */ mem_bcopy(mem_fn, mem, Read, /* serv_addr */regs->regs_R[MD_REG_A1], &osf_sa, /* addrlen */(int)regs->regs_R[MD_REG_A2]); #if 0 int i; sa.sa_family = osf_sa.sa_family; for (i=0; i < regs->regs_R[MD_REG_A2]; i++) sa.sa_data[i] = osf_sa.sa_data[i]; #endif /* result */regs->regs_R[MD_REG_V0] = connect(/* sockfd */(int)regs->regs_R[MD_REG_A0], (void *)&osf_sa, /* addrlen */(int)regs->regs_R[MD_REG_A2]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_uname: /* get name and information about current kernel */ regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = EPERM; break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_writev: { int i; char *buf; struct iovec *iov; /* allocate host side I/O vectors */ iov = (struct iovec *)malloc(/* iovcnt */regs->regs_R[MD_REG_A2] * sizeof(struct iovec)); if (!iov) fatal("out of virtual memory in SYS_writev"); /* copy target side I/O vector buffers to host memory */ for (i=0; i < /* iovcnt */regs->regs_R[MD_REG_A2]; i++) { struct osf_iovec osf_iov; /* copy target side pointer data into host side vector */ mem_bcopy(mem_fn, mem, Read, (/*iov*/regs->regs_R[MD_REG_A1] + i*sizeof(struct osf_iovec)), &osf_iov, sizeof(struct osf_iovec)); iov[i].iov_len = MD_SWAPW(osf_iov.iov_len); if (osf_iov.iov_base != 0 && osf_iov.iov_len != 0) { buf = (char *)calloc(MD_SWAPW(osf_iov.iov_len), sizeof(char)); if (!buf) fatal("out of virtual memory in SYS_writev"); mem_bcopy(mem_fn, mem, Read, MD_SWAPQ(osf_iov.iov_base), buf, MD_SWAPW(osf_iov.iov_len)); iov[i].iov_base = buf; } else iov[i].iov_base = NULL; } /* perform the vector'ed write */ do { /*result*/regs->regs_R[MD_REG_V0] = writev(/* fd */(int)regs->regs_R[MD_REG_A0], iov, /* iovcnt */(size_t)regs->regs_R[MD_REG_A2]); } while (/*result*/regs->regs_R[MD_REG_V0] == -1 && errno == EAGAIN); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* free all the allocated memory */ for (i=0; i < /* iovcnt */regs->regs_R[MD_REG_A2]; i++) { if (iov[i].iov_base) { free(iov[i].iov_base); iov[i].iov_base = NULL; } } free(iov); } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_readv: { int i; char *buf = NULL; struct osf_iovec *osf_iov; struct iovec *iov; /* allocate host side I/O vectors */ osf_iov = calloc(/* iovcnt */regs->regs_R[MD_REG_A2], sizeof(struct osf_iovec)); if (!osf_iov) fatal("out of virtual memory in SYS_readv"); iov = calloc(/* iovcnt */regs->regs_R[MD_REG_A2], sizeof(struct iovec)); if (!iov) fatal("out of virtual memory in SYS_readv"); /* copy host side I/O vector buffers */ for (i=0; i < /* iovcnt */regs->regs_R[MD_REG_A2]; i++) { /* copy target side pointer data into host side vector */ mem_bcopy(mem_fn, mem, Read, (/*iov*/regs->regs_R[MD_REG_A1] + i*sizeof(struct osf_iovec)), &osf_iov[i], sizeof(struct osf_iovec)); iov[i].iov_len = MD_SWAPW(osf_iov[i].iov_len); if (osf_iov[i].iov_base != 0 && osf_iov[i].iov_len != 0) { buf = (char *)calloc(MD_SWAPW(osf_iov[i].iov_len), sizeof(char)); if (!buf) fatal("out of virtual memory in SYS_readv"); iov[i].iov_base = buf; } else iov[i].iov_base = NULL; } /* perform the vector'ed read */ do { /*result*/regs->regs_R[MD_REG_V0] = readv(/* fd */(int)regs->regs_R[MD_REG_A0], iov, /* iovcnt */(size_t)regs->regs_R[MD_REG_A2]); } while (/*result*/regs->regs_R[MD_REG_V0] == -1 && errno == EAGAIN); /* copy target side I/O vector buffers to host memory */ for (i=0; i < /* iovcnt */regs->regs_R[MD_REG_A2]; i++) { if (osf_iov[i].iov_base != 0) { mem_bcopy(mem_fn, mem, Write, MD_SWAPQ(osf_iov[i].iov_base), iov[i].iov_base, MD_SWAPW(osf_iov[i].iov_len)); } } /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* free all the allocated memory */ for (i=0; i < /* iovcnt */regs->regs_R[MD_REG_A2]; i++) { if (iov[i].iov_base) { free(iov[i].iov_base); iov[i].iov_base = NULL; } } if (osf_iov) free(osf_iov); if (iov) free(iov); } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_setsockopt: { char *buf; struct xlate_table_t *map; int nmap; /* set options on sockets */ /* copy optval to host memory */ if (/* optval */regs->regs_R[MD_REG_A3] != 0 && /* optlen */regs->regs_R[MD_REG_A4] != 0) { buf = calloc(1, /* optlen */(size_t)regs->regs_R[MD_REG_A4]); if (!buf) fatal("cannot allocate memory in OSF_SYS_setsockopt"); /* copy target side pointer data into host side vector */ mem_bcopy(mem_fn, mem, Read, /* optval */regs->regs_R[MD_REG_A3], buf, /* optlen */(int)regs->regs_R[MD_REG_A4]); } else buf = NULL; /* pick the correct translation table */ if ((int)regs->regs_R[MD_REG_A1] == OSF_SOL_SOCKET) { map = sockopt_map; nmap = N_ELT(sockopt_map); } else if ((int)regs->regs_R[MD_REG_A1] == OSF_SOL_TCP) { map = tcpopt_map; nmap = N_ELT(tcpopt_map); } else { warn("no translation map available for `setsockopt()': %d", (int)regs->regs_R[MD_REG_A1]); map = sockopt_map; nmap = N_ELT(sockopt_map); } /* result */regs->regs_R[MD_REG_V0] = setsockopt(/* sock */(int)regs->regs_R[MD_REG_A0], /* level */xlate_arg((int)regs->regs_R[MD_REG_A1], socklevel_map, N_ELT(socklevel_map), "setsockopt(level)"), /* optname */xlate_arg((int)regs->regs_R[MD_REG_A2], map, nmap, "setsockopt(opt)"), /* optval */buf, /* optlen */regs->regs_R[MD_REG_A4]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } if (buf != NULL) free(buf); } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_old_getsockname: { /* get socket name */ char *buf; word_t osf_addrlen; int addrlen; /* get simulator memory parameters to host memory */ mem_bcopy(mem_fn, mem, Read, /* paddrlen */regs->regs_R[MD_REG_A2], &osf_addrlen, sizeof(osf_addrlen)); addrlen = (int)osf_addrlen; if (addrlen != 0) { buf = calloc(1, addrlen); if (!buf) fatal("cannot allocate memory in OSF_SYS_old_getsockname"); } else buf = NULL; /* result */regs->regs_R[MD_REG_V0] = getsockname(/* sock */(int)regs->regs_R[MD_REG_A0], /* name */(struct sockaddr *)buf, /* namelen */&addrlen); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* copy results to simulator memory */ if (addrlen != 0) mem_bcopy(mem_fn, mem, Write, /* addr */regs->regs_R[MD_REG_A1], buf, addrlen); osf_addrlen = (qword_t)addrlen; mem_bcopy(mem_fn, mem, Write, /* paddrlen */regs->regs_R[MD_REG_A2], &osf_addrlen, sizeof(osf_addrlen)); if (buf != NULL) free(buf); } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_old_getpeername: { /* get socket name */ char *buf; word_t osf_addrlen; int addrlen; /* get simulator memory parameters to host memory */ mem_bcopy(mem_fn, mem, Read, /* paddrlen */regs->regs_R[MD_REG_A2], &osf_addrlen, sizeof(osf_addrlen)); addrlen = (int)osf_addrlen; if (addrlen != 0) { buf = calloc(1, addrlen); if (!buf) fatal("cannot allocate memory in OSF_SYS_old_getsockname"); } else buf = NULL; /* result */regs->regs_R[MD_REG_V0] = getpeername(/* sock */(int)regs->regs_R[MD_REG_A0], /* name */(struct sockaddr *)buf, /* namelen */&addrlen); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* copy results to simulator memory */ if (addrlen != 0) mem_bcopy(mem_fn, mem, Write, /* addr */regs->regs_R[MD_REG_A1], buf, addrlen); osf_addrlen = (qword_t)addrlen; mem_bcopy(mem_fn, mem, Write, /* paddrlen */regs->regs_R[MD_REG_A2], &osf_addrlen, sizeof(osf_addrlen)); if (buf != NULL) free(buf); } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_setgid: /* set group ID */ /*result*/regs->regs_R[MD_REG_V0] = setgid(/* gid */(gid_t)regs->regs_R[MD_REG_A0]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_setuid: /* set user ID */ /*result*/regs->regs_R[MD_REG_V0] = setuid(/* uid */(uid_t)regs->regs_R[MD_REG_A0]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_getpriority: /* get program scheduling priority */ /*result*/regs->regs_R[MD_REG_V0] = getpriority(/* which */(int)regs->regs_R[MD_REG_A0], /* who */(int)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_setpriority: /* set program scheduling priority */ /*result*/regs->regs_R[MD_REG_V0] = setpriority(/* which */(int)regs->regs_R[MD_REG_A0], /* who */(int)regs->regs_R[MD_REG_A1], /* prio */(int)regs->regs_R[MD_REG_A2]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_select: { fd_set readfd, writefd, exceptfd; fd_set *readfdp, *writefdp, *exceptfdp; struct timeval timeout, *timeoutp; /* copy read file descriptor set into host memory */ if (/* readfds */regs->regs_R[MD_REG_A1] != 0) { mem_bcopy(mem_fn, mem, Read, /* readfds */regs->regs_R[MD_REG_A1], &readfd, sizeof(fd_set)); readfdp = &readfd; } else readfdp = NULL; /* copy write file descriptor set into host memory */ if (/* writefds */regs->regs_R[MD_REG_A2] != 0) { mem_bcopy(mem_fn, mem, Read, /* writefds */regs->regs_R[MD_REG_A2], &writefd, sizeof(fd_set)); writefdp = &writefd; } else writefdp = NULL; /* copy exception file descriptor set into host memory */ if (/* exceptfds */regs->regs_R[MD_REG_A3] != 0) { mem_bcopy(mem_fn, mem, Read, /* exceptfds */regs->regs_R[MD_REG_A3], &exceptfd, sizeof(fd_set)); exceptfdp = &exceptfd; } else exceptfdp = NULL; /* copy timeout value into host memory */ if (/* timeout */regs->regs_R[MD_REG_A4] != 0) { mem_bcopy(mem_fn, mem, Read, /* timeout */regs->regs_R[MD_REG_A4], &timeout, sizeof(struct timeval)); timeoutp = &timeout; } else timeoutp = NULL; #if defined(hpux) || defined(__hpux) /* select() on the specified file descriptors */ /* result */regs->regs_R[MD_REG_V0] = select(/* nfds */regs->regs_R[MD_REG_A0], (int *)readfdp, (int *)writefdp, (int *)exceptfdp, timeoutp); #else /* select() on the specified file descriptors */ /* result */regs->regs_R[MD_REG_V0] = select(/* nfds */regs->regs_R[MD_REG_A0], readfdp, writefdp, exceptfdp, timeoutp); #endif /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* copy read file descriptor set to target memory */ if (/* readfds */regs->regs_R[MD_REG_A1] != 0) mem_bcopy(mem_fn, mem, Write, /* readfds */regs->regs_R[MD_REG_A1], &readfd, sizeof(fd_set)); /* copy write file descriptor set to target memory */ if (/* writefds */regs->regs_R[MD_REG_A2] != 0) mem_bcopy(mem_fn, mem, Write, /* writefds */regs->regs_R[MD_REG_A2], &writefd, sizeof(fd_set)); /* copy exception file descriptor set to target memory */ if (/* exceptfds */regs->regs_R[MD_REG_A3] != 0) mem_bcopy(mem_fn, mem, Write, /* exceptfds */regs->regs_R[MD_REG_A3], &exceptfd, sizeof(fd_set)); /* copy timeout value result to target memory */ if (/* timeout */regs->regs_R[MD_REG_A4] != 0) mem_bcopy(mem_fn, mem, Write, /* timeout */regs->regs_R[MD_REG_A4], &timeout, sizeof(struct timeval)); } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_shutdown: /* shuts down socket send and receive operations */ /*result*/regs->regs_R[MD_REG_V0] = shutdown(/* sock */(int)regs->regs_R[MD_REG_A0], /* how */(int)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } break; #endif #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_poll: { int i; struct pollfd *fds; /* allocate host side I/O vectors */ fds = calloc(/* nfds */regs->regs_R[MD_REG_A1], sizeof(struct pollfd)); if (!fds) fatal("out of virtual memory in SYS_poll"); /* copy target side I/O vector buffers to host memory */ for (i=0; i < /* nfds */regs->regs_R[MD_REG_A1]; i++) { /* copy target side pointer data into host side vector */ mem_bcopy(mem_fn, mem, Read, (/* fds */regs->regs_R[MD_REG_A0] + i*sizeof(struct pollfd)), &fds[i], sizeof(struct pollfd)); } /* perform the vector'ed write */ /* result */regs->regs_R[MD_REG_V0] = poll(/* fds */fds, /* nfds */(unsigned long)regs->regs_R[MD_REG_A1], /* timeout */(int)regs->regs_R[MD_REG_A2]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* copy target side I/O vector buffers to host memory */ for (i=0; i < /* nfds */regs->regs_R[MD_REG_A1]; i++) { /* copy target side pointer data into host side vector */ mem_bcopy(mem_fn, mem, Write, (/* fds */regs->regs_R[MD_REG_A0] + i*sizeof(struct pollfd)), &fds[i], sizeof(struct pollfd)); } /* free all the allocated memory */ free(fds); } break; #endif case OSF_SYS_usleep_thread: #if 0 fprintf(stderr, "usleep(%d)\n", (unsigned int)regs->regs_R[MD_REG_A0]); #endif #ifdef alpha regs->regs_R[MD_REG_V0] = usleep((unsigned int)regs->regs_R[MD_REG_A0]); #else usleep((unsigned int)regs->regs_R[MD_REG_A0]); regs->regs_R[MD_REG_V0] = 0; #endif /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } #if 0 warn("unsupported usleep_thread() call..."); regs->regs_R[MD_REG_V0] = 0; #endif break; #if !defined(MIN_SYSCALL_MODE) case OSF_SYS_gethostname: /* get program scheduling priority */ { char *buf; buf = malloc(/* len */(size_t)regs->regs_R[MD_REG_A1]); if (!buf) fatal("out of virtual memory in gethostname()"); /* result */regs->regs_R[MD_REG_V0] = gethostname(/* name */buf, /* len */(size_t)regs->regs_R[MD_REG_A1]); /* check for an error condition */ if (regs->regs_R[MD_REG_V0] != (qword_t)-1) regs->regs_R[MD_REG_A3] = 0; else /* got an error, return details */ { regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = errno; } /* copy string back to simulated memory */ mem_bcopy(mem_fn, mem, Write, /* name */regs->regs_R[MD_REG_A0], buf, /* len */regs->regs_R[MD_REG_A1]); } break; #endif case OSF_SYS_madvise: warn("unsupported madvise() call ignored..."); regs->regs_R[MD_REG_V0] = 0; break; default: warn("invalid/unimplemented syscall %ld, PC=0x%08p, RA=0x%08p, winging it", syscode, regs->regs_PC, regs->regs_R[MD_REG_RA]); regs->regs_R[MD_REG_A3] = -1; regs->regs_R[MD_REG_V0] = 0; #if 0 fatal("invalid/unimplemented system call encountered, code %d", syscode); #endif } if (verbose) fprintf(stderr, "syscall(%d): returned %d:%d...\n", (int)syscode, (int)regs->regs_R[MD_REG_A3], (int)regs->regs_R[MD_REG_V0]); }

	Department of Computer Science School of Engineering, University of Virginia 151 Engineer's Way, P.O. Box 400740 Charlottesville, Virginia 22904-4740 (434) 982-2200  Fax: (434) 982-2214