Generic.Linux.I386.Unix.Mod 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260
  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. Timeval* = RECORD
  250. sec* : LONGINT;
  251. usec* : LONGINT
  252. END;
  253. TmPtr* = POINTER TO Tm;
  254. Tm* = RECORD
  255. sec*, min*, hour*, mday*, mon*, year*, wday*, yday*, isdst*: LONGINT;
  256. gmtoff*, tmzone*: LONGINT;
  257. END;
  258. Tms* = POINTER TO RECORD
  259. utime*, stime*, cutime*, cstime*: LONGINT
  260. END;
  261. Timezone* = RECORD
  262. minuteswest*, dsttime*: LONGINT
  263. END;
  264. Itimerval* = RECORD
  265. interval*, value*: Timeval
  266. END;
  267. CONST
  268. FdSetLen* = 32;
  269. TYPE
  270. FdSet* = ARRAY FdSetLen OF SET;
  271. Dirent* = POINTER TO RECORD
  272. ino-, off- : LONGINT; (* these may change to HUGEINT in future Linux releases!! *)
  273. reclen- : INTEGER;
  274. typ- : CHAR;
  275. name- : (*array of*) CHAR;
  276. END;
  277. Stack* = RECORD
  278. sp* : ADDRESS;
  279. flags* : SET;
  280. size* : SIZE
  281. END;
  282. Ucontext* = POINTER TO UcontextDesc;
  283. UcontextDesc* = RECORD
  284. flags- : SET;
  285. link- : ADDRESS;
  286. stack- : Stack;
  287. mc- : McontextDesc
  288. END;
  289. Mcontext* = POINTER TO McontextDesc;
  290. McontextDesc* = RECORD
  291. r_gs- : ADDRESS;
  292. r_fs- : ADDRESS;
  293. r_es- : ADDRESS;
  294. r_ds- : ADDRESS;
  295. r_di- : ADDRESS;
  296. r_si- : ADDRESS;
  297. r_bp * : ADDRESS;
  298. r_sp_x- : ADDRESS;
  299. r_bx- : ADDRESS;
  300. r_dx- : ADDRESS;
  301. r_cx- : ADDRESS;
  302. r_ax- : ADDRESS;
  303. r_trapno- : LONGINT;
  304. r_err- : LONGINT;
  305. r_pc * : ADDRESS;
  306. r_cs- : ADDRESS;
  307. r_flags- : LONGINT;
  308. r_sp * : ADDRESS; (* sp at error (signal) *)
  309. r_ss- : LONGINT;
  310. fpc- : ADDRESS; (* FPcontext *)
  311. oldmask- : LONGINT;
  312. cr2- : LONGINT
  313. END;
  314. FPcontext* = POINTER TO FPcontextDesc;
  315. FPcontextDesc* = RECORD
  316. (* ... *)
  317. END;
  318. PThreadAttr = RECORD
  319. reserved1-: ARRAY 5 OF ADDRESS;
  320. reserved2-: ARRAY 4 OF WORD;
  321. END;
  322. PtraceRegsStruct = RECORD
  323. ebx, ecx, edx, esi, edi, ebp, eax: WORD;
  324. DS, ES, FS, GS, AX, IP, CS: WORD;
  325. flags: SET;
  326. esp: WORD;
  327. ss: WORD;
  328. END;
  329. Sigaction = RECORD
  330. sa_handler: ADDRESS;
  331. (*filler1: ADDRESS;*)
  332. sa_mask: Sigset_t;
  333. sa_flags: ADDRESS;
  334. filler: ADDRESS;
  335. END;
  336. Sched_param = RECORD
  337. sched_priority: LONGINT;
  338. safety: ARRAY 8 OF ADDRESS;
  339. END;
  340. VAR
  341. suspend_mutex: MutexType;
  342. mainthread: Thread_t;
  343. suspend_done: LONGINT;
  344. resume_done: LONGINT;
  345. sasuspend, saresume: Sigaction;
  346. argc-: LONGINT; argv-: ADDRESS; environ-: ADDRESS;
  347. sysinfo-: RECORD
  348. sysname-, nodename-, release-, version-, machine-: ARRAY 65 OF CHAR;
  349. END;
  350. sigstack-: ARRAY 32*4096 OF CHAR;
  351. ptrace: PROCEDURE {C} (request: WORD; pid: Thread_t; adr, data: ADDRESS): WORD;
  352. getcontext-: PROCEDURE {C} (context: ADDRESS): WORD;
  353. pthread_mutex_init: PROCEDURE {C} (mutex: ADDRESS; mutexattr: ADDRESS): WORD;
  354. pthread_mutex_destroy: PROCEDURE {C} (mutex: ADDRESS): WORD;
  355. pthread_mutex_lock: PROCEDURE {C} (mutex: ADDRESS): WORD;
  356. pthread_mutex_unlock: PROCEDURE {C} (mutex: ADDRESS): WORD;
  357. pthread_mutexattr_init: PROCEDURE {C} (mutexattr: ADDRESS): WORD;
  358. pthread_mutexattr_settype: PROCEDURE {C} (mutexattr: ADDRESS; type: WORD): WORD;
  359. pthread_cond_init: PROCEDURE {C} (cond: ADDRESS; condAttr: ADDRESS): WORD;
  360. pthread_cond_destroy: PROCEDURE {C} (cond: ADDRESS): WORD;
  361. pthread_cond_wait: PROCEDURE {C} (cond: ADDRESS; mutex: ADDRESS): WORD;
  362. pthread_cond_signal: PROCEDURE {C} (cond: ADDRESS): WORD;
  363. pthread_create: PROCEDURE {C} (newthread: ADDRESS; attr: ADDRESS; start_routine: PROCEDURE {C} (arg: PROCEDURE):ADDRESS; arg:PROCEDURE): WORD;
  364. pthread_exit: PROCEDURE {C} (thr: ADDRESS);
  365. pthread_detach: PROCEDURE {C} (thr: ADDRESS);
  366. pthread_kill: PROCEDURE {C} (thr: ADDRESS; sigid: LONGINT): LONGINT;
  367. pthread_cancel: PROCEDURE {C} (thr: ADDRESS);
  368. pthread_attr_init: PROCEDURE {C} (attr: ADDRESS);
  369. pthread_attr_setscope: PROCEDURE {C}(attr: ADDRESS; set: WORD);
  370. pthread_attr_setdetachstate: PROCEDURE {C}(attr: ADDRESS; set: WORD);
  371. pthread_attr_setstacksize: PROCEDURE {C}(attr: ADDRESS; stackSize: SIZE);
  372. pthread_self: PROCEDURE {C} (): Thread_t;
  373. sched_get_priority_max: PROCEDURE {C} (policy: LONGINT): LONGINT;
  374. sched_get_priority_min: PROCEDURE {C} (policy: LONGINT): LONGINT;
  375. pthread_setschedparam: PROCEDURE {C} (thread: Thread_t; policy: LONGINT; param: ADDRESS): WORD;
  376. pthread_getschedparam: PROCEDURE {C} (thread: Thread_t; policy: LONGINT; param: ADDRESS): WORD;
  377. pthread_setcancelstate: PROCEDURE {C} (state: LONGINT; oldstate: ADDRESS): LONGINT;
  378. pthread_setcanceltype: PROCEDURE {C} (type: LONGINT; oldtype: ADDRESS): LONGINT;
  379. sigaction: PROCEDURE {C} (signum: LONGINT; CONST act, oldact: ADDRESS): LONGINT;
  380. sigemptyset: PROCEDURE {C} (set: ADDRESS);
  381. sigfillset: PROCEDURE {C} (set: ADDRESS): LONGINT;
  382. sigsuspend: PROCEDURE {C} (set: ADDRESS): LONGINT;
  383. sigaddset: PROCEDURE {C} (set: ADDRESS; signo: LONGINT);
  384. sigdelset: PROCEDURE {C} (set: ADDRESS; signo: LONGINT);
  385. nanosleep: PROCEDURE {C} (req, rem: ADDRESS): LONGINT;
  386. sigaltstack: PROCEDURE {C} (ss, oss: ADDRESS): LONGINT;
  387. pthread_sigmask: PROCEDURE {C}(how: LONGINT; set: ADDRESS; oldset: ADDRESS): LONGINT;
  388. (*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*)
  389. posix_spawnp- : PROCEDURE{C}(pid: ADDRESS; path: ADDRESS; file_actions: ADDRESS; attrp: ADDRESS; argv: ADDRESS ; envp: ADDRESS): LONGINT;
  390. (*more restrictive than spawnp*)
  391. posix_spawn- : PROCEDURE{C}(pid: ADDRESS; path: ADDRESS; file_actions: ADDRESS; attrp: ADDRESS; argv: ADDRESS ; envp: ADDRESS): LONGINT;
  392. waitpid- : PROCEDURE{C}(pid: pid_t; status: ADDRESS; options: LONGINT): pid_t;
  393. 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*)
  394. dup2- :PROCEDURE{C}(oldfd,newfd: LONGINT): LONGINT; (*overwrites file descriptor newfd with a copy of oldfd. useful for redirecting pipes.*)
  395. dup- :PROCEDURE{C}(oldfd: LONGINT): LONGINT;
  396. read- : PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): LONGINT;
  397. write- : PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): LONGINT;
  398. open- : PROCEDURE {C} ( name: ADDRESS; flags, mode: SET ): LONGINT;
  399. close- : PROCEDURE {C} ( fd: LONGINT ): LONGINT;
  400. lseek- : PROCEDURE {C} ( fd: LONGINT; offset, origin: SIZE ): LONGINT;
  401. fsync- : PROCEDURE {C} ( fd: LONGINT ): LONGINT;
  402. ioctl- : PROCEDURE {C} ( fd: LONGINT; request: LONGINT; arg: ADDRESS ): LONGINT;
  403. unlink- : PROCEDURE {C} ( name: ADDRESS ): LONGINT;
  404. rename- : PROCEDURE {C} ( oldname, newname: ADDRESS ): LONGINT;
  405. ftruncate- : PROCEDURE {C} ( fd: LONGINT; length: SIZE ): LONGINT;
  406. chmod- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  407. utime- : PROCEDURE {C} ( name: ADDRESS; tb: ADDRESS ): LONGINT;
  408. access- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  409. select- : PROCEDURE {C} ( width: LONGINT; rd, wr, ex: ADDRESS; VAR timeout: Timeval ): LONGINT;
  410. realpath- : PROCEDURE {C} (file_name: ADDRESS; resolved_name: ADDRESS): ADDRESS;
  411. chdir- : PROCEDURE {C} ( name: ADDRESS ): LONGINT;
  412. mkdir- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  413. rmdir- : PROCEDURE {C} ( path: ADDRESS ): LONGINT;
  414. xstat- : PROCEDURE {C} ( ver: LONGINT; name: ADDRESS; VAR buf: Status ): LONGINT;
  415. lxstat- : PROCEDURE {C} ( ver: LONGINT; name: ADDRESS; VAR buf: Status ): LONGINT;
  416. fxstat- : PROCEDURE {C} ( ver: LONGINT; fd: LONGINT; VAR buf: Status ): LONGINT;
  417. getpid- : PROCEDURE {C} ( ): LONGINT;
  418. getuid- : PROCEDURE {C} ( ): LONGINT;
  419. malloc- : PROCEDURE {C} ( size: SIZE ): ADDRESS;
  420. posix_memalign- : PROCEDURE {C} ( VAR p: ADDRESS; alignment, size: SIZE ): LONGINT;
  421. free- : PROCEDURE {C} ( p: ADDRESS );
  422. mprotect- : PROCEDURE {C} ( p: ADDRESS; len: SIZE; prot: LONGINT ): LONGINT;
  423. alarm- : PROCEDURE {C} ( ms: LONGINT ): LONGINT;
  424. setitimer- : PROCEDURE {C} ( which: LONGINT; VAR value, ovalue: Itimerval ): LONGINT;
  425. getitimer- : PROCEDURE {C} ( which: LONGINT; VAR value: Itimerval ): LONGINT;
  426. gettimeofday- : PROCEDURE {C} ( VAR tv: Timeval; VAR tz: Timezone ): LONGINT;
  427. mktime- : PROCEDURE {C} ( VAR tm: Tm ): LONGINT;
  428. localtime- : PROCEDURE {C} ( CONST tv: Timeval ): TmPtr;
  429. time- : PROCEDURE {C} ( VAR tv: Timeval ): LONGINT;
  430. times- : PROCEDURE {C} ( VAR tms: Tms ): LONGINT;
  431. system- : PROCEDURE {C} ( cmd: ADDRESS );
  432. uname- : PROCEDURE {C} ( utsname: ADDRESS ): LONGINT;
  433. getcwd- : PROCEDURE {C} ( buf: ADDRESS; len: SIZE ): ADDRESS;
  434. getenv- : PROCEDURE {C} ( name: ADDRESS ): ADDRESS;
  435. opendir- : PROCEDURE {C} ( name: ADDRESS ): ADDRESS;
  436. readdir- : PROCEDURE {C} ( dir: ADDRESS ): Dirent;
  437. closedir- : PROCEDURE {C} ( dir: ADDRESS );
  438. sigsetjmp- : PROCEDURE {C} ( env: ADDRESS; savemask: LONGINT ): LONGINT;
  439. siglongjmp- : PROCEDURE {C} ( env: ADDRESS; val: LONGINT );
  440. kill- : PROCEDURE {C} ( pid, sig: LONGINT ): LONGINT;
  441. exit- : PROCEDURE {C} ( status: LONGINT );
  442. perror- : PROCEDURE {C} ( msg: ADDRESS );
  443. errno_location: PROCEDURE {C} ( ): ADDRESS;
  444. xSetErrorHandler: PROCEDURE {C} (h: ADDRESS): WORD;
  445. xSetIOErrorHandler: PROCEDURE {C} (h: ADDRESS): WORD;
  446. libc-: LONGINT;
  447. libp-: LONGINT;
  448. libx-: LONGINT;
  449. libraryPaths: ARRAY 8 OF ARRAY 32 OF CHAR;
  450. noPaths: LONGINT;
  451. (*
  452. mtxInit: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Mutex_t;
  453. mtxDestroy: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  454. mtxLock: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  455. mtxUnlock: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  456. conInit: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Condition_t;
  457. conDestroy: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t );
  458. conWait: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t; mtx: Unix.Mutex_t );
  459. conSignal: PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t );
  460. thrStart: PROCEDURE {REALTIME, C} ( p: PROCEDURE; stackLen: LONGINT ): Unix.Thread_t;
  461. thrThis: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Thread_t;
  462. thrSleep: PROCEDURE {REALTIME, C} ( ms: LONGINT );
  463. thrYield: PROCEDURE {REALTIME, C} ( dummy: LONGINT );
  464. thrExit: PROCEDURE {REALTIME, C} ( dummy: LONGINT );
  465. thrSuspend: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  466. thrResume: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  467. thrSetPriority: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t; prio: LONGINT );
  468. thrGetPriority: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t ): LONGINT;
  469. thrKill: PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
  470. *)
  471. TYPE
  472. PROCEDURE MtxInit*(dummy: LONGINT): Mutex_t;
  473. VAR
  474. mtx: Mutex_t;
  475. BEGIN
  476. mtx := malloc(SIZEOF(MutexType));
  477. ASSERT(mtx # 0);
  478. ASSERT(pthread_mutex_init(mtx, NIL) = 0);
  479. RETURN mtx;
  480. END MtxInit;
  481. PROCEDURE RecursiveMtxInit*(dummy: LONGINT): Mutex_t;
  482. VAR
  483. mtx: Mutex_t;
  484. attr: MutexAttributeType;
  485. res: WORD;
  486. CONST
  487. Recursive = 1;
  488. BEGIN
  489. mtx := malloc(SIZEOF(MutexType));
  490. res := pthread_mutexattr_init(ADDRESS OF attr);
  491. res := pthread_mutexattr_settype(ADDRESS OF attr, Recursive);
  492. ASSERT(mtx # 0);
  493. ASSERT(pthread_mutex_init(mtx, ADDRESS OF attr) = 0);
  494. RETURN mtx;
  495. END RecursiveMtxInit;
  496. PROCEDURE MtxDestroy*(mtx: Mutex_t);
  497. BEGIN
  498. ASSERT(pthread_mutex_destroy(mtx) = 0);
  499. END MtxDestroy;
  500. PROCEDURE MtxLock*(mtx: Mutex_t);
  501. BEGIN
  502. ASSERT(pthread_mutex_lock(mtx) = 0);
  503. END MtxLock;
  504. PROCEDURE MtxUnlock*(mtx: Mutex_t);
  505. BEGIN
  506. ASSERT(pthread_mutex_unlock(mtx) = 0);
  507. END MtxUnlock;
  508. PROCEDURE ConInit* (dummy: LONGINT): Condition_t;
  509. VAR cond: Condition_t;
  510. BEGIN
  511. cond := malloc(SIZEOF(ConditionType));
  512. ASSERT(cond # 0);
  513. ASSERT(pthread_cond_init(cond, NIL)=0);
  514. RETURN cond;
  515. END ConInit;
  516. PROCEDURE ConDestroy*(con: Condition_t);
  517. BEGIN
  518. ASSERT(pthread_cond_destroy(con) = 0);
  519. END ConDestroy;
  520. PROCEDURE ConWait*(con: Condition_t; mtx: Mutex_t);
  521. BEGIN
  522. ASSERT(pthread_cond_wait(con, mtx) = 0);
  523. END ConWait;
  524. PROCEDURE ConSignal*(cond: Condition_t);
  525. BEGIN
  526. ASSERT(pthread_cond_signal(cond) = 0);
  527. END ConSignal;
  528. PROCEDURE ThrThis*(dummy: LONGINT): Thread_t;
  529. BEGIN
  530. RETURN pthread_self();
  531. END ThrThis;
  532. PROCEDURE ThrYield*(dummy: LONGINT);
  533. BEGIN
  534. ThrSleep(1);
  535. END ThrYield;
  536. PROCEDURE ThrExit*(dummy: LONGINT);
  537. BEGIN
  538. pthread_exit(0);
  539. END ThrExit;
  540. PROCEDURE ThrSetPriority*(thr: Thread_t; prio: LONGINT);
  541. VAR
  542. param: Sched_param;
  543. policy: LONGINT;
  544. BEGIN
  545. IF pthread_getschedparam( thr, ADDRESS OF policy, ADDRESS OF param ) # 0 THEN END;
  546. param.sched_priority := prio;
  547. IF pthread_setschedparam( thr, SCHED_OTHER, ADDRESS OF param ) # 0 THEN
  548. Perror("pthread_setschedparam");
  549. END
  550. END ThrSetPriority;
  551. PROCEDURE ThrGetPriority*(thr: Thread_t):LONGINT;
  552. VAR
  553. param: Sched_param;
  554. policy: LONGINT;
  555. BEGIN
  556. IF pthread_getschedparam( thr, ADDRESS OF policy, ADDRESS OF param ) # 0 THEN END;
  557. RETURN param.sched_priority;
  558. END ThrGetPriority;
  559. VAR
  560. sigstk: Stack;
  561. PROCEDURE SetSigaltstack;
  562. BEGIN
  563. IF sigaltstack(ADDRESS OF sigstk, NIL) < 0 THEN
  564. Perror("sigaltstack")
  565. END;
  566. END SetSigaltstack;
  567. PROCEDURE {C} Starter(proc: PROCEDURE): ADDRESS;
  568. VAR
  569. me: Thread_t;
  570. old, new: Sigset_t;
  571. param: Sched_param;
  572. res: LONGINT;
  573. BEGIN
  574. me := pthread_self();
  575. SetSigaltstack();
  576. IF sigfillset( ADDRESS OF new ) < 0 THEN
  577. Perror("sigfillset");
  578. END;
  579. sigdelset( ADDRESS OF new, SIGILL );
  580. sigdelset( ADDRESS OF new, SIGTRAP );
  581. sigdelset( ADDRESS OF new, SIGFPE );
  582. sigdelset( ADDRESS OF new, SIGBUS );
  583. sigdelset( ADDRESS OF new, SIGSEGV );
  584. sigdelset( ADDRESS OF new, SIGTERM );
  585. sigdelset( ADDRESS OF new, T_SIGSUSPEND );
  586. res := pthread_sigmask( SIG_SETMASK, ADDRESS OF new, ADDRESS OF old );
  587. res := pthread_setcancelstate( PTHREAD_CANCEL_ENABLE, NIL );
  588. res := pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NIL );
  589. param.sched_priority := 0;
  590. res := pthread_setschedparam( me, SCHED_OTHER, ADDRESS OF param );
  591. proc();
  592. pthread_exit( NIL );
  593. RETURN NIL;
  594. END Starter;
  595. PROCEDURE ThrStart*(p: PROCEDURE; stackSize: SIZE): Thread_t;
  596. VAR
  597. attr: PThreadAttr;
  598. id: Thread_t;
  599. res,i: LONGINT;
  600. CONST
  601. PTHREAD_SCOPE_SYSTEM = 0;
  602. PTHREAD_CREATE_DETACHED = 1;
  603. BEGIN
  604. pthread_attr_init(ADDRESS OF attr);
  605. pthread_attr_setscope(ADDRESS OF attr, PTHREAD_SCOPE_SYSTEM);
  606. pthread_attr_setdetachstate(ADDRESS OF attr, PTHREAD_CREATE_DETACHED);
  607. (*pthread_attr_setdetachstate(ADDRESS OF attr, 0);*)
  608. pthread_attr_setstacksize(ADDRESS OF attr, stackSize);
  609. res := pthread_create(ADDRESS OF id, ADDRESS OF attr, Starter, p);
  610. RETURN id;
  611. END ThrStart;
  612. PROCEDURE ThrSleep*(ms: LONGINT);
  613. VAR
  614. sltime,rem: RECORD
  615. tv_sec: WORD; (* seconds *)
  616. tv_nsec: WORD; (* nanoseconds *)
  617. END;
  618. BEGIN
  619. sltime.tv_sec := ms DIV 1000;
  620. sltime.tv_nsec := 1000000*(ms MOD 1000);
  621. WHILE (nanosleep(ADDRESS OF sltime, ADDRESS OF rem) < 0) DO
  622. (* check error ! *)
  623. sltime := rem;
  624. END;
  625. END ThrSleep;
  626. PROCEDURE ThrKill*(thr: Thread_t);
  627. BEGIN
  628. IF (thr # mainthread) THEN
  629. pthread_detach( thr );
  630. IF (thr = pthread_self()) THEN
  631. pthread_exit( 0 );
  632. ELSE
  633. pthread_cancel( thr );
  634. END
  635. END;
  636. END ThrKill;
  637. (* did not work
  638. PROCEDURE TraceThread*(p: Thread_t);
  639. VAR regs: PtraceRegsStruct; res: WORD;
  640. BEGIN
  641. res := ptrace(PTRACE_ATTACH, p , NIL, NIL);
  642. IF res < 0 THEN Perror("attach") END;
  643. TRACE(res);
  644. res := ptrace(PTRACE_GETREGS,p,NIL, ADDRESS OF regs);
  645. IF res < 0 THEN Perror("getregs") END;
  646. TRACE(res);
  647. TRACE(regs.ebx, regs.ecx, regs.edx, regs.eax);
  648. TRACE(regs.ebp, regs.esp, regs.IP, regs.flags);
  649. res := ptrace(PTRACE_DETACH, p, NIL, NIL);
  650. END TraceThread;
  651. *)
  652. PROCEDURE {C} resume_handler(sig: LONGINT);
  653. BEGIN
  654. END resume_handler;
  655. PROCEDURE ThrResume*(thr: Thread_t);
  656. VAR n: LONGINT; res: LONGINT;
  657. BEGIN
  658. res := pthread_mutex_lock( ADDRESS OF suspend_mutex );
  659. resume_done := 0; n := 1;
  660. res := pthread_kill( thr, T_SIGRESUME );
  661. WHILE (resume_done # 1) & (n < 50) DO ThrSleep(1); INC(n) END;
  662. res := pthread_mutex_unlock( ADDRESS OF suspend_mutex );
  663. END ThrResume;
  664. VAR suspendHandler*: PROCEDURE(c: Ucontext);
  665. PROCEDURE {C} suspend_handler(sig: LONGINT; scp: ADDRESS; ucp: ADDRESS);
  666. VAR block: Sigset_t; res: LONGINT;
  667. BEGIN
  668. IF suspendHandler # NIL THEN suspendHandler(S.VAL(Ucontext,ucp)) END;
  669. res := sigfillset( ADDRESS OF block );
  670. sigdelset( ADDRESS OF block, T_SIGRESUME );
  671. suspend_done := 1;
  672. res := sigsuspend( ADDRESS OF block ); (* await T_SIGRESUME *)
  673. resume_done := 1;
  674. END suspend_handler;
  675. PROCEDURE ThrSuspend*(thr: Thread_t);
  676. VAR res: LONGINT;
  677. BEGIN
  678. res := pthread_mutex_lock(ADDRESS OF suspend_mutex );
  679. suspend_done := 0;
  680. res := pthread_kill( thr, T_SIGSUSPEND );
  681. WHILE (suspend_done # 1) DO ThrSleep( 1 ) END;
  682. res := pthread_mutex_unlock( ADDRESS OF suspend_mutex );
  683. END ThrSuspend;
  684. PROCEDURE ThrInitialize*(VAR low, high: LONGINT): BOOLEAN;
  685. VAR
  686. param: Sched_param;
  687. BEGIN
  688. (*struct sched_param param;*)
  689. ASSERT(pthread_mutex_init( ADDRESS OF suspend_mutex, NIL ) = 0);
  690. mainthread := pthread_self();
  691. high := sched_get_priority_max(SCHED_OTHER);
  692. low := sched_get_priority_min(SCHED_OTHER);
  693. param.sched_priority := high;
  694. IF pthread_setschedparam( mainthread, SCHED_OTHER, ADDRESS OF param)#0 THEN
  695. Perror("ThrInitialize: setparam");
  696. END;
  697. sigemptyset( ADDRESS OF sasuspend.sa_mask );
  698. sigaddset( ADDRESS OF sasuspend.sa_mask, T_SIGRESUME );
  699. sasuspend.sa_flags := SA_SIGINFO + (*SA_ONSTACK +*) SA_NODEFER;;
  700. sasuspend.sa_handler := suspend_handler;
  701. ASSERT(sigaction( T_SIGSUSPEND, ADDRESS OF sasuspend, NIL ) = 0);
  702. sigemptyset( ADDRESS OF saresume.sa_mask );
  703. saresume.sa_flags := 0;
  704. saresume.sa_handler := resume_handler;
  705. ASSERT(sigaction( T_SIGRESUME, ADDRESS OF saresume, NIL ) = 0);
  706. RETURN TRUE;
  707. END ThrInitialize;
  708. PROCEDURE CopyContext*(CONST from: McontextDesc; VAR to: McontextDesc);
  709. BEGIN
  710. S.MOVE(ADDRESS OF from, ADDRESS OF to, SIZE OF McontextDesc);
  711. END CopyContext;
  712. PROCEDURE ModifyContext*( cont: Ucontext; pc, bp, sp: LONGINT );
  713. BEGIN
  714. cont.mc.r_pc := pc;
  715. cont.mc.r_bp := bp;
  716. cont.mc.r_sp := sp;
  717. END ModifyContext;
  718. PROCEDURE Perror*( CONST msg: ARRAY OF CHAR );
  719. BEGIN
  720. perror( ADDRESSOF( msg ) )
  721. END Perror;
  722. PROCEDURE Dlsym*( lib: ADDRESS; CONST sym: ARRAY OF CHAR; objAddr: ADDRESS );
  723. VAR val: LONGINT;
  724. BEGIN
  725. Glue.Dlsym( lib, sym, objAddr );
  726. S.GET( objAddr, val );
  727. IF val = 0 THEN
  728. Trace.String( "Unix.Dlsym: entry '" ); Trace.String( sym ); Trace.String( "' not found" );
  729. Trace.Ln;
  730. exit(0);
  731. END
  732. END Dlsym;
  733. PROCEDURE Dlopen*( CONST libname: ARRAY OF CHAR; mode: LONGINT ): ADDRESS;
  734. VAR h: ADDRESS; i, j, k: INTEGER;
  735. p: ARRAY 256 OF CHAR;
  736. BEGIN
  737. IF libname[0] = '/' THEN h := Glue.dlopen( ADDRESSOF( libname ), mode );
  738. ELSE
  739. i := 0; h := 0;
  740. WHILE (h = 0) & (i < noPaths) DO
  741. COPY( libraryPaths[i], p ); j := 0;
  742. WHILE p[j] # 0X DO INC( j ) END;
  743. p[j] := '/'; k := 0;
  744. REPEAT INC( j ); p[j] := libname[k]; INC( k ) UNTIL p[j] = 0X;
  745. h := Glue.dlopen( ADDRESSOF( p ), mode ); INC( i )
  746. END
  747. END;
  748. IF h = 0 THEN
  749. Trace.String( "Unix.Dlopen: loading library " );
  750. Trace.String( libname ); Trace.String( " failed" ); Trace.Ln;
  751. LOOP END;
  752. END;
  753. RETURN h
  754. END Dlopen;
  755. PROCEDURE Dlclose*( lib: ADDRESS );
  756. BEGIN
  757. Glue.dlclose( lib )
  758. END Dlclose;
  759. PROCEDURE GetArg*( no: LONGINT; VAR val: ARRAY OF CHAR );
  760. VAR ch: CHAR; adr: ADDRESS; i: LONGINT;
  761. BEGIN
  762. IF no >= argc THEN val[0] := 0X
  763. ELSE
  764. S.GET( argv + SIZEOF(ADDRESS)*no, adr ); i := 0;
  765. REPEAT S.GET( adr, ch ); val[i] := ch; INC( adr ); INC( i ); UNTIL (ch = 0X) OR (i >= LEN( val ));
  766. END
  767. END GetArg;
  768. PROCEDURE GetArgval*( CONST argName: ARRAY OF CHAR; VAR val: ARRAY OF CHAR );
  769. VAR i: INTEGER;
  770. buf: ARRAY 40 OF CHAR;
  771. BEGIN
  772. i := 1;
  773. WHILE i < argc - 1 DO
  774. GetArg( i, buf );
  775. IF buf = argName THEN GetArg( i + 1, val ); RETURN END;
  776. INC( i )
  777. END;
  778. val[0] := 0X
  779. END GetArgval;
  780. PROCEDURE getSysinfo;
  781. VAR res: LONGINT; p: INTEGER;
  782. buf: ARRAY 4096 OF CHAR;
  783. PROCEDURE copy( VAR p: INTEGER; VAR dest: ARRAY OF CHAR );
  784. VAR i: INTEGER;
  785. BEGIN
  786. WHILE buf[p] <= ' ' DO INC( p ) END;
  787. i := 0;
  788. REPEAT dest[i] := buf[p]; INC( i ); INC( p ) UNTIL (buf[p - 1] = 0X) OR (i >= LEN( dest ));
  789. dest[i - 1] := 0X
  790. END copy;
  791. BEGIN
  792. FOR p := 0 TO 4096 - 1 DO buf[p] := 0X END;
  793. res := uname( ADDRESSOF( buf ) );
  794. p := 0;
  795. copy( p, sysinfo.sysname );
  796. copy( p, sysinfo.nodename );
  797. copy( p, sysinfo.release );
  798. copy( p, sysinfo.version );
  799. copy( p, sysinfo.machine );
  800. END getSysinfo;
  801. PROCEDURE CreateSignalStack;
  802. BEGIN
  803. sigstk.sp := ADDRESS OF sigstack;
  804. sigstk.size := LEN(sigstack);
  805. sigstk.flags := {};
  806. END CreateSignalStack;
  807. (*
  808. static void sighandler( int sig, siginfo_t *scp, void *ucp ) {
  809. if (debug | (AosTrap == NULL)) {
  810. printf("\nhandler for signal %d got called, ucp = %p\n", sig, ucp);
  811. if (AosTrap == NULL) exit(1);
  812. }
  813. AosTrap(0, ucp, scp, sig); /* rev. order: Oberon <--> C */
  814. }
  815. *)
  816. VAR trap: SignalHandler;
  817. PROCEDURE {C} SigHandler ( sig: LONGINT; scp: ADDRESS; ucp: ADDRESS); (* reversed arguments !! *)
  818. BEGIN
  819. IF trap # NIL THEN
  820. trap(sig, scp, ucp, 0);
  821. ELSE
  822. TRACE(sig, scp, ucp)
  823. END;
  824. END SigHandler;
  825. PROCEDURE InstallSignalHandler* ( h: SignalHandler );
  826. BEGIN
  827. trap := h;
  828. END InstallSignalHandler;
  829. PROCEDURE InstallHandler(sig: LONGINT);
  830. VAR
  831. act: Sigaction;
  832. mask: Sigset_t;
  833. BEGIN
  834. sigemptyset(ADDRESS OF mask);
  835. act.sa_mask := mask;
  836. IF sig = SIGSEGV THEN (* segmentation violation *)
  837. act.sa_flags := SA_SIGINFO + SA_ONSTACK + SA_NODEFER;
  838. ELSE
  839. act.sa_flags := SA_SIGINFO + (* SA_ONSTACK + *) SA_NODEFER;
  840. END;
  841. act.sa_handler := ADDRESS OF SigHandler;
  842. IF sigaction( sig, ADDRESS OF act, 0 ) # 0 THEN
  843. Perror("sigaction");
  844. END;
  845. END InstallHandler;
  846. PROCEDURE fstat* ( fd: LONGINT; VAR buf: Status ): LONGINT;
  847. VAR res: LONGINT;
  848. BEGIN
  849. (*
  850. dev- : DevT;
  851. unused1- : LONGINT;
  852. ino- : LONGINT;
  853. mode- : LONGINT;
  854. nlink- : LONGINT;
  855. uid- : LONGINT;
  856. gid- : LONGINT;
  857. rdev- : DevT;
  858. unused2- : LONGINT;
  859. size- : LONGINT;
  860. blksize- : LONGINT;
  861. blocks- : LONGINT;
  862. atime- : Timeval;
  863. mtime- : Timeval;
  864. ctime- : Timeval;
  865. unused- : ARRAY 2 OF LONGINT;
  866. *)
  867. res := fxstat(3, fd, buf);
  868. RETURN res;
  869. END fstat;
  870. PROCEDURE stat* ( path: ADDRESS; VAR buf: Status ): LONGINT;
  871. BEGIN
  872. RETURN xstat( 3, path, buf );
  873. END stat;
  874. PROCEDURE InitSignalHandler;
  875. VAR i: LONGINT;
  876. BEGIN
  877. FOR i := 1 TO 15 DO
  878. IF i # 9 THEN InstallHandler(i) END;
  879. END;
  880. END InitSignalHandler;
  881. PROCEDURE errno*(): LONGINT;
  882. VAR loc: ADDRESS;
  883. BEGIN
  884. loc := errno_location();
  885. RETURN S.GET32(loc);
  886. END errno;
  887. TYPE OberonXErrorHandler* = PROCEDURE (disp, err: ADDRESS): LONGINT;
  888. TYPE OberonXIOErrorHandler* = PROCEDURE (disp: ADDRESS): LONGINT;
  889. VAR oberonXErrorHandler:OberonXErrorHandler;
  890. VAR oberonXIOErrorHandler: OberonXIOErrorHandler;
  891. TYPE pid_t *= LONGINT;
  892. TYPE path_t *= ARRAY OF CHAR;
  893. TYPE arg_t *= ARRAY OF CHAR;
  894. TYPE argv_t *= ARRAY OF arg_t;
  895. PROCEDURE {C} X11ErrorHandler(d: ADDRESS; err: ADDRESS): WORD;
  896. VAR res: LONGINT;
  897. BEGIN
  898. TRACE(d,err);
  899. IF oberonXErrorHandler # NIL THEN
  900. res := oberonXErrorHandler(d, err);
  901. END;
  902. RETURN 0;
  903. END X11ErrorHandler;
  904. PROCEDURE X11IOErrorHandler(d: ADDRESS): WORD;
  905. VAR res: LONGINT;
  906. BEGIN
  907. TRACE(d);
  908. IF oberonXIOErrorHandler # NIL THEN
  909. res := oberonXIOErrorHandler(d);
  910. END;
  911. RETURN 0;
  912. END X11IOErrorHandler;
  913. PROCEDURE InitXErrorHandlers*(xErrorHandler: OberonXErrorHandler; xIOErrorHandler: OberonXIOErrorHandler);
  914. VAR res: WORD;
  915. BEGIN
  916. oberonXErrorHandler := xErrorHandler;
  917. oberonXIOErrorHandler := xIOErrorHandler;
  918. res := xSetErrorHandler(ADDRESS OF X11ErrorHandler);
  919. res := xSetIOErrorHandler(ADDRESS OF X11IOErrorHandler);
  920. END InitXErrorHandlers;
  921. PROCEDURE Init;
  922. VAR test: ADDRESS; i: LONGINT; s: ARRAY 256 OF CHAR;
  923. BEGIN
  924. argc := Glue.argc;
  925. argv := Glue.argv;
  926. environ := Glue.environ;
  927. libraryPaths[0] := "/lib/i386-linux-gnu";
  928. libraryPaths[1] := "/usr/lib/i386-linux-gnu";
  929. libraryPaths[2] := "/lib";
  930. libraryPaths[3] := "/usr/lib";
  931. noPaths := 4;
  932. libc := Dlopen( libcname, 2 );
  933. libp := Dlopen( libpthreadname, 2);
  934. Dlsym( libc, "exit", ADDRESSOF( exit ) );
  935. Dlsym( libc, "ptrace", ADDRESSOF(ptrace));
  936. Dlsym( libc, "getcontext", ADDRESSOF(getcontext));
  937. Dlsym( libc, "pthread_mutex_init", ADDRESSOF(pthread_mutex_init));
  938. Dlsym( libc, "pthread_mutex_destroy", ADDRESSOF(pthread_mutex_destroy));
  939. Dlsym( libc, "pthread_mutex_lock", ADDRESSOF(pthread_mutex_lock));
  940. Dlsym( libc, "pthread_mutex_unlock", ADDRESSOF(pthread_mutex_unlock));
  941. Dlsym( libp, "pthread_mutexattr_init", ADDRESSOF(pthread_mutexattr_init));
  942. Dlsym( libp, "pthread_mutexattr_settype", ADDRESSOF(pthread_mutexattr_settype));
  943. Dlsym( libc, "pthread_cond_init", ADDRESSOF(pthread_cond_init));
  944. Dlsym( libc, "pthread_cond_destroy", ADDRESSOF(pthread_cond_destroy));
  945. Dlsym( libc, "pthread_cond_wait", ADDRESSOF(pthread_cond_wait));
  946. Dlsym( libc, "pthread_cond_signal", ADDRESSOF(pthread_cond_signal));
  947. Dlsym( libp, "pthread_create", ADDRESSOF(pthread_create));
  948. Dlsym( libp, "pthread_exit", ADDRESSOF(pthread_exit));
  949. Dlsym( libp, "pthread_detach", ADDRESSOF(pthread_detach));
  950. Dlsym( libp, "pthread_cancel", ADDRESSOF(pthread_cancel));
  951. Dlsym( libp, "pthread_kill", ADDRESSOF(pthread_kill));
  952. Dlsym( libp, "pthread_sigmask", ADDRESSOF(pthread_sigmask));
  953. Dlsym( libp, "pthread_setcancelstate", ADDRESSOF(pthread_setcancelstate));
  954. Dlsym( libp, "pthread_setcanceltype", ADDRESSOF(pthread_setcanceltype));
  955. Dlsym( libp, "pthread_attr_init", ADDRESSOF(pthread_attr_init));
  956. Dlsym( libp, "pthread_attr_setscope", ADDRESSOF(pthread_attr_setscope));
  957. Dlsym( libp, "pthread_attr_setdetachstate", ADDRESSOF(pthread_attr_setdetachstate));
  958. Dlsym( libp, "pthread_attr_setstacksize", ADDRESSOF(pthread_attr_setstacksize));
  959. Dlsym( libp, "pthread_self", ADDRESSOF(pthread_self));
  960. Dlsym( libc, "posix_spawnp", ADDRESSOF(posix_spawnp));
  961. Dlsym( libc, "posix_spawn", ADDRESSOF(posix_spawn));
  962. Dlsym( libc, "waitpid", ADDRESSOF(waitpid));
  963. Dlsym( libc, "pipe", ADDRESSOF(pipe));
  964. Dlsym( libc, "dup2",ADDRESSOF(dup2));
  965. Dlsym( libc, "dup", ADDRESSOF(dup));
  966. Dlsym( libc, "sched_get_priority_max", ADDRESSOF(sched_get_priority_max));
  967. Dlsym( libc, "sched_get_priority_min", ADDRESSOF(sched_get_priority_min));
  968. Dlsym( libc, "pthread_setschedparam", ADDRESSOF(pthread_setschedparam));
  969. Dlsym( libc, "pthread_getschedparam", ADDRESSOF(pthread_getschedparam));
  970. Dlsym( libc, "sigaction", ADDRESSOF(sigaction));
  971. Dlsym( libc, "sigemptyset", ADDRESSOF(sigemptyset));
  972. Dlsym( libc, "sigfillset", ADDRESSOF(sigfillset));
  973. Dlsym( libc, "sigaddset", ADDRESSOF(sigaddset));
  974. Dlsym( libc, "sigdelset", ADDRESSOF(sigdelset));
  975. Dlsym( libc, "nanosleep", ADDRESSOF(nanosleep));
  976. Dlsym( libc, "sigaltstack", ADDRESSOF(sigaltstack));
  977. Dlsym( libc, "sigsuspend", ADDRESSOF(sigsuspend));
  978. Dlsym( libc, "read", ADDRESSOF( read ) );
  979. Dlsym( libc, "write", ADDRESSOF( write ) );
  980. Dlsym( libc, "open", ADDRESSOF( open ) );
  981. Dlsym( libc, "close", ADDRESSOF( close ) );
  982. Dlsym( libc, "lseek", ADDRESSOF( lseek ) );
  983. Dlsym( libc, "realpath", ADDRESSOF( realpath ) );
  984. Dlsym( libc, "fsync", ADDRESSOF( fsync ) );
  985. Dlsym( libc, "ioctl", ADDRESSOF( ioctl ) );
  986. Dlsym( libc, "unlink", ADDRESSOF( unlink ) );
  987. Dlsym( libc, "rename", ADDRESSOF( rename ) );
  988. Dlsym( libc, "ftruncate", ADDRESSOF( ftruncate ) );
  989. Dlsym( libc, "chmod", ADDRESSOF( chmod ) );
  990. Dlsym( libc, "utime", ADDRESSOF( utime ) );
  991. Dlsym( libc, "access", ADDRESSOF( access ) );
  992. Dlsym( libc, "select", ADDRESSOF( select ) );
  993. Dlsym( libc, "chdir", ADDRESSOF( chdir ) );
  994. Dlsym( libc, "mkdir", ADDRESSOF( mkdir ) );
  995. Dlsym( libc, "rmdir", ADDRESSOF( rmdir ) );
  996. Dlsym( libc, "__xstat", ADDRESSOF( xstat ) );
  997. Dlsym( libc, "__lxstat", ADDRESSOF( lxstat ) );
  998. Dlsym( libc, "__fxstat", ADDRESSOF( fxstat ) );
  999. Dlsym( libc, "getpid", ADDRESSOF( getpid ) );
  1000. Dlsym( libc, "getuid", ADDRESSOF( getuid ) );
  1001. Dlsym( libc, "alarm", ADDRESSOF( alarm ) );
  1002. Dlsym( libc, "setitimer", ADDRESSOF( setitimer ) );
  1003. Dlsym( libc, "getitimer", ADDRESSOF( getitimer ) );
  1004. Dlsym( libc, "gettimeofday", ADDRESSOF( gettimeofday ) );
  1005. Dlsym( libc, "mktime", ADDRESSOF( mktime ) );
  1006. Dlsym( libc, "localtime", ADDRESSOF( localtime ) );
  1007. Dlsym( libc, "time", ADDRESSOF( time ) );
  1008. Dlsym( libc, "times", ADDRESSOF( times ) );
  1009. Dlsym( libc, "getcwd", ADDRESSOF( getcwd ) );
  1010. Dlsym( libc, "getenv", ADDRESSOF( getenv ) );
  1011. Dlsym( libc, "opendir", ADDRESSOF( opendir ) );
  1012. Dlsym( libc, "readdir", ADDRESSOF( readdir ) );
  1013. Dlsym( libc, "closedir", ADDRESSOF( closedir ) );
  1014. Dlsym( libc, "__sigsetjmp", ADDRESSOF( sigsetjmp ) );
  1015. Dlsym( libc, "siglongjmp", ADDRESSOF( siglongjmp ) );
  1016. Dlsym( libc, "malloc", ADDRESSOF( malloc ) );
  1017. Dlsym( libc, "posix_memalign", ADDRESSOF( posix_memalign ) );
  1018. Dlsym( libc, "free", ADDRESSOF( free ) );
  1019. Dlsym( libc, "mprotect", ADDRESSOF( mprotect ) );
  1020. Dlsym( libc, "system", ADDRESSOF( system ) );
  1021. Dlsym( libc, "uname", ADDRESSOF( uname ) );
  1022. Dlsym( libc, "kill", ADDRESSOF( kill ) );
  1023. Dlsym( libc, "perror", ADDRESSOF( perror ) );
  1024. Dlsym( libc, "__errno_location", ADDRESSOF(errno_location ) );
  1025. getSysinfo;
  1026. CreateSignalStack;
  1027. InitSignalHandler;
  1028. END Init;
  1029. (* load X11 related libaries only on demand *)
  1030. PROCEDURE LinkToX*;
  1031. BEGIN
  1032. libx := Dlopen( libX11name, 2);
  1033. Dlsym( libx, "XSetErrorHandler", ADDRESS OF xSetErrorHandler);
  1034. Dlsym( libx, "XSetIOErrorHandler", ADDRESS OF xSetIOErrorHandler);
  1035. END LinkToX;
  1036. PROCEDURE {INITIAL} Init0;
  1037. BEGIN
  1038. Init;
  1039. END Init0;
  1040. END Unix.