moncalls.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128
  1. /*
  2. The MON instruction
  3. */
  4. /* $Header$ */
  5. #include "sysidf.h"
  6. #include "log.h"
  7. #include "alloc.h"
  8. #include "shadow.h"
  9. #include <sys/types.h>
  10. #include <sys/stat.h>
  11. #if __STDC__
  12. #include <time.h>
  13. #endif
  14. #include <sys/times.h>
  15. extern int errno; /* UNIX error number */
  16. extern int running; /* from main.c */
  17. extern int fd_limit; /* from io.c */
  18. #define good_fd(fd) (fd < fd_limit ? 1 : (errno = 9 /* EBADF */, 0))
  19. #ifdef BSD_X /* from system.h */
  20. #include <sys/timeb.h>
  21. #endif /* BSD_X */
  22. #ifdef SYS_V
  23. struct timeb { /* non-existing; we use an ad-hoc definition */
  24. long time;
  25. unsigned short millitm;
  26. short timezone, dstflag;
  27. };
  28. #endif /* SYS_V */
  29. #ifdef BSD4_2 /* from system.h */
  30. #include <sys/time.h>
  31. #endif /* BSD4_2 */
  32. #ifdef SYS_V
  33. #include <sys/errno.h>
  34. #undef ERANGE /* collision with trap.h */
  35. #include <fcntl.h>
  36. #include <time.h>
  37. #endif /* SYS_V */
  38. #include <em_abs.h>
  39. #include "logging.h"
  40. #include "global.h"
  41. #include "trap.h"
  42. #include "warn.h"
  43. #include "mem.h"
  44. #define INPUT 0
  45. #define OUTPUT 1
  46. #define DUPMASK 0x40
  47. extern long lseek();
  48. #ifdef SYS_V
  49. extern unsigned int alarm();
  50. extern long time();
  51. extern void sync();
  52. #endif /* SYS_V */
  53. #define INT2SIZE max(wsize, 2L)
  54. #define INT4SIZE max(wsize, 4L)
  55. #define pop_int() ((int) swpop())
  56. #define pop_int2() ((int) spop(INT2SIZE))
  57. #define pop_int4() (spop(INT4SIZE))
  58. #define pop_intp() ((int) spop(psize))
  59. #define pop_uns2() ((unsigned int) upop(INT2SIZE))
  60. #define pop_unsp() ((unsigned int) upop(psize))
  61. #define pop_ptr() (dppop())
  62. #define push_int(a) (wpush((long)(a)))
  63. #define push_i2(a) (npush((long)(a), INT2SIZE))
  64. #define push_i4(a) (npush((long)(a), INT4SIZE))
  65. #define push_unsp(a) (npush((long)(a), psize))
  66. #define push_err() { push_int(errno); push_int(errno); }
  67. /************************************************************************
  68. * Monitor calls. *
  69. * *
  70. * The instruction "MON" expects a wsized integer on top of *
  71. * top of the stack, which identifies the call. Often there *
  72. * are also parameters following this number. The parameters *
  73. * were stacked in reverse order (C convention). *
  74. * The possible parameter types are : *
  75. * *
  76. * 1) int : integer of wordsize *
  77. * 2) int2: integer with size max(2, wordsize) *
  78. * 3) int4: integer with size max(4, wordsize) *
  79. * 4) intp: integer with size of a pointer *
  80. * 5) uns2: unsigned integer with size max(2, wordsize) *
  81. * 6) unsp: unsigned integer with size of a pointer *
  82. * 7) ptr : pointer into data space *
  83. * *
  84. * After the call has been executed, a return code is present *
  85. * on top of the stack. If this return code equals zero, the call *
  86. * succeeded and the results of the call can be found right *
  87. * after the return code. A non zero return code indicates a *
  88. * failure. In this case no results are available and the return *
  89. * code has been pushed twice. *
  90. * *
  91. * Monitor calls such as "ioctl", "stat", "ftime", etc. work *
  92. * with a private buffer to be filled by the call. The fields *
  93. * of the buffer are written to EM-memory separately, possibly *
  94. * with some of the fields aligned. To this end a number of *
  95. * transport routines are assembled in monstruct.[ch]. *
  96. * *
  97. * The EM report specifies a list of UNIX Version 7 -like system *
  98. * calls, not full access to the system calls on the underlying *
  99. * machine. Therefore an attempt has been made to use or emulate *
  100. * the Version 7 system calls on the various machines. A number *
  101. * of 4.1 BSD specific parameters have also been implemented. *
  102. * *
  103. ************************************************************************/
  104. PRIVATE size buf_cnt[5]; /* Current sizes of the buffers */
  105. PRIVATE char *buf[5]; /* Pointers to the buffers */
  106. PRIVATE check_buf();
  107. PRIVATE int savestr();
  108. PRIVATE int vec();
  109. moncall()
  110. {
  111. int n; /* number actually read/written */
  112. int status; /* status for wait-call */
  113. int flag; /* various flag parameters */
  114. int mode; /* various mode parameters */
  115. int oldmask; /* for umask call */
  116. int whence; /* parameter for lseek */
  117. int address; /* address parameter typed int2 */
  118. int owner; /* owner parameter typed int2 */
  119. int group; /* group parameter typed int2 */
  120. int pid; /* pid parameter typed int2 */
  121. int ppid; /* parent process pid */
  122. long off; /* offset parameter */
  123. int pfds[2]; /* pipe file descriptors */
  124. long tm; /* for stime call */
  125. long actime, modtime; /* for utime */
  126. int incr; /* for nice call */
  127. int fd, fdnew; /* file descriptors */
  128. int groupid; /* group id */
  129. int userid; /* user id */
  130. int sig; /* killing signal */
  131. ptr dsp1, dsp2, dsp3; /* Data Space Pointers */
  132. int nbytes; /* number to be read/written */
  133. unsigned int seconds; /* for alarm call */
  134. int trap_no; /* for sigtrp; trap number */
  135. int old_trap_no; /* for sigtrp; old trap number */
  136. int sig_no; /* for sigtrp; signal number */
  137. int request; /* ioctl and ptrace request */
  138. char **envvec; /* environment vector (exec) */
  139. char **argvec; /* argument vector (exec) */
  140. struct stat st_buf; /* private stat buffer */
  141. struct tms tm_buf; /* private tms buffer */
  142. struct timeb tb_buf; /* private timeb buffer */
  143. #ifdef BSD4_2 /* from system.h */
  144. struct timeval tv; /* private timeval buffer */
  145. #endif /* BSD4_2 */
  146. #ifdef BSD_X /* from system.h */
  147. time_t utimbuf[2]; /* private utime buffer */
  148. #endif /* BSD_X */
  149. #ifdef SYS_V /* from system.h */
  150. struct {time_t x, y;} utimbuf; /* private utime buffer */
  151. #endif /* SYS_V */
  152. char *cp;
  153. int nr;
  154. ptr addr;
  155. int rc;
  156. switch (pop_int()) {
  157. case 1: /* Exit */
  158. #ifdef LOGGING
  159. ES_def =
  160. ((st_sh(SP) == UNDEFINED)
  161. || (st_sh(SP + wsize-1) == UNDEFINED)) ?
  162. UNDEFINED : DEFINED;
  163. #else
  164. ES_def = DEFINED;
  165. #endif /* LOGGING */
  166. ES = pop_int();
  167. running = 0; /* stop the machine */
  168. LOG(("@m9 Exit: ES = %ld", ES));
  169. break;
  170. case 2: /* Fork */
  171. ppid = getpid();
  172. if ((pid = fork()) == 0) {
  173. /* Child */
  174. init_ofiles(0); /* Reinitialize */
  175. push_int(ppid); /* Pid of parent */
  176. push_int(1); /* Flag = 1 for child */
  177. push_int(0);
  178. LOG(("@m9 Fork: in child, ppid = %d", ppid));
  179. }
  180. else if (pid > 0) { /* Parent */
  181. incr_mess_id(); /* Incr. id for next child */
  182. push_int(pid); /* Pid of child */
  183. push_int(0); /* Flag = 0 for parent */
  184. push_int(0);
  185. LOG(("@m9 Fork: in parent, cpid = %d", pid));
  186. }
  187. else {
  188. /* fork call failed */
  189. push_err();
  190. LOG(("@m4 Fork: failed, pid = %d, errno = %d",
  191. pid, errno));
  192. }
  193. break;
  194. case 3: /* Read */
  195. fd = pop_int();
  196. dsp1 = pop_ptr();
  197. nbytes = pop_intp();
  198. if (!good_fd(fd))
  199. goto read_error;
  200. if (nbytes < 0) {
  201. errno = 22; /* EINVAL */
  202. goto read_error;
  203. }
  204. check_buf(0, (size)nbytes);
  205. if ((n = read(fd, buf[0], nbytes)) == -1)
  206. goto read_error;
  207. #ifdef LOGGING
  208. if (check_log("@m6")) {
  209. register int i;
  210. for (i = 0; i < n; i++) {
  211. LOG(("@m6 Read: char = '%c'", *(buf[0] + i)));
  212. }
  213. }
  214. #endif /* LOGGING */
  215. if (in_gda(dsp1) && !in_gda(dsp1 + (n-1))) {
  216. efault(WRGDAH);
  217. goto read_error;
  218. }
  219. if (!is_in_mem(dsp1, n)) {
  220. efault(WRUMEM);
  221. goto read_error;
  222. }
  223. for ( nr = n, cp = buf[0], addr = dsp1;
  224. nr;
  225. nr--, addr++, cp++
  226. ) {
  227. if (in_stack(addr)) {
  228. ch_st_prot(addr);
  229. stack_loc(addr) = *cp;
  230. st_int(addr);
  231. }
  232. else {
  233. ch_dt_prot(addr);
  234. data_loc(addr) = *cp;
  235. dt_int(addr);
  236. }
  237. }
  238. push_unsp(n);
  239. push_int(0);
  240. LOG(("@m9 Read: succeeded, n = %d", n));
  241. break;
  242. read_error:
  243. push_err();
  244. LOG(("@m4 Read: failed, n = %d, errno = %d", n, errno));
  245. break;
  246. case 4: /* Write */
  247. fd = pop_int();
  248. dsp1 = pop_ptr();
  249. nbytes = pop_intp();
  250. if (!good_fd(fd))
  251. goto write_error;
  252. if (nbytes < 0) {
  253. errno = 22; /* EINVAL */
  254. goto read_error;
  255. }
  256. if (in_gda(dsp1) && !in_gda(dsp1 + (nbytes-1))) {
  257. efault(WWGDAH);
  258. goto write_error;
  259. }
  260. if (!is_in_mem(dsp1, nbytes)) {
  261. efault(WWUMEM);
  262. goto write_error;
  263. }
  264. #ifdef LOGGING
  265. for (addr = dsp1; addr < dsp1 + nbytes; addr++) {
  266. if (mem_sh(addr) == UNDEFINED) {
  267. warning(in_stack(addr) ? WWLUNDEF : WWGUNDEF);
  268. }
  269. }
  270. #endif /* LOGGING */
  271. check_buf(0, (size)nbytes);
  272. for ( nr = nbytes, addr = dsp1, cp = buf[0];
  273. nr;
  274. nr--, addr++, cp++
  275. ) {
  276. *cp = mem_loc(addr);
  277. }
  278. #ifdef LOGGING
  279. if (check_log("@m6")) {
  280. register int i;
  281. for (i = 0; i < nbytes; i++) {
  282. LOG(("@m6 write: char = '%c'", *(buf[0] + i)));
  283. }
  284. }
  285. #endif /* LOGGING */
  286. if ((n = write(fd, buf[0], nbytes)) == -1)
  287. goto write_error;
  288. push_unsp(n);
  289. push_int(0);
  290. LOG(("@m9 Write: succeeded, n = %d", n));
  291. break;
  292. write_error:
  293. push_err();
  294. LOG(("@m4 Write: failed, n = %d, nbytes = %d, errno = %d",
  295. n, nbytes, errno));
  296. break;
  297. case 5: /* Open */
  298. dsp1 = pop_ptr();
  299. flag = pop_int();
  300. if (!savestr(0, dsp1) || (fd = open(buf[0], flag)) == -1) {
  301. push_err();
  302. LOG(("@m4 Open: failed, file = %lu, flag = %d, fd = %d, errno = %d",
  303. dsp1, flag, fd, errno));
  304. }
  305. else {
  306. push_int(fd);
  307. push_int(0);
  308. LOG(("@m9 Open: succeeded, file = %lu, flag = %d, fd = %d",
  309. dsp1, flag, fd));
  310. }
  311. break;
  312. case 6: /* Close */
  313. fd = pop_int();
  314. if (!good_fd(fd) || close(fd) == -1) {
  315. push_err();
  316. LOG(("@m4 Close: failed, fd = %d, errno = %d",
  317. fd, errno));
  318. }
  319. else {
  320. push_int(0);
  321. LOG(("@m9 Close: succeeded"));
  322. }
  323. break;
  324. case 7: /* Wait */
  325. if ((pid = wait(&status)) == -1) {
  326. push_err();
  327. LOG(("@m4 Wait: failed, status = %d, errno = %d",
  328. status, errno));
  329. }
  330. else {
  331. push_i2(pid);
  332. push_i2(status);
  333. push_int(0);
  334. LOG(("@m9 Wait: succeeded, status = %d, pid = %d",
  335. status, pid));
  336. }
  337. break;
  338. case 8: /* Creat */
  339. dsp1 = pop_ptr();
  340. flag = pop_int();
  341. if (!savestr(0, dsp1) || (fd = creat(buf[0], flag)) == -1) {
  342. push_err();
  343. LOG(("@m4 Creat: failed, dsp1 = %lu, flag = %d, errno = %d",
  344. dsp1, flag, errno));
  345. }
  346. else {
  347. push_int(fd);
  348. push_int(0);
  349. LOG(("@m9 Creat: succeeded, fd = %d", fd));
  350. }
  351. break;
  352. case 9: /* Link */
  353. dsp1 = pop_ptr();
  354. dsp2 = pop_ptr();
  355. if ( !savestr(0, dsp1)
  356. || !savestr(1, dsp2)
  357. || link(buf[0], buf[1]) == -1
  358. ) {
  359. push_err();
  360. LOG(("@m4 Link: failed, dsp1 = %lu, dsp2 = %lu, errno = %d",
  361. dsp1, dsp2, errno));
  362. }
  363. else {
  364. push_int(0);
  365. LOG(("@m9 Link: succeeded, dsp1 = %lu, dsp2 = %lu",
  366. dsp1, dsp2));
  367. }
  368. break;
  369. case 10: /* Unlink */
  370. dsp1 = pop_ptr();
  371. if (!savestr(0, dsp1) || unlink(buf[0]) == -1) {
  372. push_err();
  373. LOG(("@m4 Unlink: failed, dsp1 = %lu, errno = %d",
  374. dsp1, errno));
  375. }
  376. else {
  377. push_int(0);
  378. LOG(("@m9 Unlink: succeeded, dsp1 = %lu", dsp1));
  379. }
  380. break;
  381. case 12: /* Chdir */
  382. dsp1 = pop_ptr();
  383. if (!savestr(0, dsp1) || chdir(buf[0]) == -1) {
  384. push_err();
  385. LOG(("@m4 Chdir: failed, dsp1 = %lu, errno = %d",
  386. dsp1, errno));
  387. }
  388. else {
  389. push_int(0);
  390. LOG(("@m9 Chdir: succeeded, dsp1 = %lu", dsp1));
  391. }
  392. break;
  393. case 14: /* Mknod */
  394. dsp1 = pop_ptr();
  395. mode = pop_int();
  396. address = pop_int2();
  397. if (!savestr(0, dsp1) || mknod(buf[0], mode, address) == -1) {
  398. push_err();
  399. LOG(("@m4 Mknod: failed, dsp1 = %lu, mode = %d, address = %d, errno = %d",
  400. dsp1, mode, address, errno));
  401. }
  402. else {
  403. push_int(0);
  404. LOG(("@m9 Mknod: succeeded, dsp1 = %lu", dsp1));
  405. }
  406. break;
  407. case 15: /* Chmod */
  408. dsp1 = pop_ptr();
  409. mode = pop_int2();
  410. if (!savestr(0, dsp1) || chmod(buf[0], mode) == -1) {
  411. push_err();
  412. LOG(("@m4 Chmod: failed, dsp1 = %lu, mode = %d, errno = %d",
  413. dsp1, mode, errno));
  414. }
  415. else {
  416. push_int(0);
  417. LOG(("@m9 Chmod: succeeded, dsp1 = %lu", dsp1));
  418. }
  419. break;
  420. case 16: /* Chown */
  421. dsp1 = pop_ptr();
  422. owner = pop_int2();
  423. group = pop_int2();
  424. if (!savestr(0, dsp1) || chown(buf[0], owner, group) == -1) {
  425. push_err();
  426. LOG(("@m4 Chown: failed, dsp1 = %lu, owner = %d, group = %d, errno = %d",
  427. dsp1, owner, group, errno));
  428. }
  429. else {
  430. push_int(0);
  431. LOG(("@m9 Chown: succeeded, dsp1 = %lu", dsp1));
  432. }
  433. break;
  434. case 18: /* Stat */
  435. dsp1 = pop_ptr(); /* points to file-name space */
  436. dsp2 = pop_ptr(); /* points to EM-stat-buffer space */
  437. if ( !savestr(0, dsp1)
  438. || stat(buf[0], &st_buf) == -1
  439. || !stat2mem(dsp2, &st_buf)
  440. ) {
  441. push_err();
  442. LOG(("@m4 Stat: failed, dsp1 = %lu, dsp2 = %lu, errno = %d",
  443. dsp1, dsp2, errno));
  444. }
  445. else {
  446. push_int(0);
  447. LOG(("@m9 Stat: succeeded, dsp1 = %lu, dsp2 = %lu",
  448. dsp1, dsp2));
  449. }
  450. break;
  451. case 19: /* Lseek */
  452. fd = pop_int();
  453. off = pop_int4();
  454. whence = pop_int();
  455. LOG(("@m4 Lseek: fd = %d, off = %ld, whence = %d",
  456. fd, off, whence));
  457. if (!good_fd(fd) || (off = lseek(fd, off, whence)) == -1) {
  458. push_err();
  459. LOG(("@m9 Lseek: failed, errno = %d", errno));
  460. }
  461. else {
  462. push_i4(off);
  463. push_int(0);
  464. LOG(("@m9 Lseek: succeeded, pushed %ld", off));
  465. }
  466. break;
  467. case 20: /* Getpid */
  468. pid = getpid();
  469. push_i2(pid);
  470. LOG(("@m9 Getpid: succeeded, pid = %d", pid));
  471. break;
  472. case 21: /* Mount */
  473. dsp1 = pop_ptr();
  474. dsp2 = pop_ptr();
  475. flag = pop_int();
  476. if ( !savestr(0, dsp1)
  477. || !savestr(1, dsp2)
  478. || mount(buf[0], buf[1], flag) == -1
  479. ) {
  480. push_err();
  481. LOG(("@m4 Mount: failed, dsp1 = %lu, dsp2 = %lu, flag = %d, errno = %d",
  482. dsp1, dsp2, flag, errno));
  483. }
  484. else {
  485. push_int(0);
  486. LOG(("@m9 Mount: succeeded, dsp1 = %lu, dsp2 = %lu, flag = %d",
  487. dsp1, dsp2, flag));
  488. }
  489. break;
  490. case 22: /* Umount */
  491. dsp1 = pop_ptr();
  492. if ( !savestr(0, dsp1)
  493. #ifndef BSD4_2 /* from system.h */
  494. || umount(buf[0]) == -1
  495. #else /* BSD4_2 */
  496. || unmount(buf[0]) == -1
  497. #endif /* BSD4_2 */
  498. ) {
  499. push_err();
  500. LOG(("@m4 Umount: failed, dsp1 = %lu, errno = %d",
  501. dsp1, errno));
  502. }
  503. else {
  504. push_int(0);
  505. LOG(("@m9 Mount: succeeded, dsp1 = %lu", dsp1));
  506. }
  507. break;
  508. case 23: /* Setuid */
  509. userid = pop_int2();
  510. if (setuid(userid) == -1) {
  511. push_err();
  512. LOG(("@m4 Setuid: failed, userid = %d, errno = %d",
  513. userid, errno));
  514. }
  515. else {
  516. push_int(0);
  517. LOG(("@m9 Setuid: succeeded, userid = %d", userid));
  518. }
  519. break;
  520. case 24: /* Getuid */
  521. userid = getuid();
  522. push_i2(userid);
  523. LOG(("@m9 Getuid(part 1): real uid = %d", userid));
  524. userid = geteuid();
  525. push_i2(userid);
  526. LOG(("@m9 Getuid(part 2): eff uid = %d", userid));
  527. break;
  528. case 25: /* Stime */
  529. tm = pop_int4();
  530. #ifndef BSD4_2 /* from system.h */
  531. rc = stime(&tm);
  532. #else /* BSD4_2 */
  533. tv.tv_sec = tm;
  534. tv.tv_usec = 0; /* zero microseconds */
  535. rc = settimeofday(&tv, (struct timezone *)0);
  536. #endif /* BSD4_2 */
  537. if (rc == -1) {
  538. push_err();
  539. LOG(("@m4 Stime: failed, tm = %ld, errno = %d",
  540. tm, errno));
  541. }
  542. else {
  543. push_int(0);
  544. LOG(("@m9 Stime: succeeded, tm = %ld", tm));
  545. }
  546. break;
  547. case 26: /* Ptrace */
  548. request = pop_int();
  549. pid = pop_int2();
  550. dsp3 = pop_ptr();
  551. n = pop_int(); /* Data */
  552. einval(WPTRACEIMP);
  553. push_err();
  554. LOG(("@m4 Ptrace: failed, request = %d, pid = %d, addr = %lu, data = %d, errno = %d",
  555. request, pid, dsp3, n, errno));
  556. break;
  557. case 27: /* Alarm */
  558. seconds = pop_uns2();
  559. LOG(("@m9 Alarm(part 1) seconds = %u", seconds));
  560. seconds = alarm(seconds);
  561. push_i2(seconds);
  562. LOG(("@m9 Alarm(part 2) seconds = %u", seconds));
  563. break;
  564. case 28: /* Fstat */
  565. fd = pop_int();
  566. dsp2 = pop_ptr();
  567. if ( !good_fd(fd)
  568. || fstat(fd, &st_buf) == -1
  569. || !stat2mem(dsp2, &st_buf)
  570. ) {
  571. push_err();
  572. LOG(("@m4 Fstat: failed, fd = %d, dsp2 = %lu, errno = %d",
  573. fd, dsp2, errno));
  574. }
  575. else {
  576. push_int(0);
  577. LOG(("@m9 Fstat: succeeded, fd = %d, dsp2 = %lu",
  578. fd, dsp2));
  579. }
  580. break;
  581. case 29: /* Pause */
  582. pause();
  583. LOG(("@m9 Pause: succeeded"));
  584. break;
  585. case 30: /* Utime */
  586. dsp1 = pop_ptr();
  587. dsp2 = pop_ptr();
  588. if (memfault(dsp2, 2*INT4SIZE)) {
  589. push_err();
  590. LOG(("@m4 Utime: failed, dsp1 = %lu, dsp2 = %lu, errno = %d",
  591. dsp1, dsp2, errno));
  592. break;
  593. }
  594. actime = mem_ldu(dsp2, INT4SIZE);
  595. modtime = mem_ldu(dsp2 + INT4SIZE, INT4SIZE);
  596. #ifdef BSD_X /* from system.h */
  597. utimbuf[0] = actime;
  598. utimbuf[1] = modtime;
  599. #endif /* BSD_X */
  600. #ifdef SYS_V /* from system.h */
  601. utimbuf.x = actime;
  602. utimbuf.y = modtime;
  603. #endif /* SYS_V */
  604. if (!savestr(0, dsp1) || utime(buf[0], utimbuf) == -1) {
  605. push_err();
  606. LOG(("@m4 Utime: failed, dsp1 = %lu, dsp2 = %lu, errno = %d",
  607. dsp1, dsp2, errno));
  608. }
  609. else {
  610. push_int(0);
  611. LOG(("@m9 Utime: succeeded, dsp1 = %lu, dsp2 = %lu",
  612. dsp1, dsp2));
  613. }
  614. break;
  615. case 33: /* Access */
  616. dsp1 = pop_ptr();
  617. mode = pop_int();
  618. if (!savestr(0, dsp1) || access(buf[0], mode) == -1) {
  619. push_err();
  620. LOG(("@m4 Access: failed, dsp1 = %lu, mode = %d, errno = %d",
  621. dsp1, mode, errno));
  622. }
  623. else {
  624. push_int(0);
  625. LOG(("@m9 Access: succeeded, dsp1 = %lu, mode = %d",
  626. dsp1, mode));
  627. }
  628. break;
  629. case 34: /* Nice */
  630. incr = pop_int();
  631. nice(incr);
  632. LOG(("@m9 Nice: succeeded, incr = %d", incr));
  633. break;
  634. case 35: /* Ftime */
  635. dsp2 = pop_ptr();
  636. #ifdef BSD_X /* from system.h */
  637. ftime(&tb_buf);
  638. #endif /* BSD_X */
  639. #ifdef SYS_V /* from system.h */
  640. tb_buf.time = time((time_t*)0);
  641. tb_buf.millitm = 0;
  642. tb_buf.timezone = timezone / 60;
  643. tb_buf.dstflag = daylight;
  644. #endif /* SYS_V */
  645. if (!timeb2mem(dsp2, &tb_buf)) {
  646. push_err();
  647. LOG(("@m4 Ftime: failed, dsp2 = %lu, errno = %d",
  648. dsp2, errno));
  649. }
  650. else {
  651. push_int(0);
  652. LOG(("@m9 Ftime: succeeded, dsp2 = %lu", dsp2));
  653. }
  654. break;
  655. case 36: /* Sync */
  656. sync();
  657. LOG(("@m9 Sync: succeeded"));
  658. break;
  659. case 37: /* Kill */
  660. pid = pop_int2();
  661. sig = pop_int();
  662. if (kill(pid, sig) == -1) {
  663. push_err();
  664. LOG(("@m4 Kill: failed, pid = %d, sig = %d, errno = %d",
  665. pid, sig, errno));
  666. }
  667. else {
  668. push_int(0);
  669. LOG(("@m9 Kill: succeeded, pid = %d, sig = %d",
  670. pid, sig));
  671. }
  672. break;
  673. case 41: /* Dup & Dup2 */
  674. fd = pop_int();
  675. fdnew = pop_int();
  676. if (fd & DUPMASK) {
  677. int fd1 = fd & ~DUPMASK;/* stripped */
  678. LOG(("@m4 Dup2: fd1 = %d, fdnew = %d", fd1, fdnew));
  679. if (!good_fd(fd1)) {
  680. fdnew = -1;
  681. goto dup2_error;
  682. }
  683. #ifdef BSD_X /* from system.h */
  684. fdnew = dup2(fd1, fdnew);
  685. #endif /* BSD_X */
  686. #ifdef SYS_V /* from system.h */
  687. {
  688. /* simulating the semantics of dup2 on SYS_V */
  689. int dupped = dup(fd1);
  690. if (dupped < 0 && errno != EMFILE) {
  691. /* the dup failed, but not
  692. because of too many open
  693. file descriptors
  694. */
  695. fdnew = dupped;
  696. }
  697. else {
  698. close(dupped);
  699. close(fdnew);
  700. fdnew = fcntl(fd1, F_DUPFD, fdnew);
  701. }
  702. }
  703. #endif /* SYS_V */
  704. dup2_error:;
  705. }
  706. else {
  707. LOG(("@m4 Dup: fd = %d, fdnew = %d", fd, fdnew));
  708. fdnew = (!good_fd(fd) ? -1 : dup(fd));
  709. }
  710. if (fdnew == -1) {
  711. push_err();
  712. LOG(("@m4 Dup/Dup2: failed, fdnew = %d, errno = %d",
  713. fdnew, errno));
  714. }
  715. else {
  716. push_int(fdnew);
  717. push_int(0);
  718. LOG(("@m9 Dup/Dup2: succeeded, fdnew = %d", fdnew));
  719. }
  720. break;
  721. case 42: /* Pipe */
  722. if (pipe(pfds) == -1) {
  723. push_err();
  724. LOG(("@m4 Pipe: failed, errno = %d", errno));
  725. }
  726. else {
  727. push_int(pfds[0]);
  728. push_int(pfds[1]);
  729. push_int(0);
  730. LOG(("@m9 Pipe: succeeded, pfds[0] = %d, pfds[1] = %d",
  731. pfds[0], pfds[1]));
  732. }
  733. break;
  734. case 43: /* Times */
  735. dsp2 = pop_ptr();
  736. times(&tm_buf);
  737. if (!tms2mem(dsp2, &tm_buf)) {
  738. push_err();
  739. LOG(("@m4 Times: failed, dsp2 = %lu, errno = %d",
  740. dsp2, errno));
  741. }
  742. else {
  743. LOG(("@m9 Times: succeeded, dsp2 = %lu", dsp2));
  744. }
  745. break;
  746. case 44: /* Profil */
  747. dsp1 = pop_ptr(); /* Buffer */
  748. nbytes = pop_intp(); /* Buffer size */
  749. off = pop_intp(); /* Offset */
  750. n = pop_intp(); /* Scale */
  751. einval(WPROFILIMP);
  752. push_err();
  753. LOG(("@m4 Profil: failed, dsp1 = %lu, nbytes = %d, offset = %d, scale = %d, errno = %d",
  754. dsp1, nbytes, off, n, errno));
  755. break;
  756. case 46: /* Setgid */
  757. groupid = pop_int2();
  758. if (setgid(groupid) == -1) {
  759. push_err();
  760. LOG(("@m4 Setgid: failed, groupid = %d, errno = %d",
  761. groupid, errno));
  762. }
  763. else {
  764. push_int(0);
  765. LOG(("@m9 Setgid: succeeded, groupid = %d", groupid));
  766. }
  767. break;
  768. case 47: /* Getgid */
  769. groupid = getgid();
  770. push_i2(groupid);
  771. LOG(("@m9 Getgid(part 1): succeeded, real groupid = %d",
  772. groupid));
  773. groupid = getegid();
  774. push_i2(groupid);
  775. LOG(("@m9 Getgid(part 2): succeeded, eff groupid = %d",
  776. groupid));
  777. break;
  778. case 48: /* Sigtrp */
  779. trap_no = pop_int();
  780. sig_no = pop_int();
  781. if ((old_trap_no = do_sigtrp(trap_no, sig_no)) == -1) {
  782. push_err();
  783. LOG(("@m4 Sigtrp: failed, trap_no = %d, sig_no = %d, errno = %d",
  784. trap_no, sig_no, errno));
  785. }
  786. else {
  787. push_int(old_trap_no);
  788. push_int(0);
  789. LOG(("@m9 Sigtrp: succeeded, trap_no = %d, sig_no = %d, old_trap_no = %d",
  790. trap_no, sig_no, old_trap_no));
  791. }
  792. break;
  793. case 51: /* Acct */
  794. dsp1 = pop_ptr();
  795. if (!savestr(0, dsp1) || acct(buf[0]) == -1) {
  796. push_err();
  797. LOG(("@m4 Acct: failed, dsp1 = %lu, errno = %d",
  798. dsp1, errno));
  799. }
  800. else {
  801. push_int(0);
  802. LOG(("@m9 Acct: succeeded, dsp1 = %lu", dsp1));
  803. }
  804. break;
  805. case 54: /* Ioctl */
  806. fd = pop_int();
  807. request = pop_int();
  808. dsp2 = pop_ptr();
  809. if (!good_fd(fd) || do_ioctl(fd, request, dsp2) != 0) {
  810. push_err();
  811. LOG(("@m4 Ioctl: failed, fd = %d, request = %d, dsp2 = %lu, errno = %d",
  812. fd, request, dsp2, errno));
  813. }
  814. else {
  815. push_int(0);
  816. LOG(("@m9 Ioctl: succeeded, fd = %d, request = %d, dsp2 = %lu",
  817. fd, request, dsp2));
  818. }
  819. break;
  820. case 56: /* Mpxcall */
  821. request = pop_int(); /* Command */
  822. dsp1 = pop_ptr(); /* Vec */
  823. einval(WMPXIMP);
  824. push_err();
  825. LOG(("@m4 Mpxcall: failed, request = %d, dsp1 = %lu, errno = %d",
  826. request, dsp1, errno));
  827. break;
  828. case 59: /* Exec */
  829. dsp1 = pop_ptr();
  830. dsp2 = pop_ptr();
  831. dsp3 = pop_ptr();
  832. if ( !savestr(0, dsp1)
  833. || !vec(1, 2, dsp2, &argvec)
  834. || !vec(3, 4, dsp3, &envvec)
  835. || /* execute results, ignore return code */
  836. (execve(buf[0], argvec, envvec), 1)
  837. ) {
  838. push_err();
  839. LOG(("@m4 Exece: failed, dsp1 = %lu, dsp2 = %lu, dsp2 = %lu, errno = %d",
  840. dsp1, dsp2, dsp3, errno));
  841. }
  842. break;
  843. case 60: /* Umask */
  844. mode = pop_int2();
  845. oldmask = umask(mode);
  846. push_int(oldmask);
  847. LOG(("@m9 Umask: succeeded, mode = %d, oldmask = %d",
  848. mode, oldmask));
  849. break;
  850. case 61: /* Chroot */
  851. dsp1 = pop_ptr();
  852. if (!savestr(0, dsp1) || chroot(buf[0]) == -1) {
  853. push_err();
  854. LOG(("@m4 Chroot: failed, dsp1 = %lu, errno = %d",
  855. dsp1, errno));
  856. }
  857. else {
  858. push_int(0);
  859. LOG(("@m9 Chroot: succeeded, dsp1 = %lu", dsp1));
  860. }
  861. break;
  862. default:
  863. trap(EBADMON);
  864. break;
  865. }
  866. }
  867. /* Buffer administration */
  868. PRIVATE check_buf(n, sz)
  869. int n;
  870. size sz;
  871. {
  872. if (buf_cnt[n] == 0) {
  873. buf_cnt[n] = max(128, sz);
  874. buf[n] = Malloc(buf_cnt[n], "moncall buffer");
  875. }
  876. else if (buf_cnt[n] < sz) {
  877. buf_cnt[n] = allocfrac(sz);
  878. buf[n] = Realloc(buf[n], buf_cnt[n], "moncall buffer");
  879. }
  880. }
  881. PRIVATE int savestr(n, addr)
  882. int n;
  883. ptr addr;
  884. {
  885. register size len;
  886. register char *cp, ch;
  887. /* determine the length, carefully */
  888. len = 0;
  889. do {
  890. if (memfault(addr + len, 1L)) {
  891. return 0;
  892. }
  893. ch = mem_loc(addr + len);
  894. len++;
  895. } while (ch);
  896. /* allocate enough buffer space */
  897. check_buf(n, len);
  898. /* copy the string */
  899. cp = buf[n];
  900. do {
  901. *cp++ = ch = mem_loc(addr);
  902. addr++;
  903. } while (ch);
  904. return 1;
  905. }
  906. PRIVATE int vec(n1, n2, addr, vecvec)
  907. int n1, n2;
  908. ptr addr;
  909. char ***vecvec;
  910. {
  911. register char *cp1, *cp2;
  912. ptr p, ldp;
  913. register int n_ent = 0; /* number of entries */
  914. register size str = 0; /* total string length */
  915. /* determine number of elements n_ent */
  916. p = addr;
  917. do {
  918. if (memfault(addr, psize)) {
  919. return 0;
  920. }
  921. ldp = mem_lddp(p);
  922. if (!savestr(n2, ldp)) {
  923. return 0;
  924. }
  925. str += strlen(buf[n2]) + 1;
  926. n_ent++;
  927. p += psize;
  928. } while (ldp);
  929. n_ent++;
  930. *vecvec = (char **) Malloc((size)(n_ent * sizeof (char *)),
  931. "argvec or envvec in exec()");
  932. check_buf(n1, str);
  933. /* copy the elements */
  934. for ( cp1 = buf[n1], n_ent = 0, p = addr;
  935. ldp = mem_lddp(p);
  936. p += psize, n_ent++
  937. ) {
  938. if (!savestr(n2, ldp)) {
  939. return 0;
  940. }
  941. (*vecvec)[n_ent] = cp1;
  942. cp2 = buf[n2];
  943. while (*cp1++ = *cp2++) {
  944. /* nothing */
  945. }
  946. }
  947. (*vecvec)[n_ent] = 0;
  948. return 1;
  949. }
  950. int memfault(addr, length)
  951. ptr addr;
  952. size length;
  953. {
  954. /* centralizes (almost) all memory access tests in MON */
  955. if (!is_in_mem(addr, length)) {
  956. efault(WMONFLT);
  957. return 1;
  958. }
  959. return 0;
  960. }
  961. efault(wrn)
  962. int wrn; /* warning number */
  963. {
  964. warning(wrn);
  965. errno = 14; /* EFAULT */
  966. }
  967. einval(wrn)
  968. int wrn; /* warning number */
  969. {
  970. warning(wrn);
  971. errno = 22; /* EINVAL */
  972. }