Generic.Linux.I386.Unix.Mod 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275
  1. MODULE Unix; (* Josef Templ, 5.3.90 SVR4 system calls *) (** Linux x86 version, non portable *)
  2. (* Linux PPC version g.f. 18.04.98 *)
  3. (* Linux x86 version g.f 10.11.99 *)
  4. (* 2000.09.19 g.f. 'Sigaltstack' added *)
  5. (* 2002.06.27 g.f. TmDesc fixed, new: Utime, Mktime *)
  6. (* 2006.07.31 g.f. shared memory support added *)
  7. (* 2007.04.13 g.f. Thread priorities added *)
  8. IMPORT S := SYSTEM, Glue, Trace;
  9. CONST
  10. Version* = "LinuxG32";
  11. libcname* = "libc.so.6";
  12. libmname* = "libm.so.6";
  13. libX11name* = "libX11.so.6";
  14. libXextname* = "libXext.so.6";
  15. libpthreadname = "libpthread.so.0";
  16. LittleEndian* = TRUE; (** byte order of basic types *)
  17. LsbIs0* = TRUE; (** bit order of SET type *)
  18. PageSize* = 4096; (* least MMU page size *)
  19. stdin* = 0; stdout* = 1; stderr* = 2;
  20. (** Unix error codes: *)
  21. EPERM* = 1; (* Not super-user *)
  22. ENOENT* = 2; (* No such file or directory *)
  23. ESRCH* = 3; (* No such process *)
  24. EINTR* = 4; (* interrupted system call *)
  25. EIO* = 5; (* I/O error *)
  26. ENXIO* = 6; (* No such device or address *)
  27. E2BIG* = 7; (* Arg list too long *)
  28. ENOEXEC* = 8; (* Exec format error *)
  29. EBADF* = 9; (* Bad file number *)
  30. ECHILD* = 10; (* No children *)
  31. EAGAIN* = 11; (* No more processes *)
  32. ENOMEM* = 12; (* Not enough core *)
  33. EACCES* = 13; (* Permission denied *)
  34. EFAULT* = 14; (* Bad address *)
  35. ENOTBLK* = 15; (* Block device required *)
  36. EBUSY* = 16; (* Mount device busy *)
  37. EEXIST* = 17; (* File exists *)
  38. EXDEV* = 18; (* Cross-device link *)
  39. ENODEV* = 19; (* No such device *)
  40. ENOTDIR* = 20; (* Not a directory *)
  41. EISDIR* = 21; (* Is a directory *)
  42. EINVAL* = 22; (* Invalid argument *)
  43. ENFILE* = 23; (* File table overflow *)
  44. EMFILE* = 24; (* Too many open files *)
  45. ENOTTY* = 25; (* Inappropriate ioctl for device *)
  46. ETXTBSY* = 26; (* Text file busy *)
  47. EFBIG* = 27; (* File too large *)
  48. ENOSPC* = 28; (* No space left on device *)
  49. ESPIPE* = 29; (* Illegal seek *)
  50. EROFS* = 30; (* Read only file system *)
  51. EMLINK* = 31; (* Too many links *)
  52. EPIPE* = 32; (* Broken pipe *)
  53. EDOM* = 33; (* Math arg out of domain of func *)
  54. ERANGE* = 34; (* Math result not representable *)
  55. ENOMSG* = 42; (* No message of desired type *)
  56. EIDRM* = 43; (* Identifier removed *)
  57. ECHRNG* = 44; (* Channel number out of range *)
  58. EL2NSYNC* = 45; (* Level 2 not synchronized *)
  59. EL3HLT* = 46; (* Level 3 halted *)
  60. EL3RST* = 47; (* Level 3 reset *)
  61. ELNRNG* = 48; (* Link number out of range *)
  62. EUNATCH* = 49; (* Protocol driver not attached *)
  63. ENOCSI* = 50; (* No CSI structure available *)
  64. EL2HLT* = 51; (* Level 2 halted *)
  65. EDEADLK* = 35; (* Deadlock condition. *)
  66. ENOLCK* = 37; (* No record locks available. *)
  67. (* open flags *)
  68. rdonly* = {}; rdwr* = {1}; creat* = {6}; trunc* = {9};
  69. (* access modes *)
  70. rwrwr* = {2, 4, 5, 7, 8}; rwxrwxrwx* = {0..8};
  71. F_OK* = {}; X_Ok* = {0}; W_OK* = {1}; R_OK* = {2};
  72. SCHED_OTHER = 0;
  73. T_SIGRESUME = SIGUSR1;
  74. T_SIGSUSPEND = SIGUSR2;
  75. SIGHUP = 1;
  76. SIGINT = 2;
  77. SIGQUIT=3;
  78. SIGILL = 4;
  79. SIGTRAP = 5;
  80. SIGABRT = 6;
  81. SIGIOT = 6;
  82. SIGBUS = 7;
  83. SIGFPE = 8;
  84. SIGKILL = 9;
  85. SIGUSR1 = 10;
  86. SIGSEGV = 11;
  87. SIGUSR2 = 12;
  88. SIGPIPE = 13;
  89. SIGALRM = 14;
  90. SIGTERM = 15;
  91. SIGSTKFLT = 16;
  92. SIGCHLD = 17;
  93. SIGCONT = 18;
  94. SIGSTOP = 19;
  95. SIGTSTP = 20;
  96. SIGTTIN = 21;
  97. SIGTTOU = 22;
  98. SIGURG = 23;
  99. SIGXCPU = 24;
  100. SIGXFSZ = 25;
  101. SIGVTALRM = 26;
  102. SIGPROF = 27;
  103. SIGWINCH=28;
  104. SIGIO=29;
  105. SIGPOLL = SIGIO;
  106. SIGPWR = 30;
  107. SIGSYS = 31;
  108. SIGUNUSED =31;
  109. SIG_BLOCK = 0;
  110. SIG_UNBLOCK=1;
  111. SIG_SETMASK=2;
  112. SA_NOCLDSTOP = 0x00000001;
  113. SA_SIGINFO = 0x00000004;
  114. SA_ONSTACK = 0x08000000;
  115. SA_RESTART = 0x10000000;
  116. SA_NODEFER = 0x40000000;
  117. SA_RESETHAND = 0x80000000;
  118. PTHREAD_CANCEL_ENABLE = 0;
  119. PTHREAD_CANCEL_DISABLE = 1;
  120. PTHREAD_CANCEL_ASYNCHRONOUS =0;
  121. PTHREAD_CANCEL_DEFERRED = 1;
  122. (*--------------------------- Threads -------------------------------*)
  123. TYPE
  124. Thread_t* = ADDRESS;
  125. Mutex_t* = ADDRESS;
  126. MutexType = ARRAY 8 OF ADDRESS;
  127. (*
  128. Mutex = ARRAY 8 OF ADDRESS;
  129. Mutex_t* = POINTER TO Mutex;
  130. *)
  131. Condition_t* = ADDRESS;
  132. ConditionType = ARRAY 12 OF WORD;
  133. Sigset_t= ARRAY 32 OF ADDRESS;
  134. SignalHandler = PROCEDURE ( sig: LONGINT; scp, ucp, dum: ADDRESS );
  135. MutexAttributeType = ARRAY 1 OF WORD;
  136. CONST
  137. (* Thread priorities *)
  138. ThreadLow* = 1; ThreadNormal* = 20; ThreadHigh* = 99;
  139. NumPriorities* = 99; (* number of priority levels *)
  140. (*---------------------------- IP -----------------------------------*)
  141. CONST
  142. (* domain *)
  143. AFINET* = 2;
  144. AFINET6* = 26;
  145. PFINET* = AFINET;
  146. PFINET6* = AFINET6;
  147. (* types of connection*)
  148. SockStream* = 1;
  149. SockDGram* = 2;
  150. (* Protocols *)
  151. IpProtoUDP* = 17;
  152. IpProtoTCP* = 6;
  153. (* setsockopt *)
  154. SoLSocket* = 1; (* socket option level *)
  155. SoLinger* = 13; (* linger (gracefully close the connection)*)
  156. SoKeepAlive* = 9; (* keep connection alive *)
  157. SoNoDelay* = 1; (* no delay *)
  158. (* ioctl *)
  159. FioNRead* = 541BH; (* something to read ? *)
  160. (* recv *)
  161. MsgPeek* = 2;
  162. MsgDontWait* = 40H; (* non blocking read *)
  163. (* shutdown *)
  164. ShutRDWR* = 2;
  165. SockAddrSizeV4* = 16;
  166. SockAddrSizeV6* = 28;
  167. (*----------------------- seral line, cf Unix.V24.Mod -----------------------*)
  168. FIONREAD* = 541BH;
  169. TIOCMGET* = 5415H;
  170. TIOCMBIS* = 5416H;
  171. TIOCMBIC* = 5417H;
  172. TIOCMSET* = 5418H;
  173. (* speeds *)
  174. B0* = 0;
  175. B50* = 1;
  176. B75* = 2;
  177. B110* = 3;
  178. B134* = 4;
  179. B150* = 5;
  180. B200* = 6;
  181. B300* = 7;
  182. B600* = 8;
  183. B1200* = 9;
  184. B1800* = 10;
  185. B2400* = 11;
  186. B4800* = 12;
  187. B9600* = 13;
  188. B19200* = 14;
  189. B38400* = 15;
  190. B57600* = 1001H;
  191. B115200* = 1002H;
  192. B230400* = 1003H;
  193. (* tio.cflag bits *)
  194. CSIZE* = {4,5};
  195. CS5* = {};
  196. CS6* = {4};
  197. CS7* = {5};
  198. CS8* = {4,5};
  199. CSTOPB* = {6};
  200. CREAD* = {7};
  201. PARENB* = {8};
  202. PARODD* = {9};
  203. HUPCL* = {10};
  204. CLOCAL* = {11};
  205. (*
  206. PTRACE_TRACEME = 0;
  207. PTRACE_PEEKTEXT = 1;
  208. PTRACE_PEEKDATA = 2;
  209. PTRACE_PEEKUSR = 3;
  210. PTRACE_POKETEXT = 4;
  211. PTRACE_POKEDATA = 5;
  212. PTRACE_POKEUSR = 6;
  213. PTRACE_CONT = 7;
  214. PTRACE_KILL = 8;
  215. PTRACE_SINGLESTEP = 9;
  216. PTRACE_ATTACH = 16;
  217. PTRACE_DETACH = 17;
  218. PTRACE_GETREGS = 12;
  219. PTRACE_SETREGS = 13;
  220. *)
  221. TYPE
  222. Termios* = RECORD
  223. iflags*, oflags*, cflags*, lflags*: SET;
  224. line*: CHAR;
  225. cc* : ARRAY 32 OF CHAR;
  226. ispeed-, ospeed-: LONGINT
  227. END;
  228. (*------------------------------------------------------------------*)
  229. TYPE
  230. DevT* = HUGEINT;
  231. Status* = RECORD
  232. dev- : DevT;
  233. unused1- : LONGINT;
  234. ino- : LONGINT;
  235. mode- : LONGINT;
  236. nlink- : LONGINT;
  237. uid- : LONGINT;
  238. gid- : LONGINT;
  239. rdev- : DevT;
  240. unused2- : LONGINT;
  241. size- : LONGINT;
  242. blksize- : LONGINT;
  243. blocks- : LONGINT;
  244. atime- : Timeval;
  245. mtime- : Timeval;
  246. ctime- : Timeval;
  247. unused- : ARRAY 2 OF LONGINT;
  248. END;
  249. tvPtr* = POINTER TO Timeval;
  250. Timeval* = RECORD
  251. sec* : LONGINT;
  252. usec* : LONGINT
  253. END;
  254. TmPtr* = POINTER TO Tm;
  255. Tm* = RECORD
  256. sec*, min*, hour*, mday*, mon*, year*, wday*, yday*, isdst*: LONGINT;
  257. gmtoff*, tmzone*: LONGINT;
  258. END;
  259. Tms* = POINTER TO RECORD
  260. utime*, stime*, cutime*, cstime*: LONGINT
  261. END;
  262. Timezone* = RECORD
  263. minuteswest*, dsttime*: LONGINT
  264. END;
  265. Itimerval* = RECORD
  266. interval*, value*: Timeval
  267. END;
  268. CONST
  269. FdSetLen* = 32;
  270. TYPE
  271. FdSet* = ARRAY FdSetLen OF SET;
  272. Dirent* = POINTER TO RECORD
  273. ino-, off- : LONGINT; (* these may change to HUGEINT in future Linux releases!! *)
  274. reclen- : INTEGER;
  275. typ- : CHAR;
  276. name- : (*array of*) CHAR;
  277. END;
  278. Stack* = RECORD
  279. sp* : ADDRESS;
  280. flags* : SET;
  281. size* : SIZE
  282. END;
  283. Ucontext* = POINTER TO UcontextDesc;
  284. UcontextDesc* = RECORD
  285. flags- : SET;
  286. link- : ADDRESS;
  287. stack- : Stack;
  288. mc- : McontextDesc
  289. END;
  290. Mcontext* = POINTER TO McontextDesc;
  291. McontextDesc* = RECORD
  292. r_gs- : ADDRESS;
  293. r_fs- : ADDRESS;
  294. r_es- : ADDRESS;
  295. r_ds- : ADDRESS;
  296. r_di- : ADDRESS;
  297. r_si- : ADDRESS;
  298. r_bp * : ADDRESS;
  299. r_sp_x- : ADDRESS;
  300. r_bx- : ADDRESS;
  301. r_dx- : ADDRESS;
  302. r_cx- : ADDRESS;
  303. r_ax- : ADDRESS;
  304. r_trapno- : LONGINT;
  305. r_err- : LONGINT;
  306. r_pc * : ADDRESS;
  307. r_cs- : ADDRESS;
  308. r_flags- : LONGINT;
  309. r_sp * : ADDRESS; (* sp at error (signal) *)
  310. r_ss- : LONGINT;
  311. fpc- : ADDRESS; (* FPcontext *)
  312. oldmask- : LONGINT;
  313. cr2- : LONGINT
  314. END;
  315. FPcontext* = POINTER TO FPcontextDesc;
  316. FPcontextDesc* = RECORD
  317. (* ... *)
  318. END;
  319. PThreadAttr = RECORD
  320. reserved1-: ARRAY 5 OF ADDRESS;
  321. reserved2-: ARRAY 4 OF WORD;
  322. END;
  323. PtraceRegsStruct = RECORD
  324. ebx, ecx, edx, esi, edi, ebp, eax: WORD;
  325. DS, ES, FS, GS, AX, IP, CS: WORD;
  326. flags: SET;
  327. esp: WORD;
  328. ss: WORD;
  329. END;
  330. Sigaction = RECORD
  331. sa_handler: ADDRESS;
  332. (*filler1: ADDRESS;*)
  333. sa_mask: Sigset_t;
  334. sa_flags: ADDRESS;
  335. filler: ADDRESS;
  336. END;
  337. Sched_param = RECORD
  338. sched_priority: LONGINT;
  339. safety: ARRAY 8 OF ADDRESS;
  340. END;
  341. VAR
  342. suspend_mutex: MutexType;
  343. mainthread: Thread_t;
  344. suspend_done: LONGINT;
  345. resume_done: LONGINT;
  346. sasuspend, saresume: Sigaction;
  347. argc-: LONGINT; argv-: ADDRESS; environ-: ADDRESS;
  348. sysinfo-: RECORD
  349. sysname-, nodename-, release-, version-, machine-: ARRAY 65 OF CHAR;
  350. END;
  351. sigstack-: ARRAY 32*4096 OF CHAR;
  352. ptrace: PROCEDURE {C} (request: WORD; pid: Thread_t; adr, data: ADDRESS): WORD;
  353. getcontext-: PROCEDURE {C} (context: ADDRESS): WORD;
  354. sysconf: PROCEDURE {C} (name: LONGINT):WORD;
  355. pthread_mutex_init: PROCEDURE {C} (mutex: ADDRESS; mutexattr: ADDRESS): WORD;
  356. pthread_mutex_destroy: PROCEDURE {C} (mutex: ADDRESS): WORD;
  357. pthread_mutex_lock: PROCEDURE {C} (mutex: ADDRESS): WORD;
  358. pthread_mutex_unlock: PROCEDURE {C} (mutex: ADDRESS): WORD;
  359. pthread_mutexattr_init: PROCEDURE {C} (mutexattr: ADDRESS): WORD;
  360. pthread_mutexattr_settype: PROCEDURE {C} (mutexattr: ADDRESS; type: WORD): WORD;
  361. pthread_cond_init: PROCEDURE {C} (cond: ADDRESS; condAttr: ADDRESS): WORD;
  362. pthread_cond_destroy: PROCEDURE {C} (cond: ADDRESS): WORD;
  363. pthread_cond_wait: PROCEDURE {C} (cond: ADDRESS; mutex: ADDRESS): WORD;
  364. pthread_cond_signal: PROCEDURE {C} (cond: ADDRESS): WORD;
  365. pthread_create: PROCEDURE {C} (newthread: ADDRESS; attr: ADDRESS; start_routine: PROCEDURE {C} (arg: PROCEDURE):ADDRESS; arg:PROCEDURE): WORD;
  366. pthread_exit: PROCEDURE {C} (thr: ADDRESS);
  367. pthread_detach: PROCEDURE {C} (thr: ADDRESS);
  368. pthread_kill: PROCEDURE {C} (thr: ADDRESS; sigid: LONGINT): LONGINT;
  369. pthread_cancel: PROCEDURE {C} (thr: ADDRESS);
  370. pthread_attr_init: PROCEDURE {C} (attr: ADDRESS);
  371. pthread_attr_setscope: PROCEDURE {C}(attr: ADDRESS; set: WORD);
  372. pthread_attr_setdetachstate: PROCEDURE {C}(attr: ADDRESS; set: WORD);
  373. pthread_attr_setstacksize: PROCEDURE {C}(attr: ADDRESS; stackSize: SIZE);
  374. pthread_self: PROCEDURE {C} (): Thread_t;
  375. sched_get_priority_max: PROCEDURE {C} (policy: LONGINT): LONGINT;
  376. sched_get_priority_min: PROCEDURE {C} (policy: LONGINT): LONGINT;
  377. pthread_setschedparam: PROCEDURE {C} (thread: Thread_t; policy: LONGINT; param: ADDRESS): WORD;
  378. pthread_getschedparam: PROCEDURE {C} (thread: Thread_t; policy: LONGINT; param: ADDRESS): WORD;
  379. pthread_setcancelstate: PROCEDURE {C} (state: LONGINT; oldstate: ADDRESS): LONGINT;
  380. pthread_setcanceltype: PROCEDURE {C} (type: LONGINT; oldtype: ADDRESS): LONGINT;
  381. sigaction: PROCEDURE {C} (signum: LONGINT; CONST act, oldact: ADDRESS): LONGINT;
  382. sigemptyset: PROCEDURE {C} (set: ADDRESS);
  383. sigfillset: PROCEDURE {C} (set: ADDRESS): LONGINT;
  384. sigsuspend: PROCEDURE {C} (set: ADDRESS): LONGINT;
  385. sigaddset: PROCEDURE {C} (set: ADDRESS; signo: LONGINT);
  386. sigdelset: PROCEDURE {C} (set: ADDRESS; signo: LONGINT);
  387. nanosleep: PROCEDURE {C} (req, rem: ADDRESS): LONGINT;
  388. sigaltstack: PROCEDURE {C} (ss, oss: ADDRESS): LONGINT;
  389. pthread_sigmask: PROCEDURE {C}(how: LONGINT; set: ADDRESS; oldset: ADDRESS): LONGINT;
  390. (*pid: return param for process id. Only set if initialized non-null. path: pointer to string denoting the executable. file_actions: modify which files are open for the new process, if NIL it inherits open files from parent process. attrp: sets process groups, scheduler, signals etc, leave NIL. argv, evp: char** to the arguments and env. variables*)
  391. posix_spawnp- : PROCEDURE{C}(pid: ADDRESS; path: ADDRESS; file_actions: ADDRESS; attrp: ADDRESS; argv: ADDRESS ; envp: ADDRESS): LONGINT;
  392. (*more restrictive than spawnp*)
  393. posix_spawn- : PROCEDURE{C}(pid: ADDRESS; path: ADDRESS; file_actions: ADDRESS; attrp: ADDRESS; argv: ADDRESS ; envp: ADDRESS): LONGINT;
  394. waitpid- : PROCEDURE{C}(pid: pid_t; status: ADDRESS; options: LONGINT): pid_t;
  395. pipe- :PROCEDURE{C}(pipefd: ADDRESS): LONGINT; (*pipefd is assumed to be a pointer to a C array of 2 elements, after pipe creation the array will contain file descriptors for the input and output end of the pipe. returns 0 on success, or -1 on fail*)
  396. dup2- :PROCEDURE{C}(oldfd,newfd: LONGINT): LONGINT; (*overwrites file descriptor newfd with a copy of oldfd. useful for redirecting pipes.*)
  397. dup- :PROCEDURE{C}(oldfd: LONGINT): LONGINT;
  398. read- : PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): LONGINT;
  399. write- : PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): LONGINT;
  400. open- : PROCEDURE {C} ( name: ADDRESS; flags, mode: SET ): LONGINT;
  401. close- : PROCEDURE {C} ( fd: LONGINT ): LONGINT;
  402. lseek- : PROCEDURE {C} ( fd: LONGINT; offset, origin: SIZE ): LONGINT;
  403. fsync- : PROCEDURE {C} ( fd: LONGINT ): LONGINT;
  404. ioctl- : PROCEDURE {C} ( fd: LONGINT; request: LONGINT; arg: ADDRESS ): LONGINT;
  405. unlink- : PROCEDURE {C} ( name: ADDRESS ): LONGINT;
  406. rename- : PROCEDURE {C} ( oldname, newname: ADDRESS ): LONGINT;
  407. ftruncate- : PROCEDURE {C} ( fd: LONGINT; length: SIZE ): LONGINT;
  408. chmod- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  409. utime- : PROCEDURE {C} ( name: ADDRESS; tb: ADDRESS ): LONGINT;
  410. access- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  411. select- : PROCEDURE {C} ( width: LONGINT; rd, wr, ex: ADDRESS; VAR timeout: Timeval ): LONGINT;
  412. realpath- : PROCEDURE {C} (file_name: ADDRESS; resolved_name: ADDRESS): ADDRESS;
  413. chdir- : PROCEDURE {C} ( name: ADDRESS ): LONGINT;
  414. mkdir- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  415. rmdir- : PROCEDURE {C} ( path: ADDRESS ): LONGINT;
  416. xstat- : PROCEDURE {C} ( ver: LONGINT; name: ADDRESS; VAR buf: Status ): LONGINT;
  417. lxstat- : PROCEDURE {C} ( ver: LONGINT; name: ADDRESS; VAR buf: Status ): LONGINT;
  418. fxstat- : PROCEDURE {C} ( ver: LONGINT; fd: LONGINT; VAR buf: Status ): LONGINT;
  419. getpid- : PROCEDURE {C} ( ): LONGINT;
  420. getuid- : PROCEDURE {C} ( ): LONGINT;
  421. malloc- : PROCEDURE {C} ( size: SIZE ): ADDRESS;
  422. posix_memalign- : PROCEDURE {C} ( VAR p: ADDRESS; alignment, size: SIZE ): LONGINT;
  423. free- : PROCEDURE {C} ( p: ADDRESS );
  424. mprotect- : PROCEDURE {C} ( p: ADDRESS; len: SIZE; prot: LONGINT ): LONGINT;
  425. alarm- : PROCEDURE {C} ( ms: LONGINT ): LONGINT;
  426. setitimer- : PROCEDURE {C} ( which: LONGINT; VAR value, ovalue: Itimerval ): LONGINT;
  427. getitimer- : PROCEDURE {C} ( which: LONGINT; VAR value: Itimerval ): LONGINT;
  428. clock_gettime- : PROCEDURE{C} (clk_id: LONGINT; tp: tvPtr): LONGINT;
  429. gettimeofday- : PROCEDURE {C} ( VAR tv: Timeval; VAR tz: Timezone ): LONGINT;
  430. mktime- : PROCEDURE {C} ( VAR tm: Tm ): LONGINT;
  431. localtime- : PROCEDURE {C} ( CONST tv: Timeval ): TmPtr;
  432. time- : PROCEDURE {C} ( VAR tv: Timeval ): LONGINT;
  433. times- : PROCEDURE {C} ( VAR tms: Tms ): LONGINT;
  434. system- : PROCEDURE {C} ( cmd: ADDRESS );
  435. uname- : PROCEDURE {C} ( utsname: ADDRESS ): LONGINT;
  436. getcwd- : PROCEDURE {C} ( buf: ADDRESS; len: SIZE ): ADDRESS;
  437. getenv- : PROCEDURE {C} ( name: ADDRESS ): ADDRESS;
  438. opendir- : PROCEDURE {C} ( name: ADDRESS ): ADDRESS;
  439. readdir- : PROCEDURE {C} ( dir: ADDRESS ): Dirent;
  440. closedir- : PROCEDURE {C} ( dir: ADDRESS );
  441. sigsetjmp- : PROCEDURE {C} ( env: ADDRESS; savemask: LONGINT ): LONGINT;
  442. siglongjmp- : PROCEDURE {C} ( env: ADDRESS; val: LONGINT );
  443. kill- : PROCEDURE {C} ( pid, sig: LONGINT ): LONGINT;
  444. exit- : PROCEDURE {C} ( status: LONGINT );
  445. perror- : PROCEDURE {C} ( msg: ADDRESS );
  446. errno_location: PROCEDURE {C} ( ): ADDRESS;
  447. xSetErrorHandler: PROCEDURE {C} (h: ADDRESS): WORD;
  448. xSetIOErrorHandler: PROCEDURE {C} (h: ADDRESS): WORD;
  449. libc-: LONGINT;
  450. libp-: LONGINT;
  451. libx-: LONGINT;
  452. libraryPaths: ARRAY 8 OF ARRAY 32 OF CHAR;
  453. noPaths: LONGINT;
  454. (*
  455. mtxInit: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Mutex_t;
  456. mtxDestroy: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  457. mtxLock: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  458. mtxUnlock: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  459. conInit: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Condition_t;
  460. conDestroy: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t );
  461. conWait: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t; mtx: Unix.Mutex_t );
  462. conSignal: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t );
  463. thrStart: PROCEDURE {REALTIME, C} ( p: PROCEDURE; stackLen: LONGINT ): Unix.Thread_t;
  464. thrThis: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Thread_t;
  465. thrSleep: PROCEDURE {REALTIME, C} ( ms: LONGINT );
  466. thrYield: PROCEDURE {REALTIME, C} ( dummy: LONGINT );
  467. thrExit: PROCEDURE {REALTIME, C} ( dummy: LONGINT );
  468. thrSuspend: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  469. thrResume: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  470. thrSetPriority: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t; prio: LONGINT );
  471. thrGetPriority: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t ): LONGINT;
  472. thrKill: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  473. *)
  474. TYPE
  475. PROCEDURE getnprocs* (): LONGINT;
  476. BEGIN
  477. RETURN sysconf(0x54); (*0x53 for number of processors configured, 0x54 for number of processors online *)
  478. END getnprocs;
  479. PROCEDURE MtxInit*(dummy: LONGINT): Mutex_t;
  480. VAR
  481. mtx: Mutex_t;
  482. BEGIN
  483. mtx := malloc(SIZEOF(MutexType));
  484. ASSERT(mtx # 0);
  485. ASSERT(pthread_mutex_init(mtx, NIL) = 0);
  486. RETURN mtx;
  487. END MtxInit;
  488. PROCEDURE RecursiveMtxInit*(dummy: LONGINT): Mutex_t;
  489. VAR
  490. mtx: Mutex_t;
  491. attr: MutexAttributeType;
  492. res: WORD;
  493. CONST
  494. Recursive = 1;
  495. BEGIN
  496. mtx := malloc(SIZEOF(MutexType));
  497. res := pthread_mutexattr_init(ADDRESS OF attr);
  498. res := pthread_mutexattr_settype(ADDRESS OF attr, Recursive);
  499. ASSERT(mtx # 0);
  500. ASSERT(pthread_mutex_init(mtx, ADDRESS OF attr) = 0);
  501. RETURN mtx;
  502. END RecursiveMtxInit;
  503. PROCEDURE MtxDestroy*(mtx: Mutex_t);
  504. BEGIN
  505. ASSERT(pthread_mutex_destroy(mtx) = 0);
  506. END MtxDestroy;
  507. PROCEDURE MtxLock*(mtx: Mutex_t);
  508. BEGIN
  509. ASSERT(pthread_mutex_lock(mtx) = 0);
  510. END MtxLock;
  511. PROCEDURE MtxUnlock*(mtx: Mutex_t);
  512. BEGIN
  513. ASSERT(pthread_mutex_unlock(mtx) = 0);
  514. END MtxUnlock;
  515. PROCEDURE ConInit* (dummy: LONGINT): Condition_t;
  516. VAR cond: Condition_t;
  517. BEGIN
  518. cond := malloc(SIZEOF(ConditionType));
  519. ASSERT(cond # 0);
  520. ASSERT(pthread_cond_init(cond, NIL)=0);
  521. RETURN cond;
  522. END ConInit;
  523. PROCEDURE ConDestroy*(con: Condition_t);
  524. BEGIN
  525. ASSERT(pthread_cond_destroy(con) = 0);
  526. END ConDestroy;
  527. PROCEDURE ConWait*(con: Condition_t; mtx: Mutex_t);
  528. BEGIN
  529. ASSERT(pthread_cond_wait(con, mtx) = 0);
  530. END ConWait;
  531. PROCEDURE ConSignal*(cond: Condition_t);
  532. BEGIN
  533. ASSERT(pthread_cond_signal(cond) = 0);
  534. END ConSignal;
  535. PROCEDURE ThrThis*(dummy: LONGINT): Thread_t;
  536. BEGIN
  537. RETURN pthread_self();
  538. END ThrThis;
  539. PROCEDURE ThrYield*(dummy: LONGINT);
  540. BEGIN
  541. ThrSleep(1);
  542. END ThrYield;
  543. PROCEDURE ThrExit*(dummy: LONGINT);
  544. BEGIN
  545. pthread_exit(0);
  546. END ThrExit;
  547. PROCEDURE ThrSetPriority*(thr: Thread_t; prio: LONGINT);
  548. VAR
  549. param: Sched_param;
  550. policy: LONGINT;
  551. BEGIN
  552. IF pthread_getschedparam( thr, ADDRESS OF policy, ADDRESS OF param ) # 0 THEN END;
  553. param.sched_priority := prio;
  554. IF pthread_setschedparam( thr, SCHED_OTHER, ADDRESS OF param ) # 0 THEN
  555. Perror("pthread_setschedparam");
  556. END
  557. END ThrSetPriority;
  558. PROCEDURE ThrGetPriority*(thr: Thread_t):LONGINT;
  559. VAR
  560. param: Sched_param;
  561. policy: LONGINT;
  562. BEGIN
  563. IF pthread_getschedparam( thr, ADDRESS OF policy, ADDRESS OF param ) # 0 THEN END;
  564. RETURN param.sched_priority;
  565. END ThrGetPriority;
  566. VAR
  567. sigstk: Stack;
  568. PROCEDURE SetSigaltstack;
  569. BEGIN
  570. IF sigaltstack(ADDRESS OF sigstk, NIL) < 0 THEN
  571. Perror("sigaltstack")
  572. END;
  573. END SetSigaltstack;
  574. PROCEDURE {C} Starter(proc: PROCEDURE): ADDRESS;
  575. VAR
  576. me: Thread_t;
  577. old, new: Sigset_t;
  578. param: Sched_param;
  579. res: LONGINT;
  580. BEGIN
  581. me := pthread_self();
  582. SetSigaltstack();
  583. IF sigfillset( ADDRESS OF new ) < 0 THEN
  584. Perror("sigfillset");
  585. END;
  586. sigdelset( ADDRESS OF new, SIGILL );
  587. sigdelset( ADDRESS OF new, SIGTRAP );
  588. sigdelset( ADDRESS OF new, SIGFPE );
  589. sigdelset( ADDRESS OF new, SIGBUS );
  590. sigdelset( ADDRESS OF new, SIGSEGV );
  591. sigdelset( ADDRESS OF new, SIGTERM );
  592. sigdelset( ADDRESS OF new, T_SIGSUSPEND );
  593. res := pthread_sigmask( SIG_SETMASK, ADDRESS OF new, ADDRESS OF old );
  594. res := pthread_setcancelstate( PTHREAD_CANCEL_ENABLE, NIL );
  595. res := pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NIL );
  596. param.sched_priority := 0;
  597. res := pthread_setschedparam( me, SCHED_OTHER, ADDRESS OF param );
  598. proc();
  599. pthread_exit( NIL );
  600. RETURN NIL;
  601. END Starter;
  602. PROCEDURE ThrStart*(p: PROCEDURE; stackSize: SIZE): Thread_t;
  603. VAR
  604. attr: PThreadAttr;
  605. id: Thread_t;
  606. res,i: LONGINT;
  607. CONST
  608. PTHREAD_SCOPE_SYSTEM = 0;
  609. PTHREAD_CREATE_DETACHED = 1;
  610. BEGIN
  611. pthread_attr_init(ADDRESS OF attr);
  612. pthread_attr_setscope(ADDRESS OF attr, PTHREAD_SCOPE_SYSTEM);
  613. pthread_attr_setdetachstate(ADDRESS OF attr, PTHREAD_CREATE_DETACHED);
  614. (*pthread_attr_setdetachstate(ADDRESS OF attr, 0);*)
  615. pthread_attr_setstacksize(ADDRESS OF attr, stackSize);
  616. res := pthread_create(ADDRESS OF id, ADDRESS OF attr, Starter, p);
  617. RETURN id;
  618. END ThrStart;
  619. PROCEDURE ThrSleep*(ms: LONGINT);
  620. VAR
  621. sltime,rem: RECORD
  622. tv_sec: WORD; (* seconds *)
  623. tv_nsec: WORD; (* nanoseconds *)
  624. END;
  625. BEGIN
  626. sltime.tv_sec := ms DIV 1000;
  627. sltime.tv_nsec := 1000000*(ms MOD 1000);
  628. WHILE (nanosleep(ADDRESS OF sltime, ADDRESS OF rem) < 0) DO
  629. (* check error ! *)
  630. sltime := rem;
  631. END;
  632. END ThrSleep;
  633. PROCEDURE ThrKill*(thr: Thread_t);
  634. BEGIN
  635. IF (thr # mainthread) THEN
  636. pthread_detach( thr );
  637. IF (thr = pthread_self()) THEN
  638. pthread_exit( 0 );
  639. ELSE
  640. pthread_cancel( thr );
  641. END
  642. END;
  643. END ThrKill;
  644. (* did not work
  645. PROCEDURE TraceThread*(p: Thread_t);
  646. VAR regs: PtraceRegsStruct; res: WORD;
  647. BEGIN
  648. res := ptrace(PTRACE_ATTACH, p , NIL, NIL);
  649. IF res < 0 THEN Perror("attach") END;
  650. TRACE(res);
  651. res := ptrace(PTRACE_GETREGS,p,NIL, ADDRESS OF regs);
  652. IF res < 0 THEN Perror("getregs") END;
  653. TRACE(res);
  654. TRACE(regs.ebx, regs.ecx, regs.edx, regs.eax);
  655. TRACE(regs.ebp, regs.esp, regs.IP, regs.flags);
  656. res := ptrace(PTRACE_DETACH, p, NIL, NIL);
  657. END TraceThread;
  658. *)
  659. PROCEDURE {C} resume_handler(sig: LONGINT);
  660. BEGIN
  661. END resume_handler;
  662. PROCEDURE ThrResume*(thr: Thread_t);
  663. VAR n: LONGINT; res: LONGINT;
  664. BEGIN
  665. res := pthread_mutex_lock( ADDRESS OF suspend_mutex );
  666. resume_done := 0; n := 1;
  667. res := pthread_kill( thr, T_SIGRESUME );
  668. (* WHILE (resume_done # 1) & (n < 50) DO ThrSleep(1); INC(n) END; *)
  669. WHILE (resume_done # 1) DO ThrSleep(1); END;
  670. res := pthread_mutex_unlock( ADDRESS OF suspend_mutex );
  671. END ThrResume;
  672. VAR suspendHandler*: PROCEDURE(c: Ucontext);
  673. PROCEDURE {C} suspend_handler(sig: LONGINT; scp: ADDRESS; ucp: ADDRESS);
  674. VAR block: Sigset_t; res: LONGINT;
  675. BEGIN
  676. IF suspendHandler # NIL THEN suspendHandler(S.VAL(Ucontext,ucp)) END;
  677. res := sigfillset( ADDRESS OF block );
  678. sigdelset( ADDRESS OF block, T_SIGRESUME );
  679. suspend_done := 1; (*this is ok because ThrSuspend is protected by a mutex*)
  680. res := sigsuspend( ADDRESS OF block ); (* await T_SIGRESUME *)
  681. resume_done := 1;
  682. END suspend_handler;
  683. PROCEDURE ThrSuspend*(thr: Thread_t);
  684. VAR res: LONGINT;
  685. BEGIN
  686. res := pthread_mutex_lock(ADDRESS OF suspend_mutex );
  687. suspend_done := 0;
  688. res := pthread_kill( thr, T_SIGSUSPEND );
  689. WHILE (suspend_done # 1) DO ThrSleep( 1 ) END;
  690. res := pthread_mutex_unlock( ADDRESS OF suspend_mutex );
  691. END ThrSuspend;
  692. PROCEDURE ThrInitialize*(VAR low, high: LONGINT): BOOLEAN;
  693. VAR
  694. param: Sched_param;
  695. BEGIN
  696. (*struct sched_param param;*)
  697. ASSERT(pthread_mutex_init( ADDRESS OF suspend_mutex, NIL ) = 0);
  698. mainthread := pthread_self();
  699. high := sched_get_priority_max(SCHED_OTHER);
  700. low := sched_get_priority_min(SCHED_OTHER);
  701. param.sched_priority := high;
  702. IF pthread_setschedparam( mainthread, SCHED_OTHER, ADDRESS OF param)#0 THEN
  703. Perror("ThrInitialize: setparam");
  704. END;
  705. sigemptyset( ADDRESS OF sasuspend.sa_mask );
  706. sigaddset( ADDRESS OF sasuspend.sa_mask, T_SIGRESUME );
  707. sasuspend.sa_flags := SA_SIGINFO + (*SA_ONSTACK +*) SA_NODEFER;;
  708. sasuspend.sa_handler := suspend_handler;
  709. ASSERT(sigaction( T_SIGSUSPEND, ADDRESS OF sasuspend, NIL ) = 0);
  710. sigemptyset( ADDRESS OF saresume.sa_mask );
  711. saresume.sa_flags := 0;
  712. saresume.sa_handler := resume_handler;
  713. ASSERT(sigaction( T_SIGRESUME, ADDRESS OF saresume, NIL ) = 0);
  714. RETURN TRUE;
  715. END ThrInitialize;
  716. PROCEDURE CopyContext*(CONST from: McontextDesc; VAR to: McontextDesc);
  717. BEGIN
  718. S.MOVE(ADDRESS OF from, ADDRESS OF to, SIZE OF McontextDesc);
  719. END CopyContext;
  720. PROCEDURE ModifyContext*( cont: Ucontext; pc, bp, sp: LONGINT );
  721. BEGIN
  722. cont.mc.r_pc := pc;
  723. cont.mc.r_bp := bp;
  724. cont.mc.r_sp := sp;
  725. END ModifyContext;
  726. PROCEDURE Perror*( CONST msg: ARRAY OF CHAR );
  727. BEGIN
  728. perror( ADDRESSOF( msg ) )
  729. END Perror;
  730. PROCEDURE Dlsym*( lib: ADDRESS; CONST sym: ARRAY OF CHAR; objAddr: ADDRESS );
  731. VAR val: LONGINT;
  732. BEGIN
  733. Glue.Dlsym( lib, sym, objAddr );
  734. S.GET( objAddr, val );
  735. IF val = 0 THEN
  736. Trace.String( "Unix.Dlsym: entry '" ); Trace.String( sym ); Trace.String( "' not found" );
  737. Trace.Ln;
  738. exit(0);
  739. END
  740. END Dlsym;
  741. PROCEDURE Dlopen*( CONST libname: ARRAY OF CHAR; mode: LONGINT ): ADDRESS;
  742. VAR h: ADDRESS; i, j, k: INTEGER;
  743. p: ARRAY 256 OF CHAR;
  744. BEGIN
  745. IF libname[0] = '/' THEN h := Glue.dlopen( ADDRESSOF( libname ), mode );
  746. ELSE
  747. i := 0; h := 0;
  748. WHILE (h = 0) & (i < noPaths) DO
  749. COPY( libraryPaths[i], p ); j := 0;
  750. WHILE p[j] # 0X DO INC( j ) END;
  751. p[j] := '/'; k := 0;
  752. REPEAT INC( j ); p[j] := libname[k]; INC( k ) UNTIL p[j] = 0X;
  753. h := Glue.dlopen( ADDRESSOF( p ), mode ); INC( i )
  754. END
  755. END;
  756. IF h = 0 THEN
  757. Trace.String( "Unix.Dlopen: loading library " );
  758. Trace.String( libname ); Trace.String( " failed" ); Trace.Ln;
  759. LOOP END;
  760. END;
  761. RETURN h
  762. END Dlopen;
  763. PROCEDURE Dlclose*( lib: ADDRESS );
  764. BEGIN
  765. Glue.dlclose( lib )
  766. END Dlclose;
  767. PROCEDURE GetArg*( no: LONGINT; VAR val: ARRAY OF CHAR );
  768. VAR ch: CHAR; adr: ADDRESS; i: LONGINT;
  769. BEGIN
  770. IF no >= argc THEN val[0] := 0X
  771. ELSE
  772. S.GET( argv + SIZEOF(ADDRESS)*no, adr ); i := 0;
  773. REPEAT S.GET( adr, ch ); val[i] := ch; INC( adr ); INC( i ); UNTIL (ch = 0X) OR (i >= LEN( val ));
  774. END
  775. END GetArg;
  776. PROCEDURE GetArgval*( CONST argName: ARRAY OF CHAR; VAR val: ARRAY OF CHAR );
  777. VAR i: INTEGER;
  778. buf: ARRAY 40 OF CHAR;
  779. BEGIN
  780. i := 1;
  781. WHILE i < argc - 1 DO
  782. GetArg( i, buf );
  783. IF buf = argName THEN GetArg( i + 1, val ); RETURN END;
  784. INC( i )
  785. END;
  786. val[0] := 0X
  787. END GetArgval;
  788. PROCEDURE getSysinfo;
  789. VAR res: LONGINT; p: INTEGER;
  790. buf: ARRAY 4096 OF CHAR;
  791. PROCEDURE copy( VAR p: INTEGER; VAR dest: ARRAY OF CHAR );
  792. VAR i: INTEGER;
  793. BEGIN
  794. WHILE buf[p] <= ' ' DO INC( p ) END;
  795. i := 0;
  796. REPEAT dest[i] := buf[p]; INC( i ); INC( p ) UNTIL (buf[p - 1] = 0X) OR (i >= LEN( dest ));
  797. dest[i - 1] := 0X
  798. END copy;
  799. BEGIN
  800. FOR p := 0 TO 4096 - 1 DO buf[p] := 0X END;
  801. res := uname( ADDRESSOF( buf ) );
  802. p := 0;
  803. copy( p, sysinfo.sysname );
  804. copy( p, sysinfo.nodename );
  805. copy( p, sysinfo.release );
  806. copy( p, sysinfo.version );
  807. copy( p, sysinfo.machine );
  808. END getSysinfo;
  809. PROCEDURE CreateSignalStack;
  810. BEGIN
  811. sigstk.sp := ADDRESS OF sigstack;
  812. sigstk.size := LEN(sigstack);
  813. sigstk.flags := {};
  814. END CreateSignalStack;
  815. (*
  816. static void sighandler( int sig, siginfo_t *scp, void *ucp ) {
  817. if (debug | (AosTrap == NULL)) {
  818. printf("\nhandler for signal %d got called, ucp = %p\n", sig, ucp);
  819. if (AosTrap == NULL) exit(1);
  820. }
  821. AosTrap(0, ucp, scp, sig); /* rev. order: Oberon <--> C */
  822. }
  823. *)
  824. VAR trap: SignalHandler;
  825. PROCEDURE {C} SigHandler ( sig: LONGINT; scp: ADDRESS; ucp: ADDRESS); (* reversed arguments !! *)
  826. BEGIN
  827. IF trap # NIL THEN
  828. trap(sig, scp, ucp, 0);
  829. ELSE
  830. TRACE(sig, scp, ucp)
  831. END;
  832. END SigHandler;
  833. PROCEDURE InstallSignalHandler* ( h: SignalHandler );
  834. BEGIN
  835. trap := h;
  836. END InstallSignalHandler;
  837. PROCEDURE InstallHandler(sig: LONGINT);
  838. VAR
  839. act: Sigaction;
  840. mask: Sigset_t;
  841. BEGIN
  842. sigemptyset(ADDRESS OF mask);
  843. act.sa_mask := mask;
  844. IF sig = SIGSEGV THEN (* segmentation violation *)
  845. act.sa_flags := SA_SIGINFO + SA_ONSTACK + SA_NODEFER;
  846. ELSE
  847. act.sa_flags := SA_SIGINFO + (* SA_ONSTACK + *) SA_NODEFER;
  848. END;
  849. act.sa_handler := ADDRESS OF SigHandler;
  850. IF sigaction( sig, ADDRESS OF act, 0 ) # 0 THEN
  851. Perror("sigaction");
  852. END;
  853. END InstallHandler;
  854. PROCEDURE fstat* ( fd: LONGINT; VAR buf: Status ): LONGINT;
  855. VAR res: LONGINT;
  856. BEGIN
  857. (*
  858. dev- : DevT;
  859. unused1- : LONGINT;
  860. ino- : LONGINT;
  861. mode- : LONGINT;
  862. nlink- : LONGINT;
  863. uid- : LONGINT;
  864. gid- : LONGINT;
  865. rdev- : DevT;
  866. unused2- : LONGINT;
  867. size- : LONGINT;
  868. blksize- : LONGINT;
  869. blocks- : LONGINT;
  870. atime- : Timeval;
  871. mtime- : Timeval;
  872. ctime- : Timeval;
  873. unused- : ARRAY 2 OF LONGINT;
  874. *)
  875. res := fxstat(3, fd, buf);
  876. RETURN res;
  877. END fstat;
  878. PROCEDURE stat* ( path: ADDRESS; VAR buf: Status ): LONGINT;
  879. BEGIN
  880. RETURN xstat( 3, path, buf );
  881. END stat;
  882. PROCEDURE InitSignalHandler;
  883. VAR i: LONGINT;
  884. BEGIN
  885. FOR i := 1 TO 15 DO
  886. IF i # 9 THEN InstallHandler(i) END;
  887. END;
  888. END InitSignalHandler;
  889. PROCEDURE errno*(): LONGINT;
  890. VAR loc: ADDRESS;
  891. BEGIN
  892. loc := errno_location();
  893. RETURN S.GET32(loc);
  894. END errno;
  895. TYPE OberonXErrorHandler* = PROCEDURE (disp, err: ADDRESS): LONGINT;
  896. TYPE OberonXIOErrorHandler* = PROCEDURE (disp: ADDRESS): LONGINT;
  897. VAR oberonXErrorHandler:OberonXErrorHandler;
  898. VAR oberonXIOErrorHandler: OberonXIOErrorHandler;
  899. TYPE pid_t *= LONGINT;
  900. TYPE path_t *= ARRAY OF CHAR;
  901. TYPE arg_t *= ARRAY OF CHAR;
  902. TYPE argv_t *= ARRAY OF arg_t;
  903. PROCEDURE {C} X11ErrorHandler(d: ADDRESS; err: ADDRESS): WORD;
  904. VAR res: LONGINT;
  905. BEGIN
  906. TRACE(d,err);
  907. IF oberonXErrorHandler # NIL THEN
  908. res := oberonXErrorHandler(d, err);
  909. END;
  910. RETURN 0;
  911. END X11ErrorHandler;
  912. PROCEDURE X11IOErrorHandler(d: ADDRESS): WORD;
  913. VAR res: LONGINT;
  914. BEGIN
  915. TRACE(d);
  916. IF oberonXIOErrorHandler # NIL THEN
  917. res := oberonXIOErrorHandler(d);
  918. END;
  919. RETURN 0;
  920. END X11IOErrorHandler;
  921. PROCEDURE InitXErrorHandlers*(xErrorHandler: OberonXErrorHandler; xIOErrorHandler: OberonXIOErrorHandler);
  922. VAR res: WORD;
  923. BEGIN
  924. oberonXErrorHandler := xErrorHandler;
  925. oberonXIOErrorHandler := xIOErrorHandler;
  926. res := xSetErrorHandler(ADDRESS OF X11ErrorHandler);
  927. res := xSetIOErrorHandler(ADDRESS OF X11IOErrorHandler);
  928. END InitXErrorHandlers;
  929. PROCEDURE Init;
  930. VAR test: ADDRESS; i: LONGINT; s: ARRAY 256 OF CHAR;
  931. BEGIN
  932. argc := Glue.argc;
  933. argv := Glue.argv;
  934. environ := Glue.environ;
  935. libraryPaths[0] := "/lib/i386-linux-gnu";
  936. libraryPaths[1] := "/usr/lib/i386-linux-gnu";
  937. libraryPaths[2] := "/lib";
  938. libraryPaths[3] := "/usr/lib";
  939. noPaths := 4;
  940. libc := Dlopen( libcname, 2 );
  941. libp := Dlopen( libpthreadname, 2);
  942. Dlsym( libc, "exit", ADDRESSOF( exit ) );
  943. Dlsym( libc, "ptrace", ADDRESSOF(ptrace));
  944. Dlsym( libc, "getcontext", ADDRESSOF(getcontext));
  945. Dlsym( libc, "sysconf", ADDRESSOF(sysconf));
  946. Dlsym( libc, "pthread_mutex_init", ADDRESSOF(pthread_mutex_init));
  947. Dlsym( libc, "pthread_mutex_destroy", ADDRESSOF(pthread_mutex_destroy));
  948. Dlsym( libc, "pthread_mutex_lock", ADDRESSOF(pthread_mutex_lock));
  949. Dlsym( libc, "pthread_mutex_unlock", ADDRESSOF(pthread_mutex_unlock));
  950. Dlsym( libp, "pthread_mutexattr_init", ADDRESSOF(pthread_mutexattr_init));
  951. Dlsym( libp, "pthread_mutexattr_settype", ADDRESSOF(pthread_mutexattr_settype));
  952. Dlsym( libc, "pthread_cond_init", ADDRESSOF(pthread_cond_init));
  953. Dlsym( libc, "pthread_cond_destroy", ADDRESSOF(pthread_cond_destroy));
  954. Dlsym( libc, "pthread_cond_wait", ADDRESSOF(pthread_cond_wait));
  955. Dlsym( libc, "pthread_cond_signal", ADDRESSOF(pthread_cond_signal));
  956. Dlsym( libp, "pthread_create", ADDRESSOF(pthread_create));
  957. Dlsym( libp, "pthread_exit", ADDRESSOF(pthread_exit));
  958. Dlsym( libp, "pthread_detach", ADDRESSOF(pthread_detach));
  959. Dlsym( libp, "pthread_cancel", ADDRESSOF(pthread_cancel));
  960. Dlsym( libp, "pthread_kill", ADDRESSOF(pthread_kill));
  961. Dlsym( libp, "pthread_sigmask", ADDRESSOF(pthread_sigmask));
  962. Dlsym( libp, "pthread_setcancelstate", ADDRESSOF(pthread_setcancelstate));
  963. Dlsym( libp, "pthread_setcanceltype", ADDRESSOF(pthread_setcanceltype));
  964. Dlsym( libp, "pthread_attr_init", ADDRESSOF(pthread_attr_init));
  965. Dlsym( libp, "pthread_attr_setscope", ADDRESSOF(pthread_attr_setscope));
  966. Dlsym( libp, "pthread_attr_setdetachstate", ADDRESSOF(pthread_attr_setdetachstate));
  967. Dlsym( libp, "pthread_attr_setstacksize", ADDRESSOF(pthread_attr_setstacksize));
  968. Dlsym( libp, "pthread_self", ADDRESSOF(pthread_self));
  969. Dlsym( libc, "posix_spawnp", ADDRESSOF(posix_spawnp));
  970. Dlsym( libc, "posix_spawn", ADDRESSOF(posix_spawn));
  971. Dlsym( libc, "waitpid", ADDRESSOF(waitpid));
  972. Dlsym( libc, "pipe", ADDRESSOF(pipe));
  973. Dlsym( libc, "dup2",ADDRESSOF(dup2));
  974. Dlsym( libc, "dup", ADDRESSOF(dup));
  975. Dlsym( libc, "sched_get_priority_max", ADDRESSOF(sched_get_priority_max));
  976. Dlsym( libc, "sched_get_priority_min", ADDRESSOF(sched_get_priority_min));
  977. Dlsym( libc, "pthread_setschedparam", ADDRESSOF(pthread_setschedparam));
  978. Dlsym( libc, "pthread_getschedparam", ADDRESSOF(pthread_getschedparam));
  979. Dlsym( libc, "sigaction", ADDRESSOF(sigaction));
  980. Dlsym( libc, "sigemptyset", ADDRESSOF(sigemptyset));
  981. Dlsym( libc, "sigfillset", ADDRESSOF(sigfillset));
  982. Dlsym( libc, "sigaddset", ADDRESSOF(sigaddset));
  983. Dlsym( libc, "sigdelset", ADDRESSOF(sigdelset));
  984. Dlsym( libc, "nanosleep", ADDRESSOF(nanosleep));
  985. Dlsym( libc, "sigaltstack", ADDRESSOF(sigaltstack));
  986. Dlsym( libc, "sigsuspend", ADDRESSOF(sigsuspend));
  987. Dlsym( libc, "read", ADDRESSOF( read ) );
  988. Dlsym( libc, "write", ADDRESSOF( write ) );
  989. Dlsym( libc, "open", ADDRESSOF( open ) );
  990. Dlsym( libc, "close", ADDRESSOF( close ) );
  991. Dlsym( libc, "lseek", ADDRESSOF( lseek ) );
  992. Dlsym( libc, "realpath", ADDRESSOF( realpath ) );
  993. Dlsym( libc, "fsync", ADDRESSOF( fsync ) );
  994. Dlsym( libc, "ioctl", ADDRESSOF( ioctl ) );
  995. Dlsym( libc, "unlink", ADDRESSOF( unlink ) );
  996. Dlsym( libc, "rename", ADDRESSOF( rename ) );
  997. Dlsym( libc, "ftruncate", ADDRESSOF( ftruncate ) );
  998. Dlsym( libc, "chmod", ADDRESSOF( chmod ) );
  999. Dlsym( libc, "utime", ADDRESSOF( utime ) );
  1000. Dlsym( libc, "access", ADDRESSOF( access ) );
  1001. Dlsym( libc, "select", ADDRESSOF( select ) );
  1002. Dlsym( libc, "chdir", ADDRESSOF( chdir ) );
  1003. Dlsym( libc, "mkdir", ADDRESSOF( mkdir ) );
  1004. Dlsym( libc, "rmdir", ADDRESSOF( rmdir ) );
  1005. Dlsym( libc, "__xstat", ADDRESSOF( xstat ) );
  1006. Dlsym( libc, "__lxstat", ADDRESSOF( lxstat ) );
  1007. Dlsym( libc, "__fxstat", ADDRESSOF( fxstat ) );
  1008. Dlsym( libc, "getpid", ADDRESSOF( getpid ) );
  1009. Dlsym( libc, "getuid", ADDRESSOF( getuid ) );
  1010. Dlsym( libc, "alarm", ADDRESSOF( alarm ) );
  1011. Dlsym( libc, "setitimer", ADDRESSOF( setitimer ) );
  1012. Dlsym( libc, "getitimer", ADDRESSOF( getitimer ) );
  1013. Dlsym( libc, "clock_gettime", ADDRESSOF(clock_gettime) );
  1014. Dlsym( libc, "gettimeofday", ADDRESSOF( gettimeofday ) );
  1015. Dlsym( libc, "mktime", ADDRESSOF( mktime ) );
  1016. Dlsym( libc, "localtime", ADDRESSOF( localtime ) );
  1017. Dlsym( libc, "time", ADDRESSOF( time ) );
  1018. Dlsym( libc, "times", ADDRESSOF( times ) );
  1019. Dlsym( libc, "getcwd", ADDRESSOF( getcwd ) );
  1020. Dlsym( libc, "getenv", ADDRESSOF( getenv ) );
  1021. Dlsym( libc, "opendir", ADDRESSOF( opendir ) );
  1022. Dlsym( libc, "readdir", ADDRESSOF( readdir ) );
  1023. Dlsym( libc, "closedir", ADDRESSOF( closedir ) );
  1024. Dlsym( libc, "__sigsetjmp", ADDRESSOF( sigsetjmp ) );
  1025. Dlsym( libc, "siglongjmp", ADDRESSOF( siglongjmp ) );
  1026. Dlsym( libc, "malloc", ADDRESSOF( malloc ) );
  1027. Dlsym( libc, "posix_memalign", ADDRESSOF( posix_memalign ) );
  1028. Dlsym( libc, "free", ADDRESSOF( free ) );
  1029. Dlsym( libc, "mprotect", ADDRESSOF( mprotect ) );
  1030. Dlsym( libc, "system", ADDRESSOF( system ) );
  1031. Dlsym( libc, "uname", ADDRESSOF( uname ) );
  1032. Dlsym( libc, "kill", ADDRESSOF( kill ) );
  1033. Dlsym( libc, "perror", ADDRESSOF( perror ) );
  1034. Dlsym( libc, "__errno_location", ADDRESSOF(errno_location ) );
  1035. getSysinfo;
  1036. CreateSignalStack;
  1037. InitSignalHandler;
  1038. END Init;
  1039. (* load X11 related libaries only on demand *)
  1040. PROCEDURE LinkToX*;
  1041. BEGIN
  1042. libx := Dlopen( libX11name, 2);
  1043. Dlsym( libx, "XSetErrorHandler", ADDRESS OF xSetErrorHandler);
  1044. Dlsym( libx, "XSetIOErrorHandler", ADDRESS OF xSetIOErrorHandler);
  1045. END LinkToX;
  1046. PROCEDURE {INITIAL} Init0;
  1047. BEGIN
  1048. Init;
  1049. END Init0;
  1050. END Unix.