home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / c / condor40.zip / CONDOR / src / condor_lib / CONDOR_syscall < prev    next >
Text File  |  1989-09-02  |  26KB  |  895 lines
  1. /* 
  2. ** Copyright 1986, 1987, 1988, 1989 University of Wisconsin
  3. ** 
  4. ** Permission to use, copy, modify, and distribute this software and its
  5. ** documentation for any purpose and without fee is hereby granted,
  6. ** provided that the above copyright notice appear in all copies and that
  7. ** both that copyright notice and this permission notice appear in
  8. ** supporting documentation, and that the name of the University of
  9. ** Wisconsin not be used in advertising or publicity pertaining to
  10. ** distribution of the software without specific, written prior
  11. ** permission.  The University of Wisconsin makes no representations about
  12. ** the suitability of this software for any purpose.  It is provided "as
  13. ** is" without express or implied warranty.
  14. ** 
  15. ** THE UNIVERSITY OF WISCONSIN DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. ** THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. ** FITNESS. IN NO EVENT SHALL THE UNIVERSITY OF WISCONSIN  BE LIABLE FOR
  18. ** ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. ** WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ** ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  21. ** OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22. ** 
  23. ** Authors:  Allan Bricker and Michael J. Litzkow,
  24. **              University of Wisconsin, Computer Sciences Dept.
  25. ** 
  26. */ 
  27.  
  28.  
  29. #include <stdio.h>
  30. #include <sys/types.h>
  31. #include <sys/param.h>
  32. #include <sys/file.h>
  33. #include "errno.h"
  34. #include <sys/wait.h>
  35. #include <sys/time.h>
  36. #include <sys/ioctl.h>
  37. #include <rpc/types.h>
  38. #include <rpc/xdr.h>
  39. #include <varargs.h>
  40.  
  41. #include "condor_types.h"
  42. #include "ckpt_file.h"
  43. #include "condor_sys.h"
  44. #include "condor_rsc.h"
  45. #include "xdr_lib.h"
  46. #include "trace.h"
  47. #include "except.h"
  48. #include "debug.h"
  49.  
  50. #ifndef LINT
  51. static char *_FileName_ = __FILE__;        /* Used by EXCEPT (see except.h)     */
  52. #endif LINT
  53.  
  54. extern int SyscallInProgress;
  55. extern int CkptWanted;
  56.  
  57. #ifdef CONDOR
  58. static XDR xdr_data;    /* Only the RSCSock will use XDR */
  59.  
  60. static XDR *xdr_syscall;
  61.  
  62. static int RSCSock;
  63. static int ErrSock;
  64.  
  65. #define XDR_BUFSIZ    (4 * 1024)
  66.  
  67. XDR *
  68. RSC_Init( rscsock, errsock )
  69. int rscsock, errsock;
  70. {
  71.     int XDR_Read(), XDR_Write();
  72.  
  73.     xdr_syscall = &xdr_data;
  74.     RSCSock     = rscsock;
  75.     xdrrec_create( xdr_syscall, XDR_BUFSIZ, XDR_BUFSIZ, &RSCSock,
  76.             XDR_Read, XDR_Write );
  77.  
  78.     ErrSock = errsock;
  79.  
  80.     return( xdr_syscall );
  81. }
  82. #endif CONDOR
  83.  
  84. int CurrentSysCall;
  85.  
  86. /*
  87. **    In the REMOTE_syscall routine, a1 through a6 are the arguments
  88. **    to the system call.  They will be cast as needed.
  89. */
  90.  
  91. /*VARARGS1*/
  92. /* REMOTE_syscall( condor_sysnum, a1, a2, a3, a4, a5, a6 ) */
  93. REMOTE_syscall(va_alist)
  94. va_dcl
  95. {
  96.     va_list pvar;
  97.     int condor_sysnum;
  98. #ifdef CONDOR
  99.     char ErrBuf[ BUFSIZ ];
  100. #endif CONDOR
  101.     int rval;
  102.     extern errno;
  103.  
  104.     va_start(pvar);
  105.  
  106.     condor_sysnum = va_arg(pvar, int);
  107.  
  108.     CurrentSysCall = condor_sysnum;
  109.  
  110. #ifndef CONDOR
  111.     fprintf(stderr, "REMOTE syscall: CONDOR system call is %s\n",
  112.         CONDOR_SYSCALLNAME(condor_sysnum));
  113.  
  114.     rval = -1;
  115.     goto RETURN;
  116. #else CONDOR
  117.  
  118.     /*
  119.     **    System calls which must be done locally
  120.     */
  121.     switch( condor_sysnum ) {
  122.     case PSEUDO_brk:        /* char *brk( char * )                        */
  123.     case CONDOR_sbrk:            /* char *sbrk( int )                      */
  124.     case CONDOR_profil:            /* profil( char *, int, int, int )        */
  125.     case CONDOR_sigblock:        /* sigblock( int )                        */
  126.     case CONDOR_sigpause:        /* sigpause( int )                        */
  127.     case CONDOR_sigreturn:        /* sigreturn( struct sigcontext * )       */
  128.     case CONDOR_sigsetmask:        /* sigsetmask( int )                      */
  129.     case CONDOR_sigstack:        /* sigstack( struct sigstack *,
  130.                                        R struct sigstack * )              */
  131.     case CONDOR_sigvec:            /* sigvec( int, struct sigvec *,
  132.                                           R struct sigvec * )             */
  133.         sprintf(ErrBuf, "ERROR: %s call should be performed locally",
  134.                 CONDOR_SYSCALLNAME(condor_sysnum));
  135.         dprintf(D_ALWAYS, "%s\n", ErrBuf);
  136.         fprintf(stderr, "%s\n", ErrBuf);
  137.         errno = ESYSNOTSUPP;
  138.         rval = -1;
  139.         goto RETURN;
  140.     }
  141.  
  142.     SyscallInProgress = 1;
  143.  
  144.     xdr_syscall->x_op = XDR_ENCODE;
  145.     ASSERT( xdr_int(xdr_syscall, &condor_sysnum) );
  146.  
  147.     dprintf(D_SYSCALLS, "REMOTE_syscall: calling %s\n",
  148.             CONDOR_SYSCALLNAME(condor_sysnum));
  149.  
  150.     switch( condor_sysnum ) {
  151.     /*
  152.     **    System calls with no arguments
  153.     */
  154.     case CONDOR_async_daemon:    /* async_daemon()                          */
  155.     case CONDOR_fork:            /* fork()                                  */
  156.     case CONDOR_getdtablesize:    /* getdtablesize()                         */
  157.     case PSEUDO_getegid:    /* getegid()                                   */
  158.     case PSEUDO_geteuid:    /* geteuid()                                   */
  159.     case CONDOR_getgid:            /* getgid()                                */
  160.     case CONDOR_gethostid:        /* gethostid()                             */
  161.     case CONDOR_getpagesize:    /* getpagesize()                           */
  162.     case CONDOR_getpid:            /* getpid()                                */
  163.     case PSEUDO_getppid:    /* getppid()                                   */
  164.     case CONDOR_getuid:            /* getuid()                                */
  165.     case CONDOR_sync:            /* sync()                                  */
  166.     case CONDOR_vhangup:        /* vhangup()                               */
  167.         GET_RVAL(xdr_syscall);
  168.         goto RETURN;
  169.  
  170.     /*
  171.     **    System calls which take one integer argument
  172.     */
  173.     case CONDOR__exit:            /* _exit( int status )                     */
  174.     case CONDOR_close:            /* close( int d )                          */
  175.     case CONDOR_dup:            /* dup( int oldd )                         */
  176.     case CONDOR_fsync:            /* fsync( int fd )                         */
  177.     case CONDOR_getpgrp:        /* getpgrp( int pid )                      */
  178.     case CONDOR_nfssvc:            /* nfssvs( int ??? )                       */
  179.     case CONDOR_reboot:            /* reboot( int howto )                     */
  180.     case CONDOR_umask:            /* umask( int numask )                     */
  181.     {
  182.         int int_arg1 = va_arg(pvar, int);
  183.  
  184.         ASSERT(xdr_int(xdr_syscall, &int_arg1));
  185.         GET_RVAL(xdr_syscall);
  186.         goto RETURN;
  187.     }
  188.  
  189.     /*
  190.     **    System calls which take one long argument
  191.     */
  192.     case CONDOR_sethostid:        /* sethostid( long hostid )                  */
  193.     {
  194.         long hostid = va_arg(pvar, long);
  195.  
  196.         ASSERT(xdr_long(xdr_syscall, &hostid));
  197.         GET_RVAL(xdr_syscall);
  198.         goto RETURN;
  199.     }
  200.  
  201.     /*
  202.     **    System calls which take two integer arguments
  203.     */
  204.     case CONDOR_dup2:            /* dup2( int oldd, int newd )                */
  205.     case CONDOR_fchmod:            /* fchmod( int fd, int mode )                */
  206.     case CONDOR_flock:            /* flock( int fd, int operation )            */
  207.     case CONDOR_getpriority:    /* getpriority( int which, int who )         */
  208.     case CONDOR_kill:            /* kill( int pid, int sig )                  */
  209.     case CONDOR_killpg:            /* killpg( int pgrp, int sig )               */
  210.     case CONDOR_listen:            /* listen( int s, int backlog )              */
  211.     case CONDOR_setpgrp:        /* setpgrp( int pid, int pgrp )              */
  212.     case CONDOR_setregid:        /* setregid( int rgid, int egid )            */
  213.     case CONDOR_setreuid:        /* setreuid( int ruid, int euid )            */
  214.     case CONDOR_shutdown:        /* shutdown( int s, int how )                */
  215.     {
  216.         int int_arg1 = va_arg(pvar, int);
  217.         int int_arg2 = va_arg(pvar, int);
  218.  
  219.         ASSERT(xdr_int(xdr_syscall, &int_arg1));
  220.         ASSERT(xdr_int(xdr_syscall, &int_arg2));
  221.         GET_RVAL(xdr_syscall);
  222.         goto RETURN;
  223.     }
  224.  
  225.     /*
  226.     **    System calls which take an integer argument and an off_t argument
  227.     */
  228.     case CONDOR_ftruncate:        /* ftruncate( int fd, off_t length )         */
  229.     {
  230.         int fd = va_arg(pvar, int);
  231.         off_t length = va_arg(pvar, off_t);
  232.  
  233.         ASSERT(xdr_int(xdr_syscall, &fd));
  234.         ASSERT(xdr_off_t(xdr_syscall, &length));
  235.         GET_RVAL(xdr_syscall);
  236.         goto RETURN;
  237.     }
  238.  
  239.     /*
  240.     **    System calls which take three integer arguments
  241.     */
  242.     case CONDOR_fchown:            /* fchown( int fd, int owner, int group )    */
  243.     case CONDOR_fcntl:            /* fcntl( int fd, int cmd, int arg )         */
  244.     case CONDOR_setpriority:    /* setpriority( int which, int who,
  245.                                                                 int prio )   */
  246.     case CONDOR_socket:            /* socket( int domain, int type,
  247.                                                                 int protocol)*/
  248.     {
  249.         int int_arg1 = va_arg(pvar, int);
  250.         int int_arg2 = va_arg(pvar, int);
  251.         int int_arg3 = va_arg(pvar, int);
  252.  
  253.         ASSERT(xdr_int(xdr_syscall, &int_arg1));
  254.         ASSERT(xdr_int(xdr_syscall, &int_arg2));
  255.         ASSERT(xdr_int(xdr_syscall, &int_arg3));
  256.         GET_RVAL(xdr_syscall);
  257.         goto RETURN;
  258.     }
  259.  
  260.     /*
  261.     **    System calls which take an integer argument followed by
  262.     **    an off_t argument followed by another integer argument.
  263.     */
  264.     case CONDOR_lseek:            /* lseek( int d, off_t offset, int whence )  */
  265.     {
  266.         int d = va_arg(pvar, int);
  267.         off_t offset = va_arg(pvar, off_t);
  268.         int whence = va_arg(pvar, int);
  269.  
  270.         ASSERT(xdr_int(xdr_syscall, &d));
  271.         ASSERT(xdr_off_t(xdr_syscall, &offset));
  272.         ASSERT(xdr_int(xdr_syscall, &whence));
  273.         GET_RVAL(xdr_syscall);
  274.         goto RETURN;
  275.     }
  276.  
  277.     /*
  278.     **    System calls which take one string argument
  279.     */
  280.     case CONDOR_acct:            /* acct( char *file )                        */
  281.     case CONDOR_chdir:            /* chdir( char *path )                       */
  282.     case CONDOR_chroot:            /* chroot( char *dirname )                   */
  283.     case CONDOR_rmdir:            /* rmdir( char *path )                       */
  284.     case CONDOR_swapon:            /* swapon( char *special )                   */
  285.     case CONDOR_unlink:            /* unlink( char *path )                      */
  286.     case CONDOR_unmount:        /* unmount( char *name )                     */
  287.     {
  288.         char *str_arg1 = va_arg(pvar, char *);
  289.  
  290.         ASSERT(xdr_string(xdr_syscall, &str_arg1, MAXPATHLEN));
  291.         GET_RVAL(xdr_syscall);
  292.         goto RETURN;
  293.     }
  294.  
  295.     /*
  296.     **    System calls which take one string and one integer as arguments
  297.     */
  298.     case CONDOR_access:            /* access( char *path, int mode )            */
  299.     case CONDOR_chmod:            /* chmod( char *path, int mode )             */
  300.     case CONDOR_creat:            /* creat( char *path, int mode )             */
  301.     case CONDOR_mkdir:            /* mkdir( char *path, int mode )             */
  302.     case CONDOR_setdomainname:    /* setdomainname( char *name, int namelen )  */
  303.     case CONDOR_sethostname:    /* sethostname( char *name, int namelen )    */
  304.     {
  305.         char *str_arg1 = va_arg(pvar, char *);
  306.         int int_arg2 = va_arg(pvar, int);
  307.  
  308.         ASSERT(xdr_string(xdr_syscall, &str_arg1, MAXPATHLEN));
  309.         ASSERT(xdr_int(xdr_syscall, &int_arg2));
  310.         GET_RVAL(xdr_syscall);
  311.         goto RETURN;
  312.     }
  313.  
  314.     /*
  315.     **    System calls which take one string and one off_t as arguments
  316.     */
  317.     case CONDOR_truncate:        /* truncate( char *path, off_t length )      */
  318.     {
  319.         char *path = va_arg(pvar, char *);
  320.         off_t length = va_arg(pvar, off_t);
  321.  
  322.         ASSERT(xdr_string(xdr_syscall, &path, MAXPATHLEN));
  323.         ASSERT(xdr_off_t(xdr_syscall, &length));
  324.         GET_RVAL(xdr_syscall);
  325.         goto RETURN;
  326.     }
  327.  
  328.     /*
  329.     **    System calls which take one string and two integers as arguments
  330.     */
  331.     case CONDOR_chown:            /* chown( char *path, int owner, int group ) */
  332.     case CONDOR_mknod:            /* mknod( char *path, int mode, int dev )    */
  333.     case CONDOR_open:            /* open( char *path, int flags, int mode )   */
  334.     {
  335.         char *str_arg1 = va_arg(pvar, char *);
  336.         int int_arg2 = va_arg(pvar, int);
  337.         int int_arg3 = va_arg(pvar, int);
  338.  
  339.         ASSERT(xdr_string(xdr_syscall, &str_arg1, MAXPATHLEN));
  340.         ASSERT(xdr_int(xdr_syscall, &int_arg2));
  341.         ASSERT(xdr_int(xdr_syscall, &int_arg3));
  342.         GET_RVAL(xdr_syscall);
  343.         goto RETURN;
  344.     }
  345.  
  346.     /*
  347.     **    System calls which take two strings as arguments
  348.     */
  349.     case CONDOR_link:            /* link( char *name1, char *name2 )          */
  350.     case CONDOR_rename:            /* rename( char *from, char *to )            */
  351.     case CONDOR_symlink:        /* symlink( char *name1, char *name2 )       */
  352.     {
  353.         char *str_arg1 = va_arg(pvar, char *);
  354.         char *str_arg2 = va_arg(pvar, char *);
  355.  
  356.         ASSERT(xdr_string(xdr_syscall, &str_arg1, MAXPATHLEN));
  357.         ASSERT(xdr_string(xdr_syscall, &str_arg2, MAXPATHLEN));
  358.         GET_RVAL(xdr_syscall);
  359.         goto RETURN;
  360.     }
  361.  
  362.     /*
  363.     **    Other system calls
  364.     */
  365.  
  366.     case CONDOR_wait:            /* wait( R union wait *status )              */
  367.     {
  368.         union wait *status = va_arg(pvar, union wait *);
  369.  
  370.         GET_RVAL(xdr_syscall);
  371.         if( status != 0 ) {
  372.             ASSERT(xdr_wait(xdr_syscall, status));
  373.         } else {
  374.             union wait dummy;
  375.             ASSERT(xdr_wait(xdr_syscall, &dummy));
  376.         }
  377.         goto RETURN;
  378.     }
  379.  
  380.     case PSEUDO_wait3: /* wait3( R union wait *status, int options,
  381.                        **                        struct rusage *rusage )
  382.                        */
  383.     {
  384.         int xdr_rusage();
  385.         union wait *status = va_arg(pvar, union wait *);
  386.         int options = va_arg(pvar, int);
  387.         struct rusage *rusage = va_arg(pvar, struct rusage *);
  388.         
  389.         ASSERT(xdr_int(xdr_syscall, &options));
  390.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &rusage, xdr_rusage));
  391.         GET_RVAL(xdr_syscall);
  392.         ASSERT(xdr_wait(xdr_syscall, status));
  393.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &rusage, xdr_rusage));
  394.         goto RETURN;
  395.     }
  396.  
  397.     case PSEUDO_reallyexit: /* reallyexit( M union wait *status,
  398.                             **               M struct rusage *rusage )         */
  399.     {
  400.         union wait *status = va_arg(pvar, union wait *);
  401.         struct rusage *rusage = va_arg(pvar, struct rusage *);
  402.  
  403.         ASSERT(xdr_wait(xdr_syscall, status));
  404.         ASSERT(xdr_rusage(xdr_syscall, rusage));
  405.  
  406.         GET_RVAL(xdr_syscall);
  407.  
  408.         goto RETURN;
  409.     }
  410.  
  411.     case PSEUDO_getwd: /* getwd( R char *pathname )                          */
  412.     {
  413.         char *pathname = va_arg(pvar, char *);
  414.         
  415.         GET_RVAL(xdr_syscall);
  416.         ASSERT(xdr_string(xdr_syscall, &pathname, MAXPATHLEN));
  417.  
  418.         if( rval != 0 ) {
  419.             rval = (int) pathname;
  420.         }
  421.  
  422.         goto RETURN;
  423.     }
  424.  
  425.     case CONDOR_lstat:            /* lstat( char *path, R struct stat *buf )   */
  426.     case CONDOR_stat:            /* stat( char *path, R struct stat *buf )    */
  427.     {
  428.         char *path = va_arg(pvar, char *);
  429.         struct stat *buf = va_arg(pvar, struct stat *);
  430.         
  431.         ASSERT(xdr_string(xdr_syscall, &path, MAXPATHLEN));
  432.         GET_RVAL(xdr_syscall);
  433.         ASSERT(xdr_stat(xdr_syscall, buf));
  434.         goto RETURN;
  435.     }
  436.  
  437.     case CONDOR_pipe:            /* pipe( int fildes[2] )                     */
  438.     {
  439.         int *fildes = va_arg(pvar, int *);
  440.  
  441.         GET_RVAL(xdr_syscall);
  442.         ASSERT(xdr_int(xdr_syscall, &fildes[0]));
  443.         ASSERT(xdr_int(xdr_syscall, &fildes[1]));
  444.         goto RETURN;
  445.     }
  446.  
  447.     case CONDOR_settimeofday:    /* settimeofday( struct timeval *tp,
  448.                             **                 struct timezone *tzp )
  449.                             */
  450.     {
  451.         struct timeval *tp = va_arg(pvar, struct timeval *);
  452.         struct timezone *tzp = va_arg(pvar, struct timezone *);
  453.         int xdr_timezone();
  454.         
  455.         ASSERT(timeval_xdr(xdr_syscall, tp));
  456.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &tzp, xdr_timezone));
  457.         GET_RVAL(xdr_syscall);
  458.         goto RETURN;
  459.     }
  460.  
  461.     case CONDOR_gettimeofday:    /* gettimeofday( R struct timeval *tp,
  462.                             **                 R struct timezone *tzp )
  463.                             */
  464.     {
  465.         struct timeval *tp = va_arg(pvar, struct timeval *);
  466.         struct timezone *tzp = va_arg(pvar, struct timezone *);
  467.         int xdr_timezone();
  468.         
  469.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &tzp, xdr_timezone));
  470.  
  471.         GET_RVAL(xdr_syscall);
  472.         ASSERT(timeval_xdr(xdr_syscall, tp));
  473.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &tzp, xdr_timezone));
  474.         goto RETURN;
  475.     }
  476.  
  477.     case CONDOR_getdomainname:    /* getdomainname( R char *name, int namelen )*/
  478.     case CONDOR_gethostname:    /* gethostname( R char *name, int namelen )  */
  479.     {
  480.         char *name = va_arg(pvar, char *);
  481.         int namelen = va_arg(pvar, int);
  482.         
  483.         ASSERT(xdr_int(xdr_syscall, &namelen));
  484.         GET_RVAL(xdr_syscall);
  485.         ASSERT(xdr_string(xdr_syscall, &name, namelen));
  486.         goto RETURN;
  487.     }
  488.         
  489.     case CONDOR_select:            /* select( int nfds,
  490.                             **        0/VR fd_set *readfds,
  491.                             **        0/VR fd_set *writefds,
  492.                             **        0/VR fd_set *exceptfds,
  493.                             **        0/V struct timeval *timeout )
  494.                             */
  495.     {
  496.         int xdr_fdset(), timeval_xdr();
  497.         int nfds = va_arg(pvar, int);
  498.         fd_set *readfds = va_arg(pvar, fd_set *);
  499.         fd_set *writefds = va_arg(pvar, fd_set *);
  500.         fd_set *exceptfds = va_arg(pvar, fd_set *);
  501.         struct timeval *timeout = va_arg(pvar, struct timeval *);
  502.  
  503.         ASSERT(xdr_int(xdr_syscall, &nfds));
  504.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &readfds, xdr_fdset));
  505.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &writefds, xdr_fdset));
  506.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &exceptfds, xdr_fdset));
  507.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &timeout, timeval_xdr));
  508.  
  509.         GET_RVAL(xdr_syscall);
  510.  
  511.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &readfds, xdr_fdset));
  512.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &writefds, xdr_fdset));
  513.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &exceptfds, xdr_fdset));
  514.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &timeout, timeval_xdr));
  515.  
  516.         goto RETURN;
  517.     }
  518.  
  519.     case CONDOR_setgroups:        /* setgroups( int ngroups, M int *gidset )   */
  520.     {
  521.         int ngroups = va_arg(pvar, int);
  522.         int *gidset = va_arg(pvar, int *);
  523.  
  524.         ASSERT(xdr_array(xdr_syscall, &gidset, &ngroups, NGROUPS, sizeof(int), xdr_int));
  525.         GET_RVAL(xdr_syscall);
  526.         goto RETURN;
  527.     }
  528.  
  529.     case CONDOR_setitimer:        /* setitimer( int which,
  530.                             **            M struct itimerval *value,
  531.                             **          R/0 struct itimerval *ovalue )
  532.                             */
  533.     {
  534.         int which = va_arg(pvar, int);
  535.         struct itimerval *value = va_arg(pvar, struct itimerval *);
  536.         struct itimerval *ovalue = va_arg(pvar, struct itimerval *);
  537.         
  538.         ASSERT(xdr_int(xdr_syscall, &which));
  539.         ASSERT(xdr_itimerval(xdr_syscall, value));
  540.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &ovalue, timeval_xdr));
  541.  
  542.         GET_RVAL(xdr_syscall);
  543.  
  544.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &ovalue, timeval_xdr));
  545.         goto RETURN;
  546.     }
  547.  
  548.     case CONDOR_setrlimit:        /* setrlimit( int resource,
  549.                             **            M struct rlimit *rlp )
  550.                             */
  551.     {
  552.         int resource = va_arg(pvar, int);
  553.         struct rlimit *rlp = va_arg(pvar, struct rlimit *);
  554.         
  555.         ASSERT(xdr_int(xdr_syscall, &resource));
  556.         ASSERT(xdr_rlimit(xdr_syscall, rlp));
  557.         GET_RVAL(xdr_syscall);
  558.         goto RETURN;
  559.     }
  560.  
  561.     case CONDOR_getdirentries:    /* getdirentries( int fd,
  562.                             **                R char *buf,
  563.                             **                  int nbytes,
  564.                             **                R off_t *basep )
  565.                             */
  566.     {
  567.         int fd = va_arg(pvar, int);
  568.         char *buf = va_arg(pvar, char *);
  569.         int nbytes = va_arg(pvar, int);
  570.         long *basep = va_arg(pvar, long *);
  571.  
  572.         ASSERT(xdr_int(xdr_syscall, &fd));
  573.         ASSERT(xdr_int(xdr_syscall, &nbytes));
  574.         GET_RVAL(xdr_syscall);
  575.  
  576.         ASSERT(xdr_direntries(xdr_syscall, buf, rval));
  577.         ASSERT(xdr_off_t(xdr_syscall, basep));
  578.  
  579.         goto RETURN;
  580.     }
  581.  
  582.     case CONDOR_getgroups:        /* getgroups( int gidsetlen, R int *gidset ) */
  583.     {
  584.         int gidsetlen = va_arg(pvar, int);
  585.         int *gidset = va_arg(pvar, int *);
  586.         register int i;
  587.  
  588.         ASSERT(xdr_int(xdr_syscall, &gidsetlen));
  589.         GET_RVAL(xdr_syscall);
  590.  
  591.         for( i = 0; i < rval; i++ ) {
  592.             ASSERT(xdr_int(xdr_syscall, &gidset[i]));
  593.         }
  594.         goto RETURN;
  595.     }
  596.  
  597.     case CONDOR_getitimer:        /* getitimer( int which,
  598.                             **            R struct itimerval *value )
  599.                             */
  600.     {
  601.         int which = va_arg(pvar, int);
  602.         struct itimerval *value = va_arg(pvar, struct itimerval *);
  603.         
  604.         ASSERT(xdr_int(xdr_syscall, &which));
  605.         GET_RVAL(xdr_syscall);
  606.         ASSERT(xdr_itimerval(xdr_syscall, value));
  607.         goto RETURN;
  608.     }
  609.  
  610.     case CONDOR_getrlimit:        /* getrlimit( int resource,
  611.                             **            R struct rlimit *rlp )
  612.                             */
  613.     {
  614.         int resource = va_arg(pvar, int);
  615.         struct rlimit *rlp = va_arg(pvar, struct rlimit *);
  616.         
  617.         ASSERT(xdr_int(xdr_syscall, &resource));
  618.         GET_RVAL(xdr_syscall);
  619.         ASSERT(xdr_rlimit(xdr_syscall, rlp));
  620.         goto RETURN;
  621.     }
  622.  
  623.     case CONDOR_getrusage:        /* getrusage( int who,
  624.                             **            R struct rusage *rusage )
  625.                             */
  626.     {
  627.         int who = va_arg(pvar, int);
  628.         struct rusage *rusage = va_arg(pvar, struct rusage *);
  629.  
  630.         
  631.         ASSERT(xdr_int(xdr_syscall, &who));
  632.         GET_RVAL(xdr_syscall);
  633.         ASSERT(xdr_rusage(xdr_syscall, rusage));
  634.         goto RETURN;
  635.     }
  636.  
  637.     case CONDOR_fstat:            /* fstat( int fd, R struct stat *buf )       */
  638.     {
  639.         int fd = va_arg(pvar, int);
  640.         struct stat *buf = va_arg(pvar, struct stat *);
  641.         
  642.         ASSERT(xdr_int(xdr_syscall, &fd));
  643.         GET_RVAL(xdr_syscall);
  644.         ASSERT(xdr_stat(xdr_syscall, buf));
  645.         goto RETURN;
  646.     }
  647.  
  648.     case CONDOR_fstatfs:        /* fstatfs( int fd, struct statfs *buf )     */
  649.     {
  650.         int fd = va_arg(pvar, int);
  651.         struct statfs *buf = va_arg(pvar, struct statfs *);
  652.         
  653.         ASSERT(xdr_int(xdr_syscall, &fd));
  654.         GET_RVAL(xdr_syscall);
  655.         ASSERT(xdr_statfs(xdr_syscall, buf));
  656.         goto RETURN;
  657.     }
  658.  
  659.     case CONDOR_utimes:            /* utimes( char *file, M struct timeval *tvp)*/
  660.     {
  661.         char *file = va_arg(pvar, char *);
  662.         struct timeval *tvp = va_arg(pvar, struct timeval *);
  663.  
  664.         ASSERT(xdr_string(xdr_syscall, &file, MAXPATHLEN));
  665.         ASSERT(timeval_xdr(xdr_syscall, &tvp[0]));
  666.         ASSERT(timeval_xdr(xdr_syscall, &tvp[1]));
  667.  
  668.         GET_RVAL(xdr_syscall);
  669.         goto RETURN;
  670.     }
  671.  
  672.     case CONDOR_readlink:        /* readlink( char *path, char *buf,
  673.                                                                 int bufsiz ) */
  674.     {
  675.         char *path = va_arg(pvar, char *);
  676.         char *buf = va_arg(pvar, char *);
  677.         int bufsiz = va_arg(pvar, int);
  678.  
  679.         ASSERT(xdr_string(xdr_syscall, &path, MAXPATHLEN));
  680.         ASSERT(xdr_int(xdr_syscall, &bufsiz));
  681.         GET_RVAL(xdr_syscall);
  682.         ASSERT(xdr_string(xdr_syscall, &buf, bufsiz));
  683.         goto RETURN;
  684.     }
  685.  
  686.     case CONDOR_adjtime:        /* adjtime( M struct timeval *delta,
  687.                             **          R/0 struct timeval *olddelta )
  688.                             */
  689.     {
  690.         struct timeval *delta = va_arg(pvar, struct timeval *);
  691.         struct timeval *olddelta = va_arg(pvar, struct timeval *);
  692.  
  693.         ASSERT(timeval_xdr(xdr_syscall, delta));
  694.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &olddelta, timeval_xdr));
  695.  
  696.         GET_RVAL(xdr_syscall);
  697.  
  698.         ASSERT(xdr_ptr(xdr_syscall, (caddr_t *) &olddelta, timeval_xdr));
  699.  
  700.         goto RETURN;
  701.     }
  702.  
  703.     case CONDOR_statfs:            /* statfs( char *path, R struct statfs *buf )*/
  704.     {
  705.         char *path = va_arg(pvar, char *);
  706.         struct statfs *buf = va_arg(pvar, struct statfs *);
  707.         
  708.         ASSERT(xdr_string(xdr_syscall, &path, MAXPATHLEN));
  709.         GET_RVAL(xdr_syscall);
  710.         ASSERT(xdr_statfs(xdr_syscall, buf));
  711.         goto RETURN;
  712.     }
  713.  
  714.     case CONDOR_write:            /* write( int d, M char *buf, int nbytes )   */
  715.     {
  716.         int d = va_arg(pvar, int);
  717.         char *buf = va_arg(pvar, char *);
  718.         int nbytes = va_arg(pvar, int);
  719.  
  720.         ASSERT(xdr_int(xdr_syscall, &d));
  721.         ASSERT(xdr_int(xdr_syscall, &nbytes));
  722.         ASSERT(xdr_bytes(xdr_syscall, (caddr_t *) &buf, &nbytes, nbytes));
  723.  
  724.         GET_RVAL(xdr_syscall);
  725.         goto RETURN;
  726.     }
  727.  
  728.     case CONDOR_read:            /* write( int d, R char *buf, int nbytes )   */
  729.     {
  730.         int d = va_arg(pvar, int);
  731.         char *buf = va_arg(pvar, char *);
  732.         int nbytes = va_arg(pvar, int);
  733.  
  734.         ASSERT(xdr_int(xdr_syscall, &d));
  735.         ASSERT(xdr_int(xdr_syscall, &nbytes));
  736.  
  737.         GET_RVAL(xdr_syscall);
  738.  
  739.         ASSERT(xdr_bytes(xdr_syscall, (caddr_t *) &buf, &nbytes, nbytes));
  740.         goto RETURN;
  741.     }
  742.  
  743.     case CONDOR_ioctl:            /* ioctl( int d, u_long request, char *argp )*/
  744.     {
  745.         int d = va_arg(pvar, int);
  746.         u_long request = va_arg(pvar, u_long);
  747.         char *argp = va_arg(pvar, char *);
  748.  
  749.         ASSERT(xdr_int(xdr_syscall, &d));
  750.         ASSERT(xdr_u_long(xdr_syscall, &request));
  751.  
  752.         if( request & IOC_IN ) {
  753.             ASSERT(xdr_opaque(xdr_syscall, argp, request & IOCPARM_MASK));
  754.         }
  755.  
  756.         GET_RVAL(xdr_syscall);
  757.  
  758.         if( request & IOC_OUT ) {
  759.             ASSERT(xdr_opaque(xdr_syscall, argp, request & IOCPARM_MASK));
  760.         }
  761.     }
  762.  
  763.     case CONDOR_writev:            /* writev( int d, struct iovec *iov,
  764.                                                                 int iovcnt ) */
  765.     case CONDOR_readv:            /* readv( int, VR iov *, int )               */
  766.  
  767.     case CONDOR_ptrace:            /* ptrace( int, int, VR int *, int           */
  768.     case CONDOR_quotactl:        /* quotaactl( int, str, int, VRU caddr_t )   */
  769.     case CONDOR_execv:            /* execv( str, M str[] )                     */
  770.     case CONDOR_execve:            /* execve( str, M str[], M str[] )           */
  771.  
  772.     case CONDOR_send:            /* send( int, M caddr_t, int, int )          */
  773.     case CONDOR_sendto:            /* sendto( int, M caddr_t, int, int,
  774.                                         M sockaddr *, int                    */
  775.     case CONDOR_sendmsg:        /* sendmsg( int, V msghdr[], int )           */
  776.  
  777.     case CONDOR_recv:            /* recv( int, R caddr_t, int, int )          */
  778.     case CONDOR_recvfrom:        /* recvfrom( int, R caddr_t, int, int,
  779.                                             0/R sockaddr *, VR int * )       */
  780.     case CONDOR_recvmsg:        /* recvmsg( int, VR msghdr[], int )          */
  781.  
  782.     case CONDOR_setsockopt:        /* setsockopt( int, int, int, M caddr_t,int) */
  783.     case CONDOR_getsockopt:        /* getsockopt( int, int, int,
  784.                                     R caddr_t, VR int * )                    */
  785.     case CONDOR_socketpair:        /* socketpair( int, int, int, R int[2] )     */
  786.     case CONDOR_bind:            /* bind( int, sockaddr *, int )              */
  787.     case CONDOR_connect:        /* connect( int, sockaddr *, int )           */
  788.     case CONDOR_mount:            /* mount( int, str, int,
  789.                                         MU caddr_t )                         */
  790.     case CONDOR_accept:            /* accept( int, R sockaddr *, VR int * )     */
  791.     case CONDOR_getsockname:    /* getsockname( int, R sockaddr *, VR int * )*/
  792.  
  793.     case CONDOR_getpeername:    /* getpeername( int, R sockaddr *, VR int * )*/
  794.  
  795.  
  796.     /*
  797.     **    System calls with (as yet) unknown arguments
  798.     */
  799.     case CONDOR_exportfs:
  800.     case CONDOR_getdopt:
  801.     case CONDOR_getfh:
  802.     case CONDOR_madvise:
  803.     case CONDOR_mincore:
  804.     case CONDOR_mmap:
  805.     case CONDOR_mprotect:
  806.     case CONDOR_mremap:
  807.     case CONDOR_munmap:
  808.     case CONDOR_setdopt:
  809.     case CONDOR_sstk:
  810.         sprintf(ErrBuf, "ERROR: %s is a currently unsupported system call\n",
  811.             CONDOR_SYSCALLNAME(condor_sysnum));
  812.         dprintf(D_ALWAYS, "%s\n", ErrBuf);
  813.         fprintf(stderr, "%s\n", ErrBuf);
  814.         errno = ESYSNOTSUPP;
  815.         rval = -1;
  816.         goto RETURN;
  817.  
  818.     default:
  819.         sprintf(ErrBuf, "ERROR: %d is an unknown system call number\n",
  820.             condor_sysnum);
  821.         dprintf(D_ALWAYS, "%s\n", ErrBuf);
  822.         fprintf(stderr, "%s\n", ErrBuf);
  823.         errno = ESYSNOTSUPP;
  824.         rval = -1;
  825.         goto RETURN;
  826.     }
  827. #endif ! CONDOR
  828.  
  829. RETURN:
  830.     va_end(pvar);
  831.  
  832.     SyscallInProgress = 0;
  833.     if( CkptWanted ) {
  834.         dprintf(D_ALWAYS, "REMOTE_syscall: [%s] completed, checkpoint wanted\n",
  835.                 CONDOR_SYSCALLNAME(CurrentSysCall));
  836.         ckpt();
  837.     }
  838.  
  839.     return( rval );
  840. }
  841.  
  842. #ifdef CONDOR
  843.  
  844. static
  845. XDR_Read( iohandle, buf, len )
  846. int *iohandle;
  847. char *buf;
  848. u_int len;
  849. {
  850.     register int scm = SetSyscalls( SYS_LOCAL | SYS_UNRECORDED );
  851.     int cnt;
  852.  
  853.     dprintf(D_XDR, "XDR_Read: about to read(%d, 0x%x, %d)\n",
  854.             *iohandle, buf, len);
  855.  
  856.     cnt = read(*iohandle, buf, len);
  857.     if( cnt == 0 ) {
  858.         dprintf(D_XDR, "XDR_Read: cnt was zero, returning -1\n");
  859.         cnt = -1;
  860.     }
  861.  
  862.     dprintf(D_XDR, "XDR_Read: cnt = %d\n", cnt);
  863.  
  864.     (void) SetSyscalls( scm );
  865.  
  866.     return( cnt );
  867. }
  868.  
  869. static
  870. XDR_Write( iohandle, buf, len )
  871. int *iohandle;
  872. char *buf;
  873. u_int len;
  874. {
  875.     register int scm = SetSyscalls( SYS_LOCAL | SYS_UNRECORDED );
  876.     int cnt;
  877.  
  878.     dprintf(D_XDR, "XDR_Write: about to write(%d, 0x%x, %d)\n",
  879.             *iohandle, buf, len);
  880.  
  881.     cnt = write( *iohandle, buf, len );
  882.  
  883.     dprintf(D_XDR, "XDR_Write: cnt = %d\n", cnt);
  884.  
  885.     if( cnt != len ) {
  886.         EXCEPT("write(%d, 0x%x, %d) returned %d", *iohandle, buf, len, cnt);
  887.     }
  888.  
  889.     (void) SetSyscalls( scm );
  890.  
  891.     return( cnt );
  892. }
  893.  
  894. #endif CONDOR
  895.