Generic.Linux.I386.Unix.Mod 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085
  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* = "Linux";
  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. CONST
  136. (* Thread priorities *)
  137. ThreadLow* = 1; ThreadNormal* = 20; ThreadHigh* = 99;
  138. NumPriorities* = 99; (* number of priority levels *)
  139. (*---------------------------- IP -----------------------------------*)
  140. CONST
  141. (* domain *)
  142. AFINET* = 2;
  143. AFINET6* = 26;
  144. PFINET* = AFINET;
  145. PFINET6* = AFINET6;
  146. (* types of connection*)
  147. SockStream* = 1;
  148. SockDGram* = 2;
  149. (* Protocols *)
  150. IpProtoUDP* = 17;
  151. IpProtoTCP* = 6;
  152. (* setsockopt *)
  153. SoLSocket* = 1; (* socket option level *)
  154. SoLinger* = 13; (* linger (gracefully close the connection)*)
  155. SoKeepAlive* = 9; (* keep connection alive *)
  156. SoNoDelay* = 1; (* no delay *)
  157. (* ioctl *)
  158. FioNRead* = 541BH; (* something to read ? *)
  159. (* recv *)
  160. MsgPeek* = 2;
  161. MsgDontWait* = 40H; (* non blocking read *)
  162. (* shutdown *)
  163. ShutRDWR* = 2;
  164. SockAddrSizeV4* = 16;
  165. SockAddrSizeV6* = 28;
  166. (*----------------------- seral line, cf Unix.V24.Mod -----------------------*)
  167. FIONREAD* = 541BH;
  168. TIOCMGET* = 5415H;
  169. TIOCMBIS* = 5416H;
  170. TIOCMBIC* = 5417H;
  171. TIOCMSET* = 5418H;
  172. (* speeds *)
  173. B0* = 0;
  174. B50* = 1;
  175. B75* = 2;
  176. B110* = 3;
  177. B134* = 4;
  178. B150* = 5;
  179. B200* = 6;
  180. B300* = 7;
  181. B600* = 8;
  182. B1200* = 9;
  183. B1800* = 10;
  184. B2400* = 11;
  185. B4800* = 12;
  186. B9600* = 13;
  187. B19200* = 14;
  188. B38400* = 15;
  189. B57600* = 1001H;
  190. B115200* = 1002H;
  191. B230400* = 1003H;
  192. (* tio.cflag bits *)
  193. CSIZE* = {4,5};
  194. CS5* = {};
  195. CS6* = {4};
  196. CS7* = {5};
  197. CS8* = {4,5};
  198. CSTOPB* = {6};
  199. CREAD* = {7};
  200. PARENB* = {8};
  201. PARODD* = {9};
  202. HUPCL* = {10};
  203. CLOCAL* = {11};
  204. TYPE
  205. Termios* = RECORD
  206. iflags*, oflags*, cflags*, lflags*: SET;
  207. line*: CHAR;
  208. cc* : ARRAY 32 OF CHAR;
  209. ispeed-, ospeed-: LONGINT
  210. END;
  211. (*------------------------------------------------------------------*)
  212. TYPE
  213. DevT* = HUGEINT;
  214. Status* = RECORD
  215. dev- : DevT;
  216. unused1- : LONGINT;
  217. ino- : LONGINT;
  218. mode- : LONGINT;
  219. nlink- : LONGINT;
  220. uid- : LONGINT;
  221. gid- : LONGINT;
  222. rdev- : DevT;
  223. unused2- : LONGINT;
  224. size- : LONGINT;
  225. blksize- : LONGINT;
  226. blocks- : LONGINT;
  227. atime- : Timeval;
  228. mtime- : Timeval;
  229. ctime- : Timeval;
  230. unused- : ARRAY 2 OF LONGINT;
  231. END;
  232. Timeval* = RECORD
  233. sec* : LONGINT;
  234. usec* : LONGINT
  235. END;
  236. TmPtr* = POINTER TO Tm;
  237. Tm* = RECORD
  238. sec*, min*, hour*, mday*, mon*, year*, wday*, yday*, isdst*: LONGINT;
  239. gmtoff*, tmzone*: LONGINT;
  240. END;
  241. Tms* = POINTER TO RECORD
  242. utime*, stime*, cutime*, cstime*: LONGINT
  243. END;
  244. Timezone* = RECORD
  245. minuteswest*, dsttime*: LONGINT
  246. END;
  247. Itimerval* = RECORD
  248. interval*, value*: Timeval
  249. END;
  250. CONST
  251. FdSetLen* = 32;
  252. TYPE
  253. FdSet* = ARRAY FdSetLen OF SET;
  254. Dirent* = POINTER TO RECORD
  255. ino-, off- : LONGINT; (* these may change to HUGEINT in future Linux releases!! *)
  256. reclen- : INTEGER;
  257. typ- : CHAR;
  258. name- : (*array of*) CHAR;
  259. END;
  260. Stack* = RECORD
  261. sp* : ADDRESS;
  262. flags* : SET;
  263. size* : SIZE
  264. END;
  265. Ucontext* = POINTER TO UcontextDesc;
  266. UcontextDesc* = RECORD
  267. flags- : SET;
  268. link- : ADDRESS;
  269. stack- : Stack;
  270. mc- : McontextDesc
  271. END;
  272. Mcontext* = POINTER TO McontextDesc;
  273. McontextDesc* = RECORD
  274. r_gs- : LONGINT;
  275. r_fs- : LONGINT;
  276. r_es- : LONGINT;
  277. r_ds- : LONGINT;
  278. r_di- : LONGINT;
  279. r_si- : LONGINT;
  280. r_bp- : LONGINT;
  281. r_sp_ - : LONGINT;
  282. r_bx- : LONGINT;
  283. r_dx- : LONGINT;
  284. r_cx- : LONGINT;
  285. r_ax- : LONGINT;
  286. r_trapno- : LONGINT;
  287. r_err- : LONGINT;
  288. r_pc- : LONGINT;
  289. r_cs- : LONGINT;
  290. r_flags- : LONGINT;
  291. r_sp- : LONGINT; (* sp at error (signal) *)
  292. r_ss- : LONGINT;
  293. fpc- : ADDRESS; (* FPcontext *)
  294. oldmask- : LONGINT;
  295. cr2- : LONGINT
  296. END;
  297. FPcontext* = POINTER TO FPcontextDesc;
  298. FPcontextDesc* = RECORD
  299. (* ... *)
  300. END;
  301. PThreadAttr = RECORD
  302. reserved1-: ARRAY 5 OF ADDRESS;
  303. reserved2-: ARRAY 4 OF WORD;
  304. END;
  305. VAR
  306. argc-: LONGINT; argv-: ADDRESS;
  307. aargc: ADDRESS;
  308. sysinfo-: RECORD
  309. sysname-, nodename-, release-, version-, machine-: ARRAY 65 OF CHAR;
  310. END;
  311. sigstack-: ARRAY 32*4096 OF CHAR;
  312. pthread_mutex_init: PROCEDURE {C} (mutex: ADDRESS; mutexattr: ADDRESS): WORD;
  313. pthread_mutex_destroy: PROCEDURE {C} (mutex: ADDRESS): WORD;
  314. pthread_mutex_lock: PROCEDURE {C} (mutex: ADDRESS): WORD;
  315. pthread_mutex_unlock: PROCEDURE {C} (mutex: ADDRESS): WORD;
  316. pthread_cond_init: PROCEDURE {C} (cond: ADDRESS; condAttr: ADDRESS): WORD;
  317. pthread_cond_destroy: PROCEDURE {C} (cond: ADDRESS): WORD;
  318. pthread_cond_wait: PROCEDURE {C} (cond: ADDRESS; mutex: ADDRESS): WORD;
  319. pthread_cond_signal: PROCEDURE {C} (cond: ADDRESS): WORD;
  320. pthread_create: PROCEDURE {C} (newthread: ADDRESS; attr: ADDRESS; start_routine: PROCEDURE {C} (arg: PROCEDURE):ADDRESS; arg:PROCEDURE): WORD;
  321. pthread_exit: PROCEDURE {C} (thr: ADDRESS);
  322. pthread_detach: PROCEDURE {C} (thr: ADDRESS);
  323. pthread_kill: PROCEDURE {C} (thr: ADDRESS; sigid: LONGINT);
  324. pthread_cancel: PROCEDURE {C} (thr: ADDRESS);
  325. pthread_attr_init: PROCEDURE {C} (attr: ADDRESS);
  326. pthread_attr_setscope: PROCEDURE {C}(attr: ADDRESS; set: WORD);
  327. pthread_attr_setdetachstate: PROCEDURE {C}(attr: ADDRESS; set: WORD);
  328. pthread_attr_setstacksize: PROCEDURE {C}(attr: ADDRESS; stackSize: SIZE);
  329. pthread_self: PROCEDURE {C} (): Thread_t;
  330. sched_get_priority_max: PROCEDURE {C} (policy: LONGINT): LONGINT;
  331. sched_get_priority_min: PROCEDURE {C} (policy: LONGINT): LONGINT;
  332. pthread_setschedparam: PROCEDURE {C} (thread: Thread_t; policy: LONGINT; param: ADDRESS): WORD;
  333. pthread_getschedparam: PROCEDURE {C} (thread: Thread_t; policy: LONGINT; param: ADDRESS): WORD;
  334. pthread_setcancelstate: PROCEDURE {C} (state: LONGINT; oldstate: ADDRESS): LONGINT;
  335. pthread_setcanceltype: PROCEDURE {C} (type: LONGINT; oldtype: ADDRESS): LONGINT;
  336. sigaction: PROCEDURE {C} (signum: LONGINT; CONST act, oldact: ADDRESS): LONGINT;
  337. sigemptyset: PROCEDURE {C} (set: ADDRESS);
  338. sigfillset: PROCEDURE {C} (set: ADDRESS): LONGINT;
  339. sigsuspend: PROCEDURE {C} (set: ADDRESS): LONGINT;
  340. sigaddset: PROCEDURE {C} (set: ADDRESS; signo: LONGINT);
  341. sigdelset: PROCEDURE {C} (set: ADDRESS; signo: LONGINT);
  342. nanosleep: PROCEDURE {C} (req, rem: ADDRESS): LONGINT;
  343. sigaltstack: PROCEDURE {C} (ss, oss: ADDRESS): LONGINT;
  344. pthread_sigmask: PROCEDURE {C}(how: LONGINT; set: ADDRESS; oldset: ADDRESS): LONGINT;
  345. read- : PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): LONGINT;
  346. write- : PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): LONGINT;
  347. open- : PROCEDURE {C} ( name: ADDRESS; flags, mode: SET ): LONGINT;
  348. close- : PROCEDURE {C} ( fd: LONGINT ): LONGINT;
  349. lseek- : PROCEDURE {C} ( fd: LONGINT; offset, origin: SIZE ): LONGINT;
  350. fsync- : PROCEDURE {C} ( fd: LONGINT ): LONGINT;
  351. ioctl- : PROCEDURE {C} ( fd: LONGINT; request: LONGINT; arg: ADDRESS ): LONGINT;
  352. unlink- : PROCEDURE {C} ( name: ADDRESS ): LONGINT;
  353. rename- : PROCEDURE {C} ( oldname, newname: ADDRESS ): LONGINT;
  354. ftruncate- : PROCEDURE {C} ( fd: LONGINT; length: SIZE ): LONGINT;
  355. chmod- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  356. utime- : PROCEDURE {C} ( name: ADDRESS; tb: ADDRESS ): LONGINT;
  357. access- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  358. select- : PROCEDURE {C} ( width: LONGINT; rd, wr, ex: ADDRESS; VAR timeout: Timeval ): LONGINT;
  359. chdir- : PROCEDURE {C} ( name: ADDRESS ): LONGINT;
  360. mkdir- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  361. rmdir- : PROCEDURE {C} ( path: ADDRESS ): LONGINT;
  362. stat- : PROCEDURE {C} ( name: ADDRESS; VAR buf: Status ): LONGINT;
  363. lstat- : PROCEDURE {C} ( name: ADDRESS; VAR buf: Status ): LONGINT;
  364. fstat- : PROCEDURE {C} ( fd: LONGINT; VAR buf: Status ): LONGINT;
  365. getpid- : PROCEDURE {C} ( ): LONGINT;
  366. getuid- : PROCEDURE {C} ( ): LONGINT;
  367. malloc- : PROCEDURE {C} ( size: SIZE ): ADDRESS;
  368. posix_memalign- : PROCEDURE {C} ( VAR p: ADDRESS; alignment, size: SIZE ): LONGINT;
  369. free- : PROCEDURE {C} ( p: ADDRESS );
  370. mprotect- : PROCEDURE {C} ( p: ADDRESS; len: SIZE; prot: LONGINT ): LONGINT;
  371. alarm- : PROCEDURE {C} ( ms: LONGINT ): LONGINT;
  372. setitimer- : PROCEDURE {C} ( which: LONGINT; VAR value, ovalue: Itimerval ): LONGINT;
  373. getitimer- : PROCEDURE {C} ( which: LONGINT; VAR value: Itimerval ): LONGINT;
  374. gettimeofday- : PROCEDURE {C} ( VAR tv: Timeval; VAR tz: Timezone ): LONGINT;
  375. mktime- : PROCEDURE {C} ( VAR tm: Tm ): LONGINT;
  376. localtime- : PROCEDURE {C} ( CONST tv: Timeval ): TmPtr;
  377. time- : PROCEDURE {C} ( VAR tv: Timeval ): LONGINT;
  378. times- : PROCEDURE {C} ( VAR tms: Tms ): LONGINT;
  379. system- : PROCEDURE {C} ( cmd: ADDRESS );
  380. uname- : PROCEDURE {C} ( utsname: ADDRESS ): LONGINT;
  381. getcwd- : PROCEDURE {C} ( buf: ADDRESS; len: SIZE ): ADDRESS;
  382. getenv- : PROCEDURE {C} ( name: ADDRESS ): ADDRESS;
  383. opendir- : PROCEDURE {C} ( name: ADDRESS ): ADDRESS;
  384. readdir- : PROCEDURE {C} ( dir: ADDRESS ): Dirent;
  385. closedir- : PROCEDURE {C} ( dir: ADDRESS );
  386. sigsetjmp- : PROCEDURE {C} ( env: ADDRESS; savemask: LONGINT ): LONGINT;
  387. siglongjmp- : PROCEDURE {C} ( env: ADDRESS; val: LONGINT );
  388. kill- : PROCEDURE {C} ( pid, sig: LONGINT ): LONGINT;
  389. exit- : PROCEDURE {C} ( status: LONGINT );
  390. perror- : PROCEDURE {C} ( msg: ADDRESS );
  391. errno- : PROCEDURE {C} ( ): LONGINT;
  392. libc-: LONGINT;
  393. libp-: LONGINT;
  394. libraryPaths: ARRAY 8 OF ARRAY 32 OF CHAR;
  395. noPaths: LONGINT;
  396. (*
  397. mtxInit: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Mutex_t;
  398. mtxDestroy: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  399. mtxLock: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  400. mtxUnlock: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  401. conInit: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Condition_t;
  402. conDestroy: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t );
  403. conWait: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t; mtx: Unix.Mutex_t );
  404. conSignal: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t );
  405. thrStart: PROCEDURE {REALTIME, C} ( p: PROCEDURE; stackLen: LONGINT ): Unix.Thread_t;
  406. thrThis: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Thread_t;
  407. thrSleep: PROCEDURE {REALTIME, C} ( ms: LONGINT );
  408. thrYield: PROCEDURE {REALTIME, C} ( dummy: LONGINT );
  409. thrExit: PROCEDURE {REALTIME, C} ( dummy: LONGINT );
  410. thrSuspend: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  411. thrResume: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  412. thrSetPriority: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t; prio: LONGINT );
  413. thrGetPriority: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t ): LONGINT;
  414. thrKill: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  415. *)
  416. TYPE
  417. PROCEDURE MtxInit*(dummy: LONGINT): Mutex_t;
  418. VAR
  419. mtx: Mutex_t;
  420. BEGIN
  421. mtx := malloc(SIZEOF(MutexType));
  422. ASSERT(mtx # 0);
  423. ASSERT(pthread_mutex_init(mtx, NIL) = 0);
  424. RETURN mtx;
  425. END MtxInit;
  426. PROCEDURE MtxDestroy*(mtx: Mutex_t);
  427. BEGIN
  428. ASSERT(pthread_mutex_destroy(mtx) = 0);
  429. END MtxDestroy;
  430. PROCEDURE MtxLock*(mtx: Mutex_t);
  431. BEGIN
  432. ASSERT(pthread_mutex_lock(mtx) = 0);
  433. END MtxLock;
  434. PROCEDURE MtxUnlock*(mtx: Mutex_t);
  435. BEGIN
  436. ASSERT(pthread_mutex_unlock(mtx) = 0);
  437. END MtxUnlock;
  438. PROCEDURE ConInit* (dummy: LONGINT): Condition_t;
  439. VAR cond: Condition_t;
  440. BEGIN
  441. cond := malloc(SIZEOF(ConditionType));
  442. ASSERT(cond # 0);
  443. ASSERT(pthread_cond_init(cond, NIL)=0);
  444. RETURN cond;
  445. END ConInit;
  446. PROCEDURE ConDestroy*(con: Condition_t);
  447. BEGIN
  448. ASSERT(pthread_cond_destroy(con) = 0);
  449. END ConDestroy;
  450. PROCEDURE ConWait*(con: Condition_t; mtx: Mutex_t);
  451. BEGIN
  452. ASSERT(pthread_cond_wait(con, mtx) = 0);
  453. END ConWait;
  454. PROCEDURE ConSignal*(cond: Condition_t);
  455. BEGIN
  456. ASSERT(pthread_cond_signal(cond) = 0);
  457. END ConSignal;
  458. PROCEDURE ThrThis*(dummy: LONGINT): Thread_t;
  459. BEGIN
  460. RETURN pthread_self();
  461. END ThrThis;
  462. PROCEDURE ThrYield*(dummy: LONGINT);
  463. BEGIN
  464. ThrSleep(1);
  465. END ThrYield;
  466. PROCEDURE ThrExit*(dummy: LONGINT);
  467. BEGIN
  468. pthread_exit(0);
  469. END ThrExit;
  470. PROCEDURE ThrSetPriority*(thr: Thread_t; prio: LONGINT);
  471. VAR
  472. param: Sched_param;
  473. policy: LONGINT;
  474. BEGIN
  475. IF pthread_getschedparam( thr, ADDRESS OF policy, ADDRESS OF param ) # 0 THEN END;
  476. param.sched_priority := prio;
  477. IF pthread_setschedparam( thr, SCHED_OTHER, ADDRESS OF param ) # 0 THEN
  478. Perror("pthread_setschedparam");
  479. END
  480. END ThrSetPriority;
  481. PROCEDURE ThrGetPriority*(thr: Thread_t):LONGINT;
  482. VAR
  483. param: Sched_param;
  484. policy: LONGINT;
  485. BEGIN
  486. IF pthread_getschedparam( thr, ADDRESS OF policy, ADDRESS OF param ) # 0 THEN END;
  487. RETURN param.sched_priority;
  488. END ThrGetPriority;
  489. VAR
  490. sigstk: Stack;
  491. PROCEDURE SetSigaltstack;
  492. BEGIN
  493. IF sigaltstack(ADDRESS OF sigstk, NIL) < 0 THEN
  494. Perror("sigaltstack")
  495. END;
  496. END SetSigaltstack;
  497. PROCEDURE {C} Starter(proc: PROCEDURE): ADDRESS;
  498. VAR
  499. me: Thread_t;
  500. old, new: Sigset_t;
  501. param: Sched_param;
  502. res: LONGINT;
  503. BEGIN
  504. me := pthread_self();
  505. SetSigaltstack();
  506. IF sigfillset( ADDRESS OF new ) < 0 THEN
  507. Perror("sigfillset");
  508. END;
  509. sigdelset( ADDRESS OF new, SIGILL );
  510. sigdelset( ADDRESS OF new, SIGTRAP );
  511. sigdelset( ADDRESS OF new, SIGFPE );
  512. sigdelset( ADDRESS OF new, SIGBUS );
  513. sigdelset( ADDRESS OF new, SIGSEGV );
  514. sigdelset( ADDRESS OF new, SIGTERM );
  515. sigdelset( ADDRESS OF new, T_SIGSUSPEND );
  516. res := pthread_sigmask( SIG_SETMASK, ADDRESS OF new, ADDRESS OF old );
  517. res := pthread_setcancelstate( PTHREAD_CANCEL_ENABLE, NIL );
  518. res := pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NIL );
  519. param.sched_priority := 0;
  520. res := pthread_setschedparam( me, SCHED_OTHER, ADDRESS OF param );
  521. proc();
  522. pthread_exit( NIL );
  523. RETURN NIL;
  524. END Starter;
  525. PROCEDURE ThrStart*(p: PROCEDURE; stackSize: SIZE): Thread_t;
  526. VAR
  527. attr: PThreadAttr;
  528. id: Thread_t;
  529. res,i: LONGINT;
  530. CONST
  531. PTHREAD_SCOPE_SYSTEM = 0;
  532. PTHREAD_CREATE_DETACHED = 1;
  533. BEGIN
  534. pthread_attr_init(ADDRESS OF attr);
  535. pthread_attr_setscope(ADDRESS OF attr, PTHREAD_SCOPE_SYSTEM);
  536. pthread_attr_setdetachstate(ADDRESS OF attr, PTHREAD_CREATE_DETACHED);
  537. pthread_attr_setstacksize(ADDRESS OF attr, stackSize);
  538. res := pthread_create(ADDRESS OF id, ADDRESS OF attr, Starter, p);
  539. RETURN id;
  540. END ThrStart;
  541. PROCEDURE ThrSleep*(ms: LONGINT);
  542. VAR
  543. sltime,rem: RECORD
  544. tv_sec: WORD; (* seconds *)
  545. tv_nsec: WORD; (* nanoseconds *)
  546. END;
  547. BEGIN
  548. sltime.tv_sec := ms DIV 1000;
  549. sltime.tv_nsec := 1000000*(ms MOD 1000);
  550. WHILE (nanosleep(ADDRESS OF sltime, ADDRESS OF rem) < 0) DO
  551. (* check error ! *)
  552. sltime := rem;
  553. END;
  554. END ThrSleep;
  555. PROCEDURE ThrKill*(thr: Thread_t);
  556. BEGIN
  557. IF (thr # mainthread) THEN
  558. pthread_detach( thr );
  559. IF (thr = pthread_self()) THEN
  560. pthread_exit( 0 );
  561. ELSE
  562. pthread_cancel( thr );
  563. END
  564. END;
  565. END ThrKill;
  566. PROCEDURE {C} resume_handler(sig: LONGINT);
  567. BEGIN
  568. END resume_handler;
  569. PROCEDURE ThrResume*(thr: Thread_t);
  570. VAR n: LONGINT; res: LONGINT;
  571. BEGIN
  572. res := pthread_mutex_lock( ADDRESS OF suspend_mutex );
  573. resume_done := 0; n := 1;
  574. pthread_kill( thr, T_SIGRESUME );
  575. WHILE (resume_done # 1) & (n < 50) DO ThrSleep(1); INC(n) END;
  576. res := pthread_mutex_unlock( ADDRESS OF suspend_mutex );
  577. END ThrResume;
  578. PROCEDURE {C} suspend_handler(sig: LONGINT);
  579. VAR block: Sigset_t; res: LONGINT;
  580. BEGIN
  581. res := sigfillset( ADDRESS OF block );
  582. sigdelset( ADDRESS OF block, T_SIGRESUME );
  583. suspend_done := 1;
  584. res := sigsuspend( ADDRESS OF block ); (* await T_SIGRESUME *)
  585. resume_done := 1;
  586. END suspend_handler;
  587. PROCEDURE ThrSuspend*(thr: Thread_t);
  588. VAR res: LONGINT;
  589. BEGIN
  590. res := pthread_mutex_lock(ADDRESS OF suspend_mutex );
  591. suspend_done := 0;
  592. pthread_kill( thr, T_SIGSUSPEND );
  593. WHILE (suspend_done # 1) DO ThrSleep( 1 ) END;
  594. res := pthread_mutex_unlock( ADDRESS OF suspend_mutex );
  595. END ThrSuspend;
  596. TYPE
  597. Sigaction = RECORD
  598. sa_handler: ADDRESS;
  599. sa_mask: Sigset_t;
  600. sa_flags: ADDRESS;
  601. filler: ADDRESS;
  602. END;
  603. Sched_param = RECORD
  604. sched_priority: LONGINT;
  605. safety: ARRAY 8 OF ADDRESS;
  606. END;
  607. VAR
  608. suspend_mutex: MutexType;
  609. mainthread: Thread_t;
  610. suspend_done: LONGINT;
  611. resume_done: LONGINT;
  612. sasuspend, saresume: Sigaction;
  613. PROCEDURE ThrInitialize*(VAR low, high: LONGINT): BOOLEAN;
  614. VAR
  615. param: Sched_param;
  616. BEGIN
  617. (*struct sched_param param;*)
  618. ASSERT(pthread_mutex_init( ADDRESS OF suspend_mutex, NIL ) = 0);
  619. mainthread := pthread_self();
  620. high := sched_get_priority_max(SCHED_OTHER);
  621. low := sched_get_priority_min(SCHED_OTHER);
  622. param.sched_priority := high;
  623. IF pthread_setschedparam( mainthread, SCHED_OTHER, ADDRESS OF param)#0 THEN
  624. Perror("ThrInitialize: setparam");
  625. END;
  626. sigemptyset( ADDRESS OF sasuspend.sa_mask );
  627. sigaddset( ADDRESS OF sasuspend.sa_mask, T_SIGRESUME );
  628. sasuspend.sa_flags := 0;
  629. sasuspend.sa_handler := suspend_handler;
  630. ASSERT(sigaction( T_SIGSUSPEND, ADDRESS OF sasuspend, NIL ) = 0);
  631. sigemptyset( ADDRESS OF saresume.sa_mask );
  632. saresume.sa_flags := 0;
  633. saresume.sa_handler := resume_handler;
  634. ASSERT(sigaction( T_SIGRESUME, ADDRESS OF saresume, NIL ) = 0);
  635. RETURN TRUE;
  636. END ThrInitialize;
  637. PROCEDURE ModifyContext*( cont: Ucontext; pc, bp, sp: LONGINT );
  638. BEGIN
  639. cont.mc.r_pc := pc;
  640. cont.mc.r_bp := bp;
  641. cont.mc.r_sp := sp;
  642. END ModifyContext;
  643. PROCEDURE Perror*( CONST msg: ARRAY OF CHAR );
  644. BEGIN
  645. perror( ADDRESSOF( msg ) )
  646. END Perror;
  647. PROCEDURE Dlsym*( lib: ADDRESS; CONST sym: ARRAY OF CHAR; objAddr: ADDRESS );
  648. VAR val: LONGINT;
  649. BEGIN
  650. Glue.Dlsym( lib, sym, objAddr );
  651. S.GET( objAddr, val );
  652. IF val = 0 THEN
  653. Trace.String( "Unix.Dlsym: entry '" ); Trace.String( sym ); Trace.String( "' not found" );
  654. Trace.Ln;
  655. LOOP END;
  656. ELSE
  657. Trace.String( "Unix.Dlsym found " ); Trace.String( sym );
  658. Trace.Ln
  659. END
  660. END Dlsym;
  661. PROCEDURE Dlopen*( CONST libname: ARRAY OF CHAR; mode: LONGINT ): ADDRESS;
  662. VAR h: ADDRESS; i, j, k: INTEGER;
  663. p: ARRAY 256 OF CHAR;
  664. BEGIN
  665. IF libname[0] = '/' THEN h := Glue.dlopen( ADDRESSOF( libname ), mode );
  666. ELSE
  667. i := 0; h := 0;
  668. WHILE (h = 0) & (i < noPaths) DO
  669. COPY( libraryPaths[i], p ); j := 0;
  670. WHILE p[j] # 0X DO INC( j ) END;
  671. p[j] := '/'; k := 0;
  672. REPEAT INC( j ); p[j] := libname[k]; INC( k ) UNTIL p[j] = 0X;
  673. h := Glue.dlopen( ADDRESSOF( p ), mode ); INC( i )
  674. END
  675. END;
  676. IF h = 0 THEN
  677. Trace.String( "Unix.Dlopen: loading library " );
  678. Trace.String( libname ); Trace.String( " failed" ); Trace.Ln;
  679. LOOP END;
  680. END;
  681. RETURN h
  682. END Dlopen;
  683. PROCEDURE Dlclose*( lib: ADDRESS );
  684. BEGIN
  685. Glue.dlclose( lib )
  686. END Dlclose;
  687. PROCEDURE GetArg*( no: LONGINT; VAR val: ARRAY OF CHAR );
  688. VAR ch: CHAR; adr: ADDRESS; i: LONGINT;
  689. BEGIN
  690. IF no >= argc THEN val[0] := 0X
  691. ELSE
  692. S.GET( argv + SIZEOF(ADDRESS)*no, adr ); i := 0;
  693. REPEAT S.GET( adr, ch ); val[i] := ch; INC( adr ); INC( i ); UNTIL (ch = 0X) OR (i >= LEN( val ));
  694. END
  695. END GetArg;
  696. PROCEDURE GetArgval*( CONST argName: ARRAY OF CHAR; VAR val: ARRAY OF CHAR );
  697. VAR i: INTEGER;
  698. buf: ARRAY 40 OF CHAR;
  699. BEGIN
  700. i := 1;
  701. WHILE i < argc - 1 DO
  702. GetArg( i, buf );
  703. IF buf = argName THEN GetArg( i + 1, val ); RETURN END;
  704. INC( i )
  705. END;
  706. val[0] := 0X
  707. END GetArgval;
  708. PROCEDURE getSysinfo;
  709. VAR res: LONGINT; p: INTEGER;
  710. buf: ARRAY 4096 OF CHAR;
  711. PROCEDURE copy( VAR p: INTEGER; VAR dest: ARRAY OF CHAR );
  712. VAR i: INTEGER;
  713. BEGIN
  714. WHILE buf[p] <= ' ' DO INC( p ) END;
  715. i := 0;
  716. REPEAT dest[i] := buf[p]; INC( i ); INC( p ) UNTIL (buf[p - 1] = 0X) OR (i >= LEN( dest ));
  717. dest[i - 1] := 0X
  718. END copy;
  719. BEGIN
  720. FOR p := 0 TO 4096 - 1 DO buf[p] := 0X END;
  721. res := uname( ADDRESSOF( buf ) );
  722. p := 0;
  723. copy( p, sysinfo.sysname );
  724. copy( p, sysinfo.nodename );
  725. copy( p, sysinfo.release );
  726. copy( p, sysinfo.version );
  727. copy( p, sysinfo.machine );
  728. END getSysinfo;
  729. PROCEDURE CreateSignalStack;
  730. BEGIN
  731. sigstk.sp := ADDRESS OF sigstack;
  732. sigstk.size := LEN(sigstack);
  733. sigstk.flags := {};
  734. END CreateSignalStack;
  735. (*
  736. static void sighandler( int sig, siginfo_t *scp, void *ucp ) {
  737. if (debug | (AosTrap == NULL)) {
  738. printf("\nhandler for signal %d got called, ucp = %p\n", sig, ucp);
  739. if (AosTrap == NULL) exit(1);
  740. }
  741. AosTrap(0, ucp, scp, sig); /* rev. order: Oberon <--> C */
  742. }
  743. *)
  744. VAR trap: SignalHandler;
  745. PROCEDURE {C} SigHandler ( sig: LONGINT; scp: ADDRESS; ucp: ADDRESS); (* reversed arguments !! *)
  746. BEGIN
  747. IF trap # NIL THEN
  748. trap(sig, scp, ucp, 0);
  749. ELSE
  750. TRACE(sig, scp, ucp)
  751. END;
  752. END SigHandler;
  753. PROCEDURE InstallSignalHandler* ( h: SignalHandler );
  754. BEGIN
  755. trap := h;
  756. END InstallSignalHandler;
  757. PROCEDURE InstallHandler(sig: LONGINT);
  758. VAR
  759. act: Sigaction;
  760. mask: Sigset_t;
  761. BEGIN
  762. sigemptyset(ADDRESS OF mask);
  763. act.sa_mask := mask;
  764. act.sa_flags := SA_SIGINFO + SA_ONSTACK + SA_NODEFER;
  765. act.sa_handler := ADDRESS OF SigHandler;
  766. IF sigaction( sig, ADDRESS OF act, 0 ) # 0 THEN
  767. Perror("sigaction");
  768. END;
  769. END InstallHandler;
  770. PROCEDURE InitSignalHandler;
  771. VAR i: LONGINT;
  772. BEGIN
  773. FOR i := 1 TO 15 DO
  774. IF i # 9 THEN InstallHandler(i) END;
  775. END;
  776. END InitSignalHandler;
  777. PROCEDURE Init;
  778. VAR test: ADDRESS;
  779. BEGIN
  780. TRACE("Unix init start");
  781. (*
  782. Dlsym( 0, "argc", ADDRESSOF( aargc ) );
  783. IF aargc # NIL THEN
  784. S.GET( aargc, argc );
  785. END;
  786. Dlsym( 0, "argv", ADDRESSOF( argv ) );
  787. *)
  788. libraryPaths[0] := "/lib/i386-linux-gnu";
  789. libraryPaths[1] := "/usr/lib/i386-linux-gnu";
  790. libraryPaths[2] := "/lib";
  791. libraryPaths[3] := "/usr/lib";
  792. noPaths := 4;
  793. libc := Dlopen( libcname, 2 );
  794. libp := Dlopen( libpthreadname, 2);
  795. Dlsym( libc, "pthread_mutex_init", ADDRESSOF(pthread_mutex_init));
  796. Dlsym( libc, "pthread_mutex_destroy", ADDRESSOF(pthread_mutex_destroy));
  797. Dlsym( libc, "pthread_mutex_lock", ADDRESSOF(pthread_mutex_lock));
  798. Dlsym( libc, "pthread_mutex_unlock", ADDRESSOF(pthread_mutex_unlock));
  799. Dlsym( libc, "pthread_cond_init", ADDRESSOF(pthread_cond_init));
  800. Dlsym( libc, "pthread_cond_destroy", ADDRESSOF(pthread_cond_destroy));
  801. Dlsym( libc, "pthread_cond_wait", ADDRESSOF(pthread_cond_wait));
  802. Dlsym( libc, "pthread_cond_signal", ADDRESSOF(pthread_cond_signal));
  803. Dlsym( libp, "pthread_create", ADDRESSOF(pthread_create));
  804. Dlsym( libp, "pthread_exit", ADDRESSOF(pthread_exit));
  805. Dlsym( libp, "pthread_detach", ADDRESSOF(pthread_detach));
  806. Dlsym( libp, "pthread_cancel", ADDRESSOF(pthread_cancel));
  807. Dlsym( libp, "pthread_kill", ADDRESSOF(pthread_kill));
  808. Dlsym( libp, "pthread_sigmask", ADDRESSOF(pthread_sigmask));
  809. Dlsym( libp, "pthread_setcancelstate", ADDRESSOF(pthread_setcancelstate));
  810. Dlsym( libp, "pthread_setcanceltype", ADDRESSOF(pthread_setcanceltype));
  811. Dlsym( libp, "pthread_attr_init", ADDRESSOF(pthread_attr_init));
  812. Dlsym( libp, "pthread_attr_setscope", ADDRESSOF(pthread_attr_setscope));
  813. Dlsym( libp, "pthread_attr_setdetachstate", ADDRESSOF(pthread_attr_setdetachstate));
  814. Dlsym( libp, "pthread_attr_setstacksize", ADDRESSOF(pthread_attr_setstacksize));
  815. Dlsym( libp, "pthread_self", ADDRESSOF(pthread_self));
  816. Dlsym( libc, "sched_get_priority_max", ADDRESSOF(sched_get_priority_max));
  817. Dlsym( libc, "sched_get_priority_min", ADDRESSOF(sched_get_priority_min));
  818. Dlsym( libc, "pthread_setschedparam", ADDRESSOF(pthread_setschedparam));
  819. Dlsym( libc, "pthread_getschedparam", ADDRESSOF(pthread_getschedparam));
  820. Dlsym( libc, "sigaction", ADDRESSOF(sigaction));
  821. Dlsym( libc, "sigemptyset", ADDRESSOF(sigemptyset));
  822. Dlsym( libc, "sigfillset", ADDRESSOF(sigfillset));
  823. Dlsym( libc, "sigaddset", ADDRESSOF(sigaddset));
  824. Dlsym( libc, "sigdelset", ADDRESSOF(sigdelset));
  825. Dlsym( libc, "nanosleep", ADDRESSOF(nanosleep));
  826. Dlsym( libc, "sigaltstack", ADDRESSOF(sigaltstack));
  827. Dlsym( libc, "sigsuspend", ADDRESSOF(sigsuspend));
  828. (*
  829. Dlsym( libc, "putc", ADDRESSOF(test));
  830. *)
  831. Dlsym( libc, "read", ADDRESSOF( read ) );
  832. Dlsym( libc, "write", ADDRESSOF( write ) );
  833. Dlsym( libc, "open", ADDRESSOF( open ) );
  834. Dlsym( libc, "close", ADDRESSOF( close ) );
  835. Dlsym( libc, "lseek", ADDRESSOF( lseek ) );
  836. Dlsym( libc, "fsync", ADDRESSOF( fsync ) );
  837. Dlsym( libc, "ioctl", ADDRESSOF( ioctl ) );
  838. Dlsym( libc, "unlink", ADDRESSOF( unlink ) );
  839. Dlsym( libc, "rename", ADDRESSOF( rename ) );
  840. Dlsym( libc, "ftruncate", ADDRESSOF( ftruncate ) );
  841. Dlsym( libc, "chmod", ADDRESSOF( chmod ) );
  842. Dlsym( libc, "utime", ADDRESSOF( utime ) );
  843. Dlsym( libc, "access", ADDRESSOF( access ) );
  844. Dlsym( libc, "select", ADDRESSOF( select ) );
  845. Dlsym( libc, "chdir", ADDRESSOF( chdir ) );
  846. Dlsym( libc, "mkdir", ADDRESSOF( mkdir ) );
  847. Dlsym( libc, "rmdir", ADDRESSOF( rmdir ) );
  848. (*
  849. Dlsym( libc, "stat", ADDRESSOF( stat ) );
  850. Dlsym( libc, "lstat", ADDRESSOF( lstat ) );
  851. Dlsym( libc, "fstat", ADDRESSOF( fstat ) );
  852. *)
  853. Dlsym( libc, "getpid", ADDRESSOF( getpid ) );
  854. Dlsym( libc, "getuid", ADDRESSOF( getuid ) );
  855. Dlsym( libc, "alarm", ADDRESSOF( alarm ) );
  856. Dlsym( libc, "setitimer", ADDRESSOF( setitimer ) );
  857. Dlsym( libc, "getitimer", ADDRESSOF( getitimer ) );
  858. Dlsym( libc, "gettimeofday", ADDRESSOF( gettimeofday ) );
  859. Dlsym( libc, "mktime", ADDRESSOF( mktime ) );
  860. Dlsym( libc, "localtime", ADDRESSOF( localtime ) );
  861. Dlsym( libc, "time", ADDRESSOF( time ) );
  862. Dlsym( libc, "times", ADDRESSOF( times ) );
  863. Dlsym( libc, "getcwd", ADDRESSOF( getcwd ) );
  864. Dlsym( libc, "getenv", ADDRESSOF( getenv ) );
  865. Dlsym( libc, "opendir", ADDRESSOF( opendir ) );
  866. Dlsym( libc, "readdir", ADDRESSOF( readdir ) );
  867. Dlsym( libc, "closedir", ADDRESSOF( closedir ) );
  868. (*Dlsym( libp, "sigsetjmp", ADDRESSOF( sigsetjmp ) );*)
  869. (*Dlsym( libc, "siglongjmp", ADDRESSOF( siglongjmp ) );*)
  870. Dlsym( libc, "malloc", ADDRESSOF( malloc ) );
  871. Dlsym( libc, "posix_memalign", ADDRESSOF( posix_memalign ) );
  872. Dlsym( libc, "free", ADDRESSOF( free ) );
  873. Dlsym( libc, "mprotect", ADDRESSOF( mprotect ) );
  874. Dlsym( libc, "system", ADDRESSOF( system ) );
  875. Dlsym( libc, "uname", ADDRESSOF( uname ) );
  876. Dlsym( libc, "kill", ADDRESSOF( kill ) );
  877. Dlsym( libc, "exit", ADDRESSOF( exit ) );
  878. Dlsym( libc, "perror", ADDRESSOF( perror ) );
  879. Dlsym( libc, "errno", ADDRESSOF( errno ) );
  880. getSysinfo;
  881. CreateSignalStack;
  882. InitSignalHandler;
  883. TRACE("Unix init end");
  884. END Init;
  885. PROCEDURE {INITIAL} Init0;
  886. BEGIN
  887. Init;
  888. END Init0;
  889. END Unix.