home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume25 / trash / part05 / generic.c
Encoding:
C/C++ Source or Header  |  1992-03-22  |  27.6 KB  |  1,945 lines
  1. #include        "register.h"
  2. #include        "symtab.h"
  3. #include        "diblock.h"
  4. #include        "instrn.h"
  5. #include        "process.h"
  6. #include        "res.h"
  7.  
  8. extern int        bufset();
  9. extern int        fd_close();
  10. extern int        fd_invalid();
  11. extern int        fd_lookup();
  12. extern int        fd_open();
  13. extern int        mgets();
  14. extern int        dmget();
  15. extern int        mget();
  16. extern int        dmput();
  17. extern int        mput();
  18.  
  19. extern int        errno;
  20.  
  21. extern unsigned long    arg[];
  22.  
  23. extern int        return_errno;    /* errno goes here. */
  24. extern long        return_value0;    /* Result 1 value goes here. */
  25. extern long        return_value1;    /* Result 2 value goes here. */
  26.  
  27. extern char        *sys_call_buf;    /* Scratch buf. */
  28.  
  29. int
  30. generic_accept(syscallno)
  31. int    syscallno;
  32. {
  33.     int    addrlen;
  34.     void    *addrlenp;
  35.     void    *addrp;
  36.  
  37.     addrlen = 0;
  38.  
  39.     if (mget(arg[2], &addrlen, sizeof(addrlen), &addrlenp) == -1)
  40.         return -1;
  41.  
  42.     if (dmget(arg[1], addrlen, &addrp) == -1)
  43.         return -1;
  44.  
  45.     Rstart;
  46.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), addrp, addrlenp);
  47.     return_errno = errno;
  48.     Rstop;
  49.  
  50.     if (return_value0 != -1)
  51.         return_value0 = fd_open(return_value0);
  52.  
  53.     if (dmput(arg[1], addrp, addrlen, return_value0) == -1)
  54.         return -1;
  55.  
  56.     if (mput(arg[2], addrlenp, sizeof(addrlen), return_value0) == -1)
  57.         return -1;
  58.  
  59.     return 0;
  60. }
  61.  
  62. int
  63. generic_access(syscallno)
  64. int    syscallno;
  65. {
  66.     char    *cp;
  67.  
  68.     if (mgets(arg[0], &cp) == -1)
  69.         return -1;
  70.  
  71.     Rstart;
  72.     return_value0 = syscall(syscallno, cp, (int)arg[1]);
  73.     return_errno = errno;
  74.     Rstop;
  75.  
  76.     return 0;
  77. }
  78.  
  79. int
  80. generic_acct(syscallno)
  81. int    syscallno;
  82. {
  83.     char    *cp;
  84.  
  85.     if (mgets(arg[0], &cp) == -1)
  86.         return -1;
  87.  
  88.     Rstart;
  89.     return_value0 = syscall(syscallno, cp);
  90.     return_errno = errno;
  91.     Rstop;
  92.  
  93.     return 0;
  94. }
  95.  
  96. int
  97. generic_adjtime(syscallno, tv, tvz, otv, otvz)
  98. int    syscallno;
  99. void    *tv;
  100. int    tvz;
  101. void    *otv;
  102. int    otvz;
  103. {
  104.     void    *tvp;
  105.     void    *otvp;
  106.  
  107.     if (mget(arg[0], tv, tvz, &tvp) == -1)
  108.         return -1;
  109.  
  110.     if (mget(arg[1], otv, otvz, &otvp) == -1)
  111.         return -1;
  112.  
  113.     Rstart;
  114.     return_value0 = syscall(syscallno, tvp, otvp);
  115.     return_errno = errno;
  116.     Rstop;
  117.  
  118.     if (mput(arg[1], otvp, otvz, return_value0) == -1)
  119.         return -1;
  120.  
  121.     if (mput(arg[0], tvp, tvz, return_value0) == -1)
  122.         return -1;
  123.  
  124.     return 0;
  125. }
  126.  
  127. int
  128. generic_alarm(syscallno)
  129. int    syscallno;
  130. {
  131.     Rstart;
  132.     return_value0 = syscall(syscallno, (int)arg[0]);
  133.     return_errno = errno;
  134.     Rstop;
  135.  
  136.     return 0;
  137. }
  138.  
  139. int
  140. generic_async_daemon(syscallno)
  141. int    syscallno;
  142. {
  143.     Rstart;
  144.     return_value0 = syscall(syscallno);
  145.     return_errno = errno;
  146.     Rstop;
  147.  
  148.     return 0;
  149. }
  150.  
  151. int
  152. generic_bind(syscallno)
  153. int    syscallno;
  154. {
  155.     int    namelen;
  156.     void    *namep;
  157.  
  158.     namelen = arg[2];
  159.  
  160.     if (dmget(arg[1], namelen, &namep) == -1)
  161.         return -1;
  162.  
  163.     Rstart;
  164.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), namep, namelen);
  165.     return_errno = errno;
  166.     Rstop;
  167.  
  168.     if (dmput(arg[1], namep, namelen, return_value0) == -1)
  169.         return -1;
  170.  
  171.     return 0;
  172. }
  173.  
  174. int
  175. generic_brk(syscallno)
  176. int    syscallno;
  177. {
  178.     if (quiet_procbreakget(&return_value1) == -1)
  179.         return -1;
  180.  
  181.     if (quiet_procbreakput(arg[0]) == -1)
  182.         return -1;
  183.  
  184.     return_value0 = 0;
  185.     return_errno = 0;
  186.  
  187.     return 0;
  188. }
  189.  
  190. int
  191. generic_cachectl(syscallno)
  192. int    syscallno;
  193. {
  194.     /*
  195.      * TODO: check args to cachectl.
  196.      *
  197.     Rstart;
  198.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  199.     return_errno = errno;
  200.     Rstop;
  201.      */
  202.  
  203.     return 0;
  204. }
  205.  
  206. int
  207. generic_cacheflush(syscallno)
  208. int    syscallno;
  209. {
  210.     /*
  211.      * TODO: check args to cacheflush.
  212.      *
  213.     Rstart;
  214.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  215.     return_errno = errno;
  216.     Rstop;
  217.      */
  218.  
  219.     return 0;
  220. }
  221.  
  222. int
  223. generic_chdir(syscallno)
  224. int    syscallno;
  225. {
  226.     char    *cp;
  227.  
  228.     if (mgets(arg[0], &cp) == -1)
  229.         return -1;
  230.  
  231.     Rstart;
  232.     return_value0 = syscall(syscallno, cp);
  233.     return_errno = errno;
  234.     Rstop;
  235.  
  236.     return 0;
  237. }
  238.  
  239. int
  240. generic_chmod(syscallno)
  241. int    syscallno;
  242. {
  243.     char    *cp;
  244.  
  245.     if (mgets(arg[0], &cp) == -1)
  246.         return -1;
  247.  
  248.     Rstart;
  249.     return_value0 = syscall(syscallno, cp, (int)arg[1]);
  250.     return_errno = errno;
  251.     Rstop;
  252.  
  253.     return 0;
  254. }
  255.  
  256. int
  257. generic_chown(syscallno)
  258. int    syscallno;
  259. {
  260.     char    *cp;
  261.  
  262.     if (mgets(arg[0], &cp) == -1)
  263.         return -1;
  264.  
  265.     Rstart;
  266.     return_value0 = syscall(syscallno, cp, (int)arg[1], (int)arg[2]);
  267.     return_errno = errno;
  268.     Rstop;
  269.  
  270.     return 0;
  271. }
  272.  
  273. int
  274. generic_chroot(syscallno)
  275. int    syscallno;
  276. {
  277.     char    *cp;
  278.  
  279.     if (mgets(arg[0], &cp) == -1)
  280.         return -1;
  281.  
  282.     Rstart;
  283.     return_value0 = syscall(syscallno, cp);
  284.     return_errno = errno;
  285.     Rstop;
  286.  
  287.     return 0;
  288. }
  289.  
  290. int
  291. generic_close(syscallno)
  292. int    syscallno;
  293. {
  294.     Rstart;
  295.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]));
  296.     return_errno = errno;
  297.     Rstop;
  298.  
  299.     return fd_close((int)arg[0]);
  300. }
  301.  
  302. int
  303. generic_connect(syscallno)
  304. int    syscallno;
  305. {
  306.     int    namelen;
  307.     void    *namep;
  308.  
  309.     namelen = arg[2];
  310.  
  311.     if (dmget(arg[1], namelen, &namep) == -1)
  312.         return -1;
  313.  
  314.     Rstart;
  315.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), namep, namelen);
  316.     return_errno = errno;
  317.     Rstop;
  318.  
  319.     if (dmput(arg[1], namep, namelen, return_value0) == -1)
  320.         return -1;
  321.  
  322.     return 0;
  323. }
  324.  
  325. int
  326. generic_creat(syscallno)
  327. int    syscallno;
  328. {
  329.     char    *cp;
  330.  
  331.     if (mgets(arg[0], &cp) == -1)
  332.         return -1;
  333.  
  334.     Rstart;
  335.     return_value0 = syscall(syscallno, cp, (int)arg[1]);
  336.     return_errno = errno;
  337.     Rstop;
  338.  
  339.     if (return_value0 != -1)
  340.     {
  341.         if ((return_value0 = fd_open(return_value0)) == -1)
  342.             return -1;
  343.     }
  344.  
  345.     return 0;
  346. }
  347.  
  348. int
  349. generic_dup(syscallno)
  350. int    syscallno;
  351. {
  352.     Rstart;
  353.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]));
  354.     return_errno = errno;
  355.     Rstop;
  356.  
  357.     if (return_value0 != -1)
  358.     {
  359.         if ((return_value0 = fd_open(return_value0)) == -1)
  360.             return -1;
  361.     }
  362.  
  363.     return 0;
  364. }
  365.  
  366. int
  367. generic_exit(syscallno)
  368. int    syscallno;
  369. {
  370.     histo_dump();
  371.     hist_dump();
  372.  
  373.     (void)procclose();
  374.  
  375. #if    defined(PIXIE)
  376.     exit((int)arg[0]);
  377. #else    /* defined(PIXIE) */
  378.     syscall(syscallno, (int)arg[0]);
  379. #endif    /* defined(PIXIE) */
  380. }
  381.  
  382. int
  383. generic_fchmod(syscallno)
  384. int    syscallno;
  385. {
  386.     Rstart;
  387.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  388.     return_errno = errno;
  389.     Rstop;
  390.  
  391.     return 0;
  392. }
  393.  
  394. int
  395. generic_fchown(syscallno)
  396. int    syscallno;
  397. {
  398.     Rstart;
  399.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1], (int)arg[2]);
  400.     return_errno = errno;
  401.     Rstop;
  402.  
  403.     return 0;
  404. }
  405.  
  406. int
  407. generic_flock(syscallno)
  408. int    syscallno;
  409. {
  410.     Rstart;
  411.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1]);
  412.     return_errno = errno;
  413.     Rstop;
  414.  
  415.     return 0;
  416. }
  417.  
  418. int
  419. generic_fork(syscallno)
  420. int    syscallno;
  421. {
  422.     int    parent_pid;
  423.  
  424.     parent_pid = getpid();
  425.  
  426.     errno = 0;
  427.  
  428.     Rstart;
  429.     return_value0 = syscall(syscallno);
  430.     return_errno = errno;
  431.     Rstop;
  432.  
  433.     if ((P.p_pid = getpid()) != parent_pid)
  434.         return_value0 = 0;
  435.  
  436.     switch (return_value0)
  437.     {
  438.     case -1:    /* error */
  439.         break;
  440.  
  441.     case 0:        /* child */
  442.         return_value1 = 1;
  443.         break;
  444.  
  445.     default:    /* parent */
  446.         return_value1 = 0;
  447.         break;
  448.     }
  449.  
  450.     return 0;
  451. }
  452.  
  453. int
  454. generic_fstat(syscallno, sbufz)
  455. int    syscallno;
  456. int    sbufz;
  457. {
  458.     void    *sbufp;
  459.  
  460.     if (dmget(arg[1], sbufz, &sbufp) == -1)
  461.         return -1;
  462.  
  463.     Rstart;
  464.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), sbufp);
  465.     return_errno = errno;
  466.     Rstop;
  467.  
  468.     if (dmput(arg[1], sbufp, sbufz, return_value0) == -1)
  469.         return -1;
  470.  
  471.     return 0;
  472. }
  473.  
  474. int
  475. generic_fsync(syscallno)
  476. int    syscallno;
  477. {
  478.     Rstart;
  479.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]));
  480.     return_errno = errno;
  481.     Rstop;
  482.  
  483.     return 0;
  484. }
  485.  
  486. int
  487. generic_ftruncate(syscallno)
  488. int    syscallno;
  489. {
  490.     Rstart;
  491.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), arg[1]);
  492.     return_errno = errno;
  493.     Rstop;
  494.  
  495.     return 0;
  496. }
  497.  
  498. int
  499. generic_getdents(syscallno)
  500. int    syscallno;
  501. {
  502.     int    nbyte;
  503.     char    *buf;
  504.  
  505.     nbyte = arg[2];
  506.  
  507.     if (dmget(arg[1], nbyte, &buf) == -1)
  508.         return -1;
  509.  
  510.     Rstart;
  511.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), buf, nbyte);
  512.     return_errno = errno;
  513.     Rstop;
  514.  
  515.     if (dmput(arg[1], buf, nbyte, return_value0) == -1)
  516.         return -1;
  517.  
  518.     return 0;
  519. }
  520.  
  521. int
  522. generic_getdirentries(syscallno)
  523. int    syscallno;
  524. {
  525.     int    nbytes;
  526.     char    *bufp;
  527.     long    base;
  528.     long    *basep;
  529.  
  530.     nbytes = arg[2];
  531.  
  532.     if (dmget(arg[1], nbytes, &bufp) == -1)
  533.         return -1;
  534.  
  535.     if (mget(arg[3], &base, sizeof(base), &basep) == -1)
  536.         return -1;
  537.  
  538.     Rstart;
  539.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), bufp, nbytes, basep);
  540.     return_errno = errno;
  541.     Rstop;
  542.  
  543.     if (mput(arg[3], basep, sizeof(base), return_value0) == -1)
  544.         return -1;
  545.  
  546.     if (dmput(arg[1], bufp, return_value0, return_value0) == -1)
  547.         return -1;
  548.  
  549.     return 0;
  550. }
  551.  
  552. int
  553. generic_getdomainname(syscallno)
  554. int    syscallno;
  555. {
  556.     int    namelen;
  557.     char    *name;
  558.  
  559.     namelen = arg[1];
  560.  
  561.     if (dmget(arg[0], namelen, &name) == -1)
  562.         return -1;
  563.  
  564.     Rstart;
  565.     return_value0 = syscall(syscallno, name, namelen);
  566.     return_errno = errno;
  567.     Rstop;
  568.  
  569.     if (dmput(arg[0], name, namelen, return_value0) == -1)
  570.         return -1;
  571.  
  572.     return 0;
  573. }
  574.  
  575. int
  576. generic_getdtablesize(syscallno)
  577. int    syscallno;
  578. {
  579.     Rstart;
  580.     return_value0 = syscall(syscallno);
  581.     return_errno = errno;
  582.     Rstop;
  583.  
  584.     return 0;
  585. }
  586.  
  587. int
  588. generic_getgroups(syscallno, maxngroups)
  589. int    syscallno;
  590. int    maxngroups;
  591. {
  592.     int    gidsetlen;
  593.     int    *gidsetp;
  594.  
  595.     gidsetlen = (int)arg[0];
  596.  
  597.     if (gidsetlen < 0)
  598.         gidsetlen = 0;
  599.     else if (gidsetlen > maxngroups)
  600.         gidsetlen = maxngroups;
  601.  
  602.     if (dmget(arg[1], gidsetlen * sizeof(int), &gidsetp) == -1)
  603.         return -1;
  604.  
  605.     Rstart;
  606.     return_value0 = syscall(syscallno, gidsetlen, gidsetp);
  607.     return_errno = errno;
  608.     Rstop;
  609.  
  610.     if (dmput(arg[1], gidsetp, return_value0 * sizeof(int), return_value0) == -1)
  611.         return -1;
  612.  
  613.     return 0;
  614. }
  615.  
  616. int
  617. generic_gethostid(syscallno)
  618. int    syscallno;
  619. {
  620.     Rstart;
  621.     return_value0 = syscall(syscallno);
  622.     return_errno = errno;
  623.     Rstop;
  624.  
  625.     return 0;
  626. }
  627.  
  628. int
  629. generic_gethostname(syscallno)
  630. int    syscallno;
  631. {
  632.     int    namelen;
  633.     char    *name;
  634.  
  635.     namelen = arg[1];
  636.  
  637.     if (dmget(arg[0], namelen, &name) == -1)
  638.         return -1;
  639.  
  640.     Rstart;
  641.     return_value0 = syscall(syscallno, name, namelen);
  642.     return_errno = errno;
  643.     Rstop;
  644.  
  645.     if (dmput(arg[0], name, namelen, return_value0) == -1)
  646.         return -1;
  647.  
  648.     return 0;
  649. }
  650.  
  651. int
  652. generic_getitimer(syscallno, itimervalz)
  653. int    syscallno;
  654. int    itimervalz;
  655. {
  656.     void    *itimervalp;
  657.  
  658.     if (dmget(arg[1], itimervalz, &itimervalp) == -1)
  659.         return -1;
  660.  
  661.     Rstart;
  662.     return_value0 = syscall(syscallno, (int)arg[0], itimervalp);
  663.     return_errno = errno;
  664.     Rstop;
  665.  
  666.     if (dmput(arg[1], itimervalp, itimervalz, return_value0) == -1)
  667.         return -1;
  668.  
  669.     return 0;
  670. }
  671.  
  672. int
  673. generic_getpagesize(syscallno)
  674. int    syscallno;
  675. {
  676.     Rstart;
  677.     return_value0 = syscall(syscallno);
  678.     return_errno = errno;
  679.     Rstop;
  680.  
  681.     return 0;
  682. }
  683.  
  684. int
  685. generic_getpeername(syscallno)
  686. int    syscallno;
  687. {
  688.     int    namelen;
  689.     void    *namelenp;
  690.     void    *namep;
  691.  
  692.     namelen = 0;
  693.  
  694.     if (mget(arg[2], &namelen, sizeof(namelen), &namelenp) == -1)
  695.         return -1;
  696.  
  697.     if (dmget(arg[1], namelen, &namep) == -1)
  698.         return -1;
  699.  
  700.     Rstart;
  701.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), namep, namelenp);
  702.     return_errno = errno;
  703.     Rstop;
  704.  
  705.     if (dmput(arg[1], namep, namelen, return_value0) == -1)
  706.         return -1;
  707.  
  708.     if (mput(arg[2], namelenp, sizeof(namelen), return_value0) == -1)
  709.         return -1;
  710.  
  711.     return 0;
  712. }
  713.  
  714. int
  715. generic_getpid(syscallno)
  716. int    syscallno;
  717. {
  718.     Rstart;
  719.     return_value0 = syscall(syscallno);
  720.     return_errno = errno;
  721.     Rstop;
  722.  
  723.     return 0;
  724. }
  725.  
  726. int
  727. generic_getpriority(syscallno)
  728. int    syscallno;
  729. {
  730.     Rstart;
  731.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  732.     return_errno = errno;
  733.     Rstop;
  734.  
  735.     return 0;
  736. }
  737.  
  738. int
  739. generic_getrlimit(syscallno, rlimitz)
  740. int    syscallno;
  741. int    rlimitz;
  742. {
  743.     void    *rlimitp;
  744.  
  745.     if (dmget(arg[1], rlimitz, &rlimitp) == -1)
  746.         return -1;
  747.  
  748.     Rstart;
  749.     return_value0 = syscall(syscallno, arg[0], rlimitp);
  750.     return_errno = errno;
  751.     Rstop;
  752.  
  753.     if (dmput(arg[1], rlimitp, rlimitz, return_value0) == -1)
  754.         return -1;
  755.  
  756.     return 0;
  757. }
  758.  
  759. int
  760. generic_getrusage(syscallno, rusagez)
  761. int    syscallno;
  762. int    rusagez;
  763. {
  764.     void    *rusagep;
  765.  
  766.     if (dmget(arg[1], rusagez, &rusagep) == -1)
  767.         return -1;
  768.  
  769.     Rstart;
  770.     return_value0 = syscall(syscallno, arg[0], rusagep);
  771.     return_errno = errno;
  772.     Rstop;
  773.  
  774.     if (dmput(arg[1], rusagep, rusagez, return_value0) == -1)
  775.         return -1;
  776.  
  777.     return 0;
  778. }
  779.  
  780. int
  781. generic_gettimeofday(syscallno, tv, tvz, tz, tzz)
  782. int    syscallno;
  783. void    *tv;
  784. int    tvz;
  785. void    *tz;
  786. int    tzz;
  787. {
  788.     void    *tvp;
  789.     void    *tzp;
  790.  
  791.     if (mget(arg[0], tv, tvz, &tvp) == -1)
  792.         return -1;
  793.  
  794.     if (mget(arg[1], tz, tzz, &tzp) == -1)
  795.         return -1;
  796.  
  797.     Rstart;
  798.     return_value0 = syscall(syscallno, tvp, tzp);
  799.     return_errno = errno;
  800.     Rstop;
  801.  
  802.     if (mput(arg[1], tzp, tzz, return_value0) == -1)
  803.         return -1;
  804.  
  805.     if (mput(arg[0], tvp, tvz, return_value0) == -1)
  806.         return -1;
  807.  
  808.     return 0;
  809. }
  810.  
  811. int
  812. generic_getsockname(syscallno)
  813. int    syscallno;
  814. {
  815.     int    namelen;
  816.     void    *namelenp;
  817.     void    *namep;
  818.  
  819.     namelen = 0;
  820.  
  821.     if (mget(arg[2], &namelen, sizeof(namelen), &namelenp) == -1)
  822.         return -1;
  823.  
  824.     if (dmget(arg[1], namelen, &namep) == -1)
  825.         return -1;
  826.  
  827.     Rstart;
  828.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), namep, namelenp);
  829.     return_errno = errno;
  830.     Rstop;
  831.  
  832.     if (dmput(arg[1], namep, namelen, return_value0) == -1)
  833.         return -1;
  834.  
  835.     if (mput(arg[2], namelenp, sizeof(namelen), return_value0) == -1)
  836.         return -1;
  837.  
  838.     return 0;
  839. }
  840.  
  841. int
  842. generic_getsockopt(syscallno)
  843. int    syscallno;
  844. {
  845.     int    optlen;
  846.     int    *optlenp;
  847.     char    *optvalp;
  848.  
  849.     optlen = 0;
  850.  
  851.     if (mget(arg[4], &optlen, sizeof(optlen), &optlenp) == -1)
  852.         return -1;
  853.  
  854.     if (dmget(arg[3], optlen, &optvalp) == -1)
  855.         return -1;
  856.  
  857.     Rstart;
  858.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1], (int)arg[2], optvalp, optlenp);
  859.     return_errno = errno;
  860.     Rstop;
  861.  
  862.     if (dmput(arg[3], optvalp, optlen, return_value0) == -1)
  863.         return -1;
  864.  
  865.     if (mput(arg[4], optlenp, sizeof(optlen), return_value0) == -1)
  866.         return -1;
  867.  
  868.     return 0;
  869. }
  870.  
  871. int
  872. generic_kill(syscallno)
  873. int    syscallno;
  874. {
  875.     Rstart;
  876.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  877.     return_errno = errno;
  878.     Rstop;
  879.  
  880.     return 0;
  881. }
  882.  
  883. int
  884. generic_killpg(syscallno)
  885. int    syscallno;
  886. {
  887.     Rstart;
  888.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  889.     return_errno = errno;
  890.     Rstop;
  891.  
  892.     return 0;
  893. }
  894.  
  895. int
  896. generic_link(syscallno)
  897. int    syscallno;
  898. {
  899.     char    *cp;
  900.     char    name1[1024];
  901.     char    *name1p;
  902.  
  903.     if (mgets(arg[0], &name1p) == -1)
  904.         return -1;
  905.  
  906.     if (name1p != (char *)0)
  907.     {
  908.         (void)strcpy(&name1[0], name1p);
  909.         name1p = &name1[0];
  910.     }
  911.  
  912.     if (mgets(arg[1], &cp) == -1)
  913.         return -1;
  914.  
  915.     Rstart;
  916.     return_value0 = syscall(syscallno, name1p, cp);
  917.     return_errno = errno;
  918.     Rstop;
  919.  
  920.     return 0;
  921. }
  922.  
  923. int
  924. generic_listen(syscallno)
  925. int    syscallno;
  926. {
  927.     Rstart;
  928.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1]);
  929.     return_errno = errno;
  930.     Rstop;
  931.  
  932.     return 0;
  933. }
  934.  
  935. int
  936. generic_lseek(syscallno)
  937. int    syscallno;
  938. {
  939.     Rstart;
  940.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), arg[1], (int)arg[2]);
  941.     return_errno = errno;
  942.     Rstop;
  943.  
  944.     return 0;
  945. }
  946.  
  947. int
  948. generic_lstat(syscallno, statb, statbz)
  949. int    syscallno;
  950. void    *statb;
  951. int    statbz;
  952. {
  953.     char    *cp;
  954.     void    *statbp;
  955.  
  956.     if (mgets(arg[0], &cp) == -1)
  957.         return -1;
  958.  
  959.     if (mget(arg[1], statb, statbz, &statbp) == -1)
  960.         return -1;
  961.  
  962.     Rstart;
  963.     return_value0 = syscall(syscallno, cp, statbp);
  964.     return_errno = errno;
  965.     Rstop;
  966.  
  967.     if (mput(arg[1], statbp, statbz, return_value0) == -1)
  968.         return -1;
  969.  
  970.     return 0;
  971. }
  972.  
  973. int
  974. generic_mkdir(syscallno)
  975. int    syscallno;
  976. {
  977.     char    *cp;
  978.  
  979.     if (mgets(arg[0], &cp) == -1)
  980.         return -1;
  981.  
  982.     Rstart;
  983.     return_value0 = syscall(syscallno, cp, (int)arg[1]);
  984.     return_errno = errno;
  985.     Rstop;
  986.  
  987.     return 0;
  988. }
  989.  
  990. int
  991. generic_mknod(syscallno)
  992. int    syscallno;
  993. {
  994.     char    *cp;
  995.  
  996.     if (mgets(arg[0], &cp) == -1)
  997.         return -1;
  998.  
  999.     Rstart;
  1000.     return_value0 = syscall(syscallno, cp, (int)arg[1], (int)arg[2]);
  1001.     return_errno = errno;
  1002.     Rstop;
  1003.  
  1004.     return 0;
  1005. }
  1006.  
  1007. int
  1008. generic_nfssvc(syscallno)
  1009. int    syscallno;
  1010. {
  1011.     Rstart;
  1012.     return_value0 = syscall(syscallno, arg[0]);
  1013.     return_errno = errno;
  1014.     Rstop;
  1015.  
  1016.     return 0;
  1017. }
  1018.  
  1019. int
  1020. generic_nice(syscallno)
  1021. int    syscallno;
  1022. {
  1023.     Rstart;
  1024.     return_value0 = syscall(syscallno, (int)arg[0]);
  1025.     return_errno = errno;
  1026.     Rstop;
  1027.  
  1028.     return 0;
  1029. }
  1030.  
  1031. int
  1032. generic_open(syscallno)
  1033. int    syscallno;
  1034. {
  1035.     char    *cp;
  1036.  
  1037.     if (mgets(arg[0], &cp) == -1)
  1038.         return -1;
  1039.  
  1040.     Rstart;
  1041.     return_value0 = syscall(syscallno, cp, (int)arg[1], (int)arg[2]);
  1042.     return_errno = errno;
  1043.     Rstop;
  1044.  
  1045.     if (return_value0 != -1)
  1046.         return_value0 = fd_open(return_value0);
  1047.  
  1048.     return 0;
  1049. }
  1050.  
  1051. int
  1052. generic_pause(syscallno)
  1053. int    syscallno;
  1054. {
  1055.     Rstart;
  1056.     return_value0 = syscall(syscallno);
  1057.     return_errno = errno;
  1058.     Rstop;
  1059.  
  1060.     return 0;
  1061. }
  1062.  
  1063. int
  1064. generic_plock(syscallno)
  1065. int    syscallno;
  1066. {
  1067.     Rstart;
  1068.     return_value0 = syscall(syscallno, (int)arg[0]);
  1069.     return_errno = errno;
  1070.     Rstop;
  1071.  
  1072.     return 0;
  1073. }
  1074.  
  1075. int
  1076. generic_profil(syscallno)
  1077. int    syscallno;
  1078. {
  1079.     /*
  1080.      * TODO -- pseudo-profiling
  1081.      */
  1082.     return_value0 = 0;
  1083.     return_errno = 0;
  1084.  
  1085.     return 0;
  1086. }
  1087.  
  1088. int
  1089. generic_ptrace(syscallno)
  1090. int    syscallno;
  1091. {
  1092.     Rstart;
  1093.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2], (int)arg[3]);
  1094.     return_errno = errno;
  1095.     Rstop;
  1096.  
  1097.     return 0;
  1098. }
  1099.  
  1100. int
  1101. generic_read(syscallno)
  1102. int    syscallno;
  1103. {
  1104.     int    nbyte;
  1105.     char    *buf;
  1106.  
  1107.     /*
  1108.      * It seems that some programs rely on this
  1109.      * error being detected before some others
  1110.      * (specifically, an illegal buffer address).
  1111.      */
  1112.     if (fd_invalid((int)arg[0]))
  1113.     {
  1114.         return_value0 = -1;
  1115.         return_errno = errno;
  1116.  
  1117.         return 0;
  1118.     }
  1119.  
  1120.     nbyte = arg[2];
  1121.  
  1122.     if (dmget(arg[1], nbyte, &buf) == -1)
  1123.         return -1;
  1124.  
  1125.     Rstart;
  1126.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), buf, nbyte);
  1127.     return_errno = errno;
  1128.     Rstop;
  1129.  
  1130.     if (dmput(arg[1], buf, return_value0, return_value0) == -1)
  1131.         return -1;
  1132.  
  1133.     return 0;
  1134. }
  1135.  
  1136. int
  1137. generic_readlink(syscallno)
  1138. int    syscallno;
  1139. {
  1140.     char    *pathp;
  1141.     char    path[1024];
  1142.     char    *buf;
  1143.     int    bufsiz;
  1144.  
  1145.     if (mgets(arg[0], &pathp) == -1)
  1146.         return -1;
  1147.  
  1148.     if (pathp != (char *)0)
  1149.     {
  1150.         (void)strcpy(&path[0], pathp);
  1151.         pathp = &path[0];
  1152.     }
  1153.  
  1154.     bufsiz = arg[2];
  1155.  
  1156.     if (bufset(bufsiz) == -1)
  1157.         return -1;
  1158.  
  1159.     if (mget(arg[1], sys_call_buf, bufsiz, &buf) == -1)
  1160.         return -1;
  1161.  
  1162.     Rstart;
  1163.     return_value0 = syscall(syscallno, pathp, buf, bufsiz);
  1164.     return_errno = errno;
  1165.     Rstop;
  1166.  
  1167.     if (mput(arg[1], buf, return_value0, return_value0) == -1)
  1168.         return -1;
  1169.  
  1170.     return 0;
  1171. }
  1172.  
  1173. int
  1174. generic_recv(syscallno)
  1175. int    syscallno;
  1176. {
  1177.     int    len;
  1178.     char    *buf;
  1179.  
  1180.     len = arg[2];
  1181.  
  1182.     if (dmget(arg[1], len, &buf) == -1)
  1183.         return -1;
  1184.  
  1185.     Rstart;
  1186.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), buf, len, (int)arg[3]);
  1187.     return_errno = errno;
  1188.     Rstop;
  1189.  
  1190.     if (dmput(arg[1], buf, return_value0, return_value0) == -1)
  1191.         return -1;
  1192.  
  1193.     return 0;
  1194. }
  1195.  
  1196. int
  1197. generic_recvfrom(syscallno, from)
  1198. int    syscallno;
  1199. void    *from;
  1200. {
  1201.     int    len;
  1202.     char    *buf;
  1203.     void    *fromp;
  1204.     int    fromlen;
  1205.     int    *fromlenp;
  1206.  
  1207.     len = arg[2];
  1208.  
  1209.     if (dmget(arg[1], len, &buf) == -1)
  1210.         return -1;
  1211.  
  1212.     fromlen = 0;
  1213.  
  1214.     if (mget(arg[5], &fromlen, sizeof(fromlen), &fromlenp) == -1)
  1215.         return -1;
  1216.  
  1217.     if (mget(arg[4], from, fromlen, &fromp) == -1)
  1218.         return -1;
  1219.  
  1220.     Rstart;
  1221.     return_value0 =
  1222.     syscall
  1223.     (
  1224.         syscallno,
  1225.         fd_lookup((int)arg[0]),
  1226.         buf,
  1227.         len,
  1228.         (int)arg[3],
  1229.         fromp,
  1230.         fromlenp
  1231.     );
  1232.     return_errno = errno;
  1233.     Rstop;
  1234.  
  1235.     if (mput(arg[4], fromp, fromlen, return_value0) == -1)
  1236.         return -1;
  1237.  
  1238.     if (mput(arg[5], fromlenp, sizeof(fromlen), return_value0) == -1)
  1239.         return -1;
  1240.  
  1241.     if (dmput(arg[1], buf, return_value0, return_value0) == -1)
  1242.         return -1;
  1243.  
  1244.     return 0;
  1245. }
  1246.  
  1247. int
  1248. generic_rename(syscallno)
  1249. int    syscallno;
  1250. {
  1251.     char    *fromp;
  1252.     char    fromname[1024];
  1253.     char    *cp;
  1254.  
  1255.     if (mgets(arg[0], &fromp) == -1)
  1256.         return -1;
  1257.  
  1258.     if (fromp != (char *)0)
  1259.     {
  1260.         (void)strcpy(&fromname[0], fromp);
  1261.         fromp = &fromname[0];
  1262.     }
  1263.  
  1264.     if (mgets(arg[1], &cp) == -1)
  1265.         return -1;
  1266.  
  1267.     Rstart;
  1268.     return_value0 = syscall(syscallno, fromp, cp);
  1269.     return_errno = errno;
  1270.     Rstop;
  1271.  
  1272.     return 0;
  1273. }
  1274.  
  1275. int
  1276. generic_rmdir(syscallno)
  1277. int    syscallno;
  1278. {
  1279.     char    *cp;
  1280.  
  1281.     if (mgets(arg[0], &cp) == -1)
  1282.         return -1;
  1283.  
  1284.     Rstart;
  1285.     return_value0 = syscall(syscallno, cp);
  1286.     return_errno = errno;
  1287.     Rstop;
  1288.  
  1289.     return 0;
  1290. }
  1291.  
  1292. int
  1293. generic_send(syscallno)
  1294. int    syscallno;
  1295. {
  1296.     int    len;
  1297.     char    *msg;
  1298.  
  1299.     len = arg[2];
  1300.  
  1301.     if (dmget(arg[1], len, &msg) == -1)
  1302.         return -1;
  1303.  
  1304.     Rstart;
  1305.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), msg, len, (int)arg[3]);
  1306.     return_errno = errno;
  1307.     Rstop;
  1308.  
  1309.     return 0;
  1310. }
  1311.  
  1312. int
  1313. generic_sendto(syscallno, to)
  1314. int    syscallno;
  1315. void    *to;
  1316. {
  1317.     char    *msg;
  1318.     int    len;
  1319.     void    *top;
  1320.     int    tolen;
  1321.  
  1322.     len = arg[2];
  1323.  
  1324.     if (dmget(arg[1], len, &msg) == -1)
  1325.         return -1;
  1326.  
  1327.     tolen = arg[5];
  1328.  
  1329.     if (mget(arg[4], to, tolen, &top) == -1)
  1330.         return -1;
  1331.  
  1332.     Rstart;
  1333.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), msg, len, (int)arg[3], top, tolen);
  1334.     return_errno = errno;
  1335.     Rstop;
  1336.  
  1337.     return 0;
  1338. }
  1339.  
  1340. int
  1341. generic_setdomainname(syscallno)
  1342. int    syscallno;
  1343. {
  1344.     int    namelen;
  1345.     char    *name;
  1346.  
  1347.     namelen = arg[1];
  1348.  
  1349.     if (dmget(arg[0], namelen, &name) == -1)
  1350.         return -1;
  1351.  
  1352.     Rstart;
  1353.     return_value0 = syscall(syscallno, name, namelen);
  1354.     return_errno = errno;
  1355.     Rstop;
  1356.  
  1357.     if (dmput(arg[0], name, namelen, return_value0) == -1)
  1358.         return -1;
  1359.  
  1360.     return 0;
  1361. }
  1362.  
  1363. int
  1364. generic_setgid(syscallno)
  1365. int    syscallno;
  1366. {
  1367.     Rstart;
  1368.     return_value0 = syscall(syscallno, (int)arg[0]);
  1369.     return_errno = errno;
  1370.     Rstop;
  1371.  
  1372.     return 0;
  1373. }
  1374.  
  1375. int
  1376. generic_setgroups(syscallno)
  1377. int    syscallno;
  1378. {
  1379.     int    ngroups;
  1380.     int    *gidset;
  1381.  
  1382.     ngroups = (int)arg[0];
  1383.  
  1384.     if (ngroups < 0)
  1385.         ngroups = 0;
  1386.  
  1387.     if (dmget(arg[1], ngroups * sizeof(int), &gidset) == -1)
  1388.         return -1;
  1389.  
  1390.     Rstart;
  1391.     return_value0 = syscall(syscallno, ngroups, gidset);
  1392.     return_errno = errno;
  1393.     Rstop;
  1394.  
  1395.     return 0;
  1396. }
  1397.  
  1398. int
  1399. generic_sethostid(syscallno)
  1400. int    syscallno;
  1401. {
  1402.     Rstart;
  1403.     return_value0 = syscall(syscallno, arg[0]);
  1404.     return_errno = errno;
  1405.     Rstop;
  1406.  
  1407.     return 0;
  1408. }
  1409.  
  1410. int
  1411. generic_setitimer(syscallno, it, itz, oit, oitz)
  1412. int    syscallno;
  1413. void    *it;
  1414. int    itz;
  1415. void    *oit;
  1416. int    oitz;
  1417. {
  1418.     void    *itp;
  1419.     void    *oitp;
  1420.  
  1421.     if (mget(arg[1], it, itz, &itp) == -1)
  1422.         return -1;
  1423.  
  1424.     if (mget(arg[2], oit, oitz, &oitp) == -1)
  1425.         return -1;
  1426.  
  1427.     Rstart;
  1428.     return_value0 = syscall(syscallno, (int)arg[0], itp, oitp);
  1429.     return_errno = errno;
  1430.     Rstop;
  1431.  
  1432.     if (mput(arg[2], oitp, oitz, return_value0) == -1)
  1433.         return -1;
  1434.  
  1435.     if (mput(arg[1], itp, itz, return_value0) == -1)
  1436.         return -1;
  1437.  
  1438.     return 0;
  1439. }
  1440.  
  1441. int
  1442. generic_setpgid(syscallno)
  1443. int    syscallno;
  1444. {
  1445.     Rstart;
  1446.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  1447.     return_errno = errno;
  1448.     Rstop;
  1449.  
  1450.     return 0;
  1451. }
  1452.  
  1453. int
  1454. generic_setpriority(syscallno)
  1455. int    syscallno;
  1456. {
  1457.     Rstart;
  1458.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  1459.     return_errno = errno;
  1460.     Rstop;
  1461.  
  1462.     return 0;
  1463. }
  1464.  
  1465. int
  1466. generic_setregid(syscallno)
  1467. int    syscallno;
  1468. {
  1469.     Rstart;
  1470.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  1471.     return_errno = errno;
  1472.     Rstop;
  1473.  
  1474.     return 0;
  1475. }
  1476.  
  1477. int
  1478. generic_setreuid(syscallno)
  1479. int    syscallno;
  1480. {
  1481.     Rstart;
  1482.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  1483.     return_errno = errno;
  1484.     Rstop;
  1485.  
  1486.     return 0;
  1487. }
  1488.  
  1489. int
  1490. generic_setrlimit(syscallno, rlimitz)
  1491. int    syscallno;
  1492. int    rlimitz;
  1493. {
  1494.     void    *rlimitp;
  1495.  
  1496.     if (dmget(arg[1], rlimitz, &rlimitp) == -1)
  1497.         return -1;
  1498.  
  1499.     Rstart;
  1500.     return_value0 = syscall(syscallno, arg[0], rlimitp);
  1501.     return_errno = errno;
  1502.     Rstop;
  1503.  
  1504.     if (dmput(arg[1], rlimitp, rlimitz, return_value0) == -1)
  1505.         return -1;
  1506.  
  1507.     return 0;
  1508. }
  1509.  
  1510. int
  1511. generic_setsockopt(syscallno)
  1512. int    syscallno;
  1513. {
  1514.     int    optlen;
  1515.     char    *optval;
  1516.  
  1517.     optlen = arg[4];
  1518.  
  1519.     if (dmget(arg[3], optlen, &optval) == -1)
  1520.         return -1;
  1521.  
  1522.     Rstart;
  1523.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1], (int)arg[2], optval, optlen);
  1524.     return_errno = errno;
  1525.     Rstop;
  1526.  
  1527.     return 0;
  1528. }
  1529.  
  1530. int
  1531. generic_settimeofday(syscallno, tv, tvz, tz, tzz)
  1532. int    syscallno;
  1533. void    *tv;
  1534. int    tvz;
  1535. void    *tz;
  1536. int    tzz;
  1537. {
  1538.     void    *tvp;
  1539.     void    *tzp;
  1540.  
  1541.     if (mget(arg[0], tv, tvz, &tvp) == -1)
  1542.         return -1;
  1543.  
  1544.     if (mget(arg[1], tz, tzz, &tzp) == -1)
  1545.         return -1;
  1546.  
  1547.     Rstart;
  1548.     return_value0 = syscall(syscallno, tvp, tzp);
  1549.     return_errno = errno;
  1550.     Rstop;
  1551.  
  1552.     if (mput(arg[1], tzp, tzz, return_value0) == -1)
  1553.         return -1;
  1554.  
  1555.     if (mput(arg[0], tvp, tvz, return_value0) == -1)
  1556.         return -1;
  1557.  
  1558.     return 0;
  1559. }
  1560.  
  1561. int
  1562. generic_setuid(syscallno)
  1563. int    syscallno;
  1564. {
  1565.     Rstart;
  1566.     return_value0 = syscall(syscallno, (int)arg[0]);
  1567.     return_errno = errno;
  1568.     Rstop;
  1569.  
  1570.     return 0;
  1571. }
  1572.  
  1573. int
  1574. generic_shutdown(syscallno)
  1575. int    syscallno;
  1576. {
  1577.     Rstart;
  1578.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1]);
  1579.     return_errno = errno;
  1580.     Rstop;
  1581.  
  1582.     return 0;
  1583. }
  1584.  
  1585. int
  1586. generic_socket(syscallno)
  1587. int    syscallno;
  1588. {
  1589.     Rstart;
  1590.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  1591.     return_errno = errno;
  1592.     Rstop;
  1593.  
  1594.     if (return_value0 != -1)
  1595.         return_value0 = fd_open(return_value0);
  1596.  
  1597.     return 0;
  1598. }
  1599.  
  1600. int
  1601. generic_socketpair(syscallno)
  1602. int    syscallno;
  1603. {
  1604.     int    *svp;
  1605.  
  1606.     if (dmget(arg[3], 2 * sizeof(*svp), &svp) == -1)
  1607.         return -1;
  1608.  
  1609.     Rstart;
  1610.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2], svp);
  1611.     return_errno = errno;
  1612.     Rstop;
  1613.  
  1614.     if (dmput(arg[3], svp, 2 * sizeof(*svp), return_value0) == -1)
  1615.         return -1;
  1616.  
  1617.     return 0;
  1618. }
  1619.  
  1620. int
  1621. generic_stat(syscallno, statb, statbz)
  1622. int    syscallno;
  1623. void    *statb;
  1624. int    statbz;
  1625. {
  1626.     char    *cp;
  1627.     void    *statbp;
  1628.  
  1629.     if (mgets(arg[0], &cp) == -1)
  1630.         return -1;
  1631.  
  1632.     if (mget(arg[1], statb, statbz, &statbp) == -1)
  1633.         return -1;
  1634.  
  1635.     Rstart;
  1636.     return_value0 = syscall(syscallno, cp, statbp);
  1637.     return_errno = errno;
  1638.     Rstop;
  1639.  
  1640.     if (mput(arg[1], statbp, statbz, return_value0) == -1)
  1641.         return -1;
  1642.  
  1643.     return 0;
  1644. }
  1645.  
  1646. int
  1647. generic_stime(syscallno)
  1648. int    syscallno;
  1649. {
  1650.     long    *tp;
  1651.  
  1652.     if (dmget(arg[0], sizeof(*tp), &tp) == -1)
  1653.         return -1;
  1654.  
  1655.     Rstart;
  1656.     return_value0 = syscall(syscallno, tp);
  1657.     return_errno = errno;
  1658.     Rstop;
  1659.  
  1660.     if (dmput(arg[0], tp, sizeof(*tp), return_value0) == -1)
  1661.         return -1;
  1662.  
  1663.     return 0;
  1664. }
  1665.  
  1666. int
  1667. generic_symlink(syscallno)
  1668. int    syscallno;
  1669. {
  1670.     char    *namep;
  1671.     char    name1[1024];
  1672.     char    *cp;
  1673.  
  1674.     if (mgets(arg[0], &namep) == -1)
  1675.         return -1;
  1676.  
  1677.     if (namep != (char *)0)
  1678.     {
  1679.         (void)strcpy(&name1[0], namep);
  1680.         namep = &name1[0];
  1681.     }
  1682.  
  1683.     if (mgets(arg[1], &cp) == -1)
  1684.         return -1;
  1685.  
  1686.     Rstart;
  1687.     return_value0 = syscall(syscallno, namep, cp);
  1688.     return_errno = errno;
  1689.     Rstop;
  1690.  
  1691.     return 0;
  1692. }
  1693.  
  1694. int
  1695. generic_sync(syscallno)
  1696. int    syscallno;
  1697. {
  1698.     Rstart;
  1699.     return_value0 = syscall(syscallno);
  1700.     return_errno = errno;
  1701.     Rstop;
  1702.  
  1703.     return 0;
  1704. }
  1705.  
  1706. int
  1707. generic_time(syscallno)
  1708. int    syscallno;
  1709. {
  1710.     long    *tlocp;
  1711.  
  1712.     if (dmget(arg[0], sizeof(*tlocp), &tlocp) == -1)
  1713.         return -1;
  1714.  
  1715.     Rstart;
  1716.     return_value0 = syscall(syscallno, tlocp);
  1717.     return_errno = errno;
  1718.     Rstop;
  1719.  
  1720.     if (dmput(arg[0], tlocp, sizeof(*tlocp), return_value0) == -1)
  1721.         return -1;
  1722.  
  1723.     return 0;
  1724. }
  1725.  
  1726. int
  1727. generic_times(syscallno, tz)
  1728. int    syscallno;
  1729. int    tz;
  1730. {
  1731.     void    *tp;
  1732.  
  1733.     if (dmget(arg[0], tz, &tp) == -1)
  1734.         return -1;
  1735.  
  1736.     Rstart;
  1737.     return_value0 = syscall(syscallno, tp);
  1738.     return_errno = errno;
  1739.     Rstop;
  1740.  
  1741.     if (dmput(arg[0], tp, tz, return_value0) == -1)
  1742.         return -1;
  1743.  
  1744.     return 0;
  1745. }
  1746.  
  1747. int
  1748. generic_truncate(syscallno)
  1749. int    syscallno;
  1750. {
  1751.     char    *cp;
  1752.  
  1753.     if (mgets(arg[0], &cp) == -1)
  1754.         return -1;
  1755.  
  1756.     Rstart;
  1757.     return_value0 = syscall(syscallno, cp, (int)arg[1]);
  1758.     return_errno = errno;
  1759.     Rstop;
  1760.  
  1761.     return 0;
  1762. }
  1763.  
  1764. int
  1765. generic_uadmin(syscallno)
  1766. int    syscallno;
  1767. {
  1768.     Rstart;
  1769.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  1770.     return_errno = errno;
  1771.     Rstop;
  1772.  
  1773.     return 0;
  1774. }
  1775.  
  1776. int
  1777. generic_ulimit(syscallno)
  1778. int    syscallno;
  1779. {
  1780.     Rstart;
  1781.     return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  1782.     return_errno = errno;
  1783.     Rstop;
  1784.  
  1785.     return 0;
  1786. }
  1787.  
  1788. int
  1789. generic_umask(syscallno)
  1790. int    syscallno;
  1791. {
  1792.     Rstart;
  1793.     return_value0 = syscall(syscallno, (int)arg[0]);
  1794.     return_errno = errno;
  1795.     Rstop;
  1796.  
  1797.     return 0;
  1798. }
  1799.  
  1800. int
  1801. generic_unlink(syscallno)
  1802. int    syscallno;
  1803. {
  1804.     char    *cp;
  1805.  
  1806.     if (mgets(arg[0], &cp) == -1)
  1807.         return -1;
  1808.  
  1809.     Rstart;
  1810.     return_value0 = syscall(syscallno, cp);
  1811.     return_errno = errno;
  1812.     Rstop;
  1813.  
  1814.     return 0;
  1815. }
  1816.  
  1817. int
  1818. generic_unmount(syscallno)
  1819. int    syscallno;
  1820. {
  1821.     char    *cp;
  1822.  
  1823.     if (mgets(arg[0], &cp) == -1)
  1824.         return -1;
  1825.  
  1826.     Rstart;
  1827.     return_value0 = syscall(syscallno, cp);
  1828.     return_errno = errno;
  1829.     Rstop;
  1830.  
  1831.     return 0;
  1832. }
  1833.  
  1834. int
  1835. generic_utime(syscallno, t, tz)
  1836. int    syscallno;
  1837. void    *t;
  1838. int    tz;
  1839. {
  1840.     char    *cp;
  1841.     void    *tp;
  1842.  
  1843.     if (mgets(arg[0], &cp) == -1)
  1844.         return -1;
  1845.  
  1846.     if (mget(arg[1], t, tz, &tp) == -1)
  1847.         return -1;
  1848.  
  1849.     Rstart;
  1850.     return_value0 = syscall(syscallno, cp, tp);
  1851.     return_errno = errno;
  1852.     Rstop;
  1853.  
  1854.     return 0;
  1855. }
  1856.  
  1857. int
  1858. generic_utimes(syscallno, tv, tvz)
  1859. int    syscallno;
  1860. void    *tv;
  1861. int    tvz;
  1862. {
  1863.     char    *cp;
  1864.     void    *tvp;
  1865.  
  1866.     if (mgets(arg[0], &cp) == -1)
  1867.         return -1;
  1868.  
  1869.     if (mget(arg[1], tv, tvz, &tvp) == -1)
  1870.         return -1;
  1871.  
  1872.     Rstart;
  1873.     return_value0 = syscall(syscallno, cp, tvp);
  1874.     return_errno = errno;
  1875.     Rstop;
  1876.  
  1877.     if (mput(arg[1], tvp, tvz, return_value0) == -1)
  1878.         return -1;
  1879.  
  1880.     return 0;
  1881. }
  1882.  
  1883. int
  1884. generic_vhangup(syscallno)
  1885. int    syscallno;
  1886. {
  1887.     Rstart;
  1888.     return_value0 = syscall(syscallno);
  1889.     return_errno = errno;
  1890.     Rstop;
  1891.  
  1892.     return 0;
  1893. }
  1894.  
  1895. int
  1896. generic_wait3(syscallno, s, sz, r, rz)
  1897. int    syscallno;
  1898. void    *s;
  1899. int    sz;
  1900. void    *r;
  1901. int    rz;
  1902. {
  1903.     void    *sp;
  1904.     void    *rp;
  1905.  
  1906.     if (mget(arg[0], s, sz, &sp) == -1)
  1907.         return -1;
  1908.  
  1909.     if (mget(arg[2], r, rz, &rp) == -1)
  1910.         return -1;
  1911.  
  1912.     Rstart;
  1913.     return_value0 = syscall(syscallno, sp, arg[1], rp);
  1914.     return_errno = errno;
  1915.     Rstop;
  1916.  
  1917.     if (mput(arg[2], rp, rz, return_value0) == -1)
  1918.         return -1;
  1919.  
  1920.     if (mput(arg[0], sp, sz, return_value0) == -1)
  1921.         return -1;
  1922.  
  1923.     return 0;
  1924. }
  1925.  
  1926. int
  1927. generic_write(syscallno)
  1928. int    syscallno;
  1929. {
  1930.     char    *buf;
  1931.     int    nbyte;
  1932.  
  1933.     nbyte = arg[2];
  1934.  
  1935.     if (dmget(arg[1], nbyte, &buf) == -1)
  1936.         return -1;
  1937.  
  1938.     Rstart;
  1939.     return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), buf, nbyte);
  1940.     return_errno = errno;
  1941.     Rstop;
  1942.  
  1943.     return 0;
  1944. }
  1945.