Generic.Unix.I386.Machine.Mod 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043
  1. MODULE Machine; (** AUTHOR "pjm, G.F."; PURPOSE "Bootstrapping, configuration and machine interface"; *)
  2. IMPORT S := SYSTEM, Trace, Unix, Glue;
  3. CONST
  4. DefaultConfig = "Color 0 StackSize 128";
  5. Version = "Aos (rev.6640)";
  6. DefaultObjectFileExtension* = ".Obj";
  7. Second* = 1000; (* frequency of ticks increments in Hz *)
  8. (** bits in features variable *)
  9. MTTR* = 12; MMX* = 23;
  10. AddrSize = SIZEOF( ADDRESS );
  11. SizeSize = SIZEOF( SIZE );
  12. AddressSize = SIZEOF(ADDRESS);
  13. BlockHeaderSize = 2 * AddressSize;
  14. RecordDescSize = 4 * AddressSize; (* needs to be adapted in case Heaps.RecordBlockDesc is changed *)
  15. StaticBlockSize = 32; (* static heap block size *)
  16. BlockSize = 32;
  17. MemBlockSize* = 64*1024*1024;
  18. TraceOutput* = 0; (* Trace output *)
  19. Memory* = 1; (*! Virtual memory management, stack and page allocation, not used in UnixAos *)
  20. Heaps* = 2; (* Storage allocation and Garbage collection *)
  21. Interrupts* = 3; (*! Interrupt handling, not used in UnixAos *)
  22. Modules* = 4; (* Module list *)
  23. Objects* = 5; (*! Ready queue, not used in UnixAos *)
  24. Processors* = 6; (*! Interprocessor interrupts, not used in UnixAos *)
  25. KernelLog* = 7; (* Atomic output *)
  26. X11* = 8; (* XWindows I/O *)
  27. Trap* = 9;
  28. GC = 10;
  29. MaxLocks* = 11; (* { <= 32 } *)
  30. MaxCPU* = 4;
  31. IsCooperative* = FALSE;
  32. TYPE
  33. Vendor* = ARRAY 13 OF CHAR;
  34. MemoryBlock* = POINTER TO MemoryBlockDesc;
  35. MemoryBlockDesc* = RECORD
  36. next- {UNTRACED}: MemoryBlock;
  37. startAdr-: ADDRESS; (* sort key in linked list of memory blocks *)
  38. size-: SIZE;
  39. beginBlockAdr-, endBlockAdr-: ADDRESS
  40. END;
  41. (** processor state, ordering of record fields is predefined! *)
  42. (*!(not used in UnixAos, for interface compatibility only)*)
  43. State* = RECORD (* offsets used in FieldInterrupt, FieldIRQ and Objects.RestoreState *)
  44. EDI*, ESI*, ERR*, ESP0*, EBX*, EDX*, ECX*, EAX*: LONGINT; (** ESP0 = ADR(s.INT) *)
  45. INT*, BP*, PC*, CS*: LONGINT; (* BP and ERR are exchanged by glue code, for procedure link *)
  46. FLAGS*: SET;
  47. SP*, SS*: LONGINT; (** only valid if (VMBit IN s.EFLAGS) OR (CS MOD 4 < s.CS MOD 4) *)
  48. ES*, DS*, FS*, GS*: LONGINT; (** only valid if (VMBit IN s.FLAGS) *)
  49. END;
  50. VAR
  51. mtx : ARRAY MaxLocks OF Unix.Mutex_t;
  52. version-: ARRAY 64 OF CHAR; (** Aos version *)
  53. features-, features2 : SET;
  54. MMXSupport- : BOOLEAN;
  55. SSESupport- : BOOLEAN;
  56. SSE2Support- : BOOLEAN;
  57. SSE3Support- : BOOLEAN;
  58. SSSE3Support- : BOOLEAN;
  59. SSE41Support- : BOOLEAN;
  60. SSE42Support- : BOOLEAN;
  61. SSE5Support- : BOOLEAN;
  62. AVXSupport- : BOOLEAN;
  63. GCacquired- : BOOLEAN;
  64. ticks-: LONGINT; (** timer ticks. Use Kernel.GetTicks() to read, don't write *)
  65. prioLow-, prioHigh-: LONGINT; (* permitted thread priorities *)
  66. fcr-: SET; (** default floating-point control register value (default rounding mode is towards -infinity, for ENTIER) *)
  67. mhz-: HUGEINT; (** clock rate of GetTimer in MHz, or 0 if not known *)
  68. standaloneAppl-: BOOLEAN;
  69. firstMemBlock: MemoryBlockDesc; (* pseudo heap *)
  70. gcThreshold-: SIZE;
  71. memBlockHead-{UNTRACED}, memBlockTail-{UNTRACED}: MemoryBlock; (* head and tail of sorted list of memory blocks *)
  72. config: ARRAY 2048 OF CHAR; (* config strings *)
  73. (*
  74. Unix.ThrInitialize : PROCEDURE {REALTIME, C} ( VAR low, high: LONGINT ): BOOLEAN;
  75. Unix.MtxInit : PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Mutex_t;
  76. Unix.MtxDestroy : PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  77. Unix.MtxLock : PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  78. Unix.MtxUnlock : PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
  79. conInit : PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Condition_t;
  80. conDestroy : PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t );
  81. conWait : PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t; mtx: Unix.Mutex_t );
  82. conSignal : PROCEDURE {REALTIME, C} ( cond: Unix.Condition_t );
  83. thrSleep : PROCEDURE {REALTIME, C} ( ms: LONGINT );
  84. thrThis : PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Thread_t;
  85. *)
  86. logfile: LONGINT;
  87. traceHeap: BOOLEAN;
  88. timer0 : HUGEINT;
  89. (** Return current processor ID (0 to MaxNum-1). *)
  90. PROCEDURE {REALTIME} ID* (): LONGINT;
  91. BEGIN
  92. RETURN 0
  93. END ID;
  94. (**
  95. * Flush Data Cache for the specified virtual address range. If len is negative, flushes the whole cache.
  96. * This is used on some architecture to interact with DMA hardware (e.g. Ethernet and USB. It can be
  97. * left empty on Intel architecture.
  98. *)
  99. PROCEDURE FlushDCacheRange * (adr: ADDRESS; len: LONGINT);
  100. END FlushDCacheRange;
  101. (**
  102. * Invalidate Data Cache for the specified virtual address range. If len is negative, flushes the whole cache.
  103. * This is used on some architecture to interact with DMA hardware (e.g. Ethernet and USB. It can be
  104. * left empty on Intel architecture.
  105. *)
  106. PROCEDURE InvalidateDCacheRange * (adr: ADDRESS; len: LONGINT);
  107. END InvalidateDCacheRange;
  108. (**
  109. * Invalidate Instruction Cache for the specified virtual address range. If len is negative, flushes the whole cache.
  110. * This is used on some architecture to interact with DMA hardware (e.g. Ethernet and USB. It can be
  111. * left empty on Intel architecture.
  112. *)
  113. PROCEDURE InvalidateICacheRange * (adr: ADDRESS; len: LONGINT);
  114. END InvalidateICacheRange;
  115. (* insert given memory block in sorted list of memory blocks, sort key is startAdr field - called during GC *)
  116. PROCEDURE InsertMemoryBlock(memBlock: MemoryBlock);
  117. VAR cur {UNTRACED}, prev {UNTRACED}: MemoryBlock;
  118. BEGIN
  119. cur := memBlockHead;
  120. prev := NIL;
  121. WHILE (cur # NIL) & (cur.startAdr < memBlock.startAdr) DO
  122. prev := cur;
  123. cur := cur.next
  124. END;
  125. IF prev = NIL THEN (* insert at head of list *)
  126. memBlock.next := memBlockHead;
  127. memBlockHead := memBlock
  128. ELSE (* insert in middle or at end of list *)
  129. prev.next := memBlock;
  130. memBlock.next := cur;
  131. IF cur = NIL THEN
  132. memBlockTail := memBlock
  133. END
  134. END
  135. END InsertMemoryBlock;
  136. (* Free unused memory block - called during GC *)
  137. PROCEDURE FreeMemBlock*(memBlock: MemoryBlock);
  138. VAR cur {UNTRACED}, prev {UNTRACED}: MemoryBlock;
  139. BEGIN
  140. cur := memBlockHead;
  141. prev := NIL;
  142. WHILE (cur # NIL) & (cur # memBlock) DO
  143. prev := cur;
  144. cur := cur.next
  145. END;
  146. IF cur = memBlock THEN
  147. IF traceHeap THEN
  148. Trace.String( "Release memory block " ); Trace.Hex( memBlock.startAdr, -8 ); Trace.Ln
  149. END;
  150. IF prev = NIL THEN
  151. memBlockHead := cur.next
  152. ELSE
  153. prev.next := cur.next;
  154. IF cur.next = NIL THEN
  155. memBlockTail := prev
  156. END
  157. END;
  158. Unix.free( memBlock.startAdr )
  159. ELSE
  160. HALT(535) (* error in memory block management *)
  161. END;
  162. END FreeMemBlock;
  163. (* expand heap by allocating a new memory block *)
  164. PROCEDURE ExpandHeap*( dummy: LONGINT; size: SIZE; VAR memoryBlock: MemoryBlock; VAR beginBlockAdr, endBlockAdr: ADDRESS );
  165. VAR mBlock: MemoryBlock; alloc, s: SIZE; a, adr: ADDRESS;
  166. BEGIN
  167. IF size < (MemBlockSize - (2*BlockSize)) THEN alloc := MemBlockSize
  168. ELSE alloc := size + (2*BlockSize);
  169. END;
  170. INC( alloc, (-alloc) MOD Unix.PageSize );
  171. IF Unix.posix_memalign( adr, Unix.PageSize, alloc ) # 0 THEN
  172. Unix.Perror( "Machine.ExpandHeap: posix_memalign" );
  173. beginBlockAdr := 0;
  174. endBlockAdr := 0
  175. ELSE
  176. IF Unix.mprotect( adr, alloc, 7 (* READ WRITE EXEC *) ) # 0 THEN
  177. Unix.Perror( "Machine.ExpandHeap: mprotect" )
  178. END;
  179. mBlock := S.VAL( MemoryBlock, adr );
  180. mBlock.next := NIL;
  181. mBlock.startAdr := adr;
  182. mBlock.size := alloc;
  183. mBlock.beginBlockAdr := adr + BlockSize - AddrSize;
  184. ASSERT( (mBlock.beginBlockAdr + AddrSize) MOD BlockSize = 0 );
  185. s := adr + alloc - mBlock.beginBlockAdr - BlockSize;
  186. DEC( s, s MOD BlockSize );
  187. ASSERT( s >= size );
  188. mBlock.endBlockAdr := mBlock.beginBlockAdr + s;
  189. InsertMemoryBlock( mBlock );
  190. IF traceHeap THEN TraceHeap( mBlock ) END;
  191. a := mBlock.beginBlockAdr;
  192. S.PUT( a, a + AddrSize ); (* tag *)
  193. S.PUT( a + AddrSize, s - AddrSize ); (* size *)
  194. S.PUT( a + AddrSize + SizeSize, S.VAL( ADDRESS, 0 ) ); (* next *)
  195. beginBlockAdr := mBlock.beginBlockAdr;
  196. endBlockAdr := mBlock.endBlockAdr;
  197. memoryBlock := mBlock;
  198. END
  199. END ExpandHeap;
  200. (* Set memory block end address *)
  201. PROCEDURE SetMemoryBlockEndAddress*(memBlock: MemoryBlock; endBlockAdr: ADDRESS);
  202. BEGIN
  203. ASSERT(endBlockAdr >= memBlock.beginBlockAdr);
  204. memBlock.endBlockAdr := endBlockAdr
  205. END SetMemoryBlockEndAddress;
  206. PROCEDURE TraceHeap( new: MemoryBlock );
  207. VAR cur{UNTRACED}: MemoryBlock;
  208. BEGIN
  209. Trace.Ln;
  210. Trace.String( "Heap expanded" ); Trace.Ln;
  211. cur := memBlockHead;
  212. WHILE cur # NIL DO
  213. Trace.Hex( cur.startAdr, -8 ); Trace.String( " " ); Trace.Int( cur.size, 15 );
  214. IF cur = new THEN Trace.String( " (new)" ) END;
  215. Trace.Ln;
  216. cur := cur.next
  217. END
  218. END TraceHeap;
  219. (** Get first memory block and first free address, the first free address is identical to memBlockHead.endBlockAdr *)
  220. PROCEDURE GetStaticHeap*(VAR beginBlockAdr, endBlockAdr, freeBlockAdr: ADDRESS);
  221. VAR memBlockAdr: ADDRESS;
  222. BEGIN
  223. InitHeap(memBlockHead,beginBlockAdr, endBlockAdr);
  224. memBlockTail := memBlockHead;
  225. (*
  226. SYSTEM.GET(bootHeapAdr + EndBlockOfs, freeBlockAdr);
  227. ASSERT(freeBlockAdr MOD StaticBlockSize = 0);
  228. memBlockAdr := bootHeapAdr + HeaderSize + MemoryBlockOfs;
  229. memBlockHead := SYSTEM.VAL(MemoryBlock, memBlockAdr); (* this block will never be freed since there is a global reference (initBlock in Heaps.Mod) to it *)
  230. memBlockHead.startAdr := bootHeapAdr;
  231. memBlockHead.size := bootHeapSize;
  232. ASSERT(memBlockHead.beginBlockAdr MOD StaticBlockSize = 0);
  233. ASSERT((memBlockHead.endBlockAdr - memBlockHead.beginBlockAdr) MOD StaticBlockSize = 0);
  234. memBlockTail := memBlockHead;
  235. *)
  236. beginBlockAdr := memBlockHead.beginBlockAdr;
  237. endBlockAdr := memBlockHead.endBlockAdr;
  238. freeBlockAdr := beginBlockAdr;
  239. END GetStaticHeap;
  240. (* returns if an address is a currently allocated heap address *)
  241. PROCEDURE ValidHeapAddress*( p: ADDRESS ): BOOLEAN;
  242. VAR mb: MemoryBlock;
  243. BEGIN
  244. mb := memBlockHead;
  245. WHILE mb # NIL DO
  246. IF (p >= mb.beginBlockAdr) & (p <= mb.endBlockAdr) THEN RETURN TRUE END;
  247. mb := mb.next;
  248. END;
  249. RETURN TRUE;
  250. RETURN FALSE
  251. END ValidHeapAddress;
  252. (** Return information on free memory in Kbytes. *)
  253. PROCEDURE GetFreeK*(VAR total, lowFree, highFree: SIZE);
  254. BEGIN
  255. (*! meaningless in Unix port, for interface compatibility only *)
  256. total := 0;
  257. lowFree := 0;
  258. highFree := 0
  259. END GetFreeK;
  260. (** Fill "size" bytes at "destAdr" with "filler". "size" must be multiple of 4. *)
  261. PROCEDURE {REALTIME} Fill32* (destAdr: ADDRESS; size: SIZE; filler: LONGINT);
  262. CODE {SYSTEM.i386}
  263. MOV EDI, [EBP+destAdr]
  264. MOV ECX, [EBP+size]
  265. MOV EAX, [EBP+filler]
  266. TEST ECX, 3
  267. JZ ok
  268. PUSH 8 ; ASSERT failure
  269. INT 3
  270. ok:
  271. SHR ECX, 2
  272. CLD
  273. REP STOSD
  274. END Fill32;
  275. PROCEDURE Portin8*(port: LONGINT; VAR val: CHAR);
  276. END Portin8;
  277. PROCEDURE Portin16*(port: LONGINT; VAR val: INTEGER);
  278. END Portin16;
  279. PROCEDURE Portin32*(port: LONGINT; VAR val: LONGINT);
  280. END Portin32;
  281. PROCEDURE Portout8*(port: LONGINT; val: CHAR);
  282. END Portout8;
  283. PROCEDURE Portout16*(port: LONGINT; val: INTEGER);
  284. END Portout16;
  285. PROCEDURE Portout32*(port: LONGINT; val: LONGINT);
  286. END Portout32;
  287. (** -- Atomic operations -- *)
  288. (** Atomic INC(x). *)
  289. PROCEDURE -AtomicInc*(VAR x: LONGINT);
  290. CODE {SYSTEM.i386}
  291. POP EAX
  292. LOCK
  293. INC DWORD [EAX]
  294. END AtomicInc;
  295. (** Atomic DEC(x). *)
  296. PROCEDURE -AtomicDec*(VAR x: LONGINT);
  297. CODE {SYSTEM.i386}
  298. POP EAX
  299. LOCK
  300. DEC DWORD [EAX]
  301. END AtomicDec;
  302. (** Atomic INC(x, y). *)
  303. PROCEDURE -AtomicAdd*(VAR x: LONGINT; y: LONGINT);
  304. CODE {SYSTEM.i386}
  305. POP EBX
  306. POP EAX
  307. LOCK
  308. ADD DWORD [EAX], EBX
  309. END AtomicAdd;
  310. (** Atomic EXCL. *)
  311. PROCEDURE AtomicExcl* (VAR s: SET; bit: LONGINT);
  312. CODE {SYSTEM.i386}
  313. MOV EAX, [EBP+bit]
  314. MOV EBX, [EBP+s]
  315. LOCK
  316. BTR [EBX], EAX
  317. END AtomicExcl;
  318. (** Atomic test-and-set. Set x = TRUE and return old value of x. *)
  319. PROCEDURE -AtomicTestSet*(VAR x: BOOLEAN): BOOLEAN;
  320. CODE {SYSTEM.i386}
  321. POP EBX
  322. MOV AL, 1
  323. XCHG [EBX], AL
  324. END AtomicTestSet;
  325. (* Atomic compare-and-swap. Set x = new if x = old and return old value of x *)
  326. PROCEDURE {REALTIME} -AtomicCAS* (VAR x: LONGINT; old, new: LONGINT): LONGINT;
  327. CODE {SYSTEM.i386}
  328. POP EBX ; new
  329. POP EAX ; old
  330. POP ECX ; address of x
  331. DB 0F0X, 00FX, 0B1X, 019X ; LOCK CMPXCHG [ECX], EBX; atomicly compare x with old and set it to new if equal
  332. END AtomicCAS;
  333. (* Return current instruction pointer *)
  334. PROCEDURE {REALTIME} CurrentPC* (): ADDRESS;
  335. CODE {SYSTEM.i386}
  336. MOV EAX, [EBP+4]
  337. END CurrentPC;
  338. (* Return current frame pointer *)
  339. PROCEDURE {REALTIME} -CurrentBP* (): ADDRESS;
  340. CODE {SYSTEM.i386}
  341. MOV EAX, EBP
  342. END CurrentBP;
  343. (* Set current frame pointer *)
  344. PROCEDURE {REALTIME} -SetBP* (bp: ADDRESS);
  345. CODE {SYSTEM.i386}
  346. POP EBP
  347. END SetBP;
  348. (* Return current stack pointer *)
  349. PROCEDURE {REALTIME} -CurrentSP* (): ADDRESS;
  350. CODE {SYSTEM.i386}
  351. MOV EAX, ESP
  352. END CurrentSP;
  353. (* Set current stack pointer *)
  354. PROCEDURE {REALTIME} -SetSP* (sp: ADDRESS);
  355. CODE {SYSTEM.i386}
  356. POP ESP
  357. END SetSP;
  358. PROCEDURE {REALTIME} -GetEAX*(): LONGINT;
  359. CODE{SYSTEM.i386}
  360. END GetEAX;
  361. PROCEDURE {REALTIME} -GetECX*(): LONGINT;
  362. CODE{SYSTEM.i386}
  363. MOV EAX,ECX
  364. END GetECX;
  365. PROCEDURE {REALTIME} -GetESI*(): LONGINT;
  366. CODE{SYSTEM.i386}
  367. MOV EAX,ESI
  368. END GetESI;
  369. PROCEDURE {REALTIME} -GetEDI*(): LONGINT;
  370. CODE{SYSTEM.i386}
  371. MOV EAX,EDI
  372. END GetEDI;
  373. PROCEDURE {REALTIME} -SetEAX*(n: LONGINT);
  374. CODE{SYSTEM.i386}
  375. POP EAX
  376. END SetEAX;
  377. PROCEDURE {REALTIME} -SetEBX*(n: LONGINT);
  378. CODE{SYSTEM.i386}
  379. POP EBX
  380. END SetEBX;
  381. PROCEDURE {REALTIME} -SetECX*(n: LONGINT);
  382. CODE{SYSTEM.i386}
  383. POP ECX
  384. END SetECX;
  385. PROCEDURE {REALTIME} -SetEDX*(n: LONGINT);
  386. CODE{SYSTEM.i386}
  387. POP EDX
  388. END SetEDX;
  389. PROCEDURE {REALTIME} -SetESI*(n: LONGINT);
  390. CODE{SYSTEM.i386}
  391. POP ESI
  392. END SetESI;
  393. PROCEDURE {REALTIME} -SetEDI*(n: LONGINT);
  394. CODE{SYSTEM.i386}
  395. POP EDI
  396. END SetEDI;
  397. PROCEDURE -GetTimer* (): HUGEINT;
  398. CODE {SYSTEM.Pentium}
  399. RDTSC ; set EDX:EAX
  400. END GetTimer;
  401. (** -- Configuration and bootstrapping -- *)
  402. (** Return the value of the configuration string specified by parameter name in parameter val. Returns val = "" if the string was not found, or has an empty value. *)
  403. PROCEDURE GetConfig* (CONST name: ARRAY OF CHAR; VAR val: ARRAY OF CHAR);
  404. VAR i, src: LONGINT; ch: CHAR;
  405. BEGIN
  406. ASSERT (name[0] # "="); (* no longer supported, use GetInit instead *)
  407. src := -1;
  408. LOOP
  409. REPEAT
  410. INC( src ); ch := config[src];
  411. IF ch = 0X THEN EXIT END;
  412. UNTIL ch > ' ';
  413. i := 0;
  414. LOOP
  415. ch := config[src];
  416. IF (ch # name[i]) OR (name[i] = 0X) THEN EXIT END;
  417. INC (i); INC (src)
  418. END;
  419. IF (ch <= ' ') & (name[i] = 0X) THEN (* found *)
  420. i := 0;
  421. REPEAT
  422. INC (src); ch := config[src]; val[i] := ch; INC (i);
  423. IF i = LEN(val) THEN val[i - 1] := 0X; RETURN END (* val too short *)
  424. UNTIL ch <= ' ';
  425. IF ch = ' ' THEN val[i -1] := 0X END;
  426. RETURN
  427. ELSE
  428. WHILE ch > ' ' DO (* skip to end of name *)
  429. INC (src); ch := config[src]
  430. END;
  431. INC (src);
  432. REPEAT (* skip to end of value *)
  433. ch := config[src]; INC (src)
  434. UNTIL ch <= ' '
  435. END
  436. END;
  437. val[0] := 0X
  438. END GetConfig;
  439. (** Convert a string to an integer. Parameter i specifies where in the string scanning should begin (usually 0 in the first call). Scanning stops at the first non-valid character, and i returns the updated position. Parameter s is the string to be scanned. The value is returned as result, or 0 if not valid. Syntax: number = ["-"] digit {digit} ["H" | "h"] . digit = "0" | ... "9" | "A" .. "F" | "a" .. "f" . If the number contains any hexdecimal letter, or if it ends in "H" or "h", it is interpreted as hexadecimal. *)
  440. PROCEDURE StrToInt* (VAR i: LONGINT; CONST s: ARRAY OF CHAR): LONGINT;
  441. VAR vd, vh, sgn, d: LONGINT; hex: BOOLEAN;
  442. BEGIN
  443. vd := 0; vh := 0; hex := FALSE;
  444. IF s[i] = "-" THEN sgn := -1; INC (i) ELSE sgn := 1 END;
  445. LOOP
  446. IF (s[i] >= "0") & (s[i] <= "9") THEN d := ORD (s[i])-ORD ("0")
  447. ELSIF (CAP (s[i]) >= "A") & (CAP (s[i]) <= "F") THEN d := ORD (CAP (s[i]))-ORD ("A") + 10; hex := TRUE
  448. ELSE EXIT
  449. END;
  450. vd := 10*vd + d; vh := 16*vh + d;
  451. INC (i)
  452. END;
  453. IF CAP (s[i]) = "H" THEN hex := TRUE; INC (i) END; (* optional H *)
  454. IF hex THEN vd := vh END;
  455. RETURN sgn * vd
  456. END StrToInt;
  457. (* function returning the number of processors that are available to Aos *)
  458. PROCEDURE NumberOfProcessors*( ): LONGINT;
  459. BEGIN
  460. RETURN 1
  461. END NumberOfProcessors;
  462. (*! non portable code, for native Aos only *)
  463. PROCEDURE SetNumberOfProcessors*( num: LONGINT );
  464. BEGIN
  465. (* numberOfProcessors := num; *)
  466. END SetNumberOfProcessors;
  467. (* function for changing byte order *)
  468. PROCEDURE ChangeByteOrder* (n: LONGINT): LONGINT;
  469. CODE { SYSTEM.i486 }
  470. MOV EAX, [EBP+n] ; load n in eax
  471. BSWAP EAX ; swap byte order
  472. END ChangeByteOrder;
  473. (* Send and print character *)
  474. PROCEDURE TraceChar *(c: CHAR);
  475. BEGIN
  476. Trace.Char( c )
  477. END TraceChar;
  478. (** CPU identification *)
  479. PROCEDURE CPUID*( VAR vendor: Vendor; VAR version: LONGINT; VAR features1,features2: SET );
  480. CODE {SYSTEM.i386, SYSTEM.Pentium}
  481. MOV EAX, 0
  482. CPUID
  483. CMP EAX, 0
  484. JNE ok
  485. MOV ESI, [EBP+vendor]
  486. MOV [ESI], AL ; AL = 0
  487. MOV ESI, [EBP+version]
  488. MOV [ESI], EAX ; EAX = 0
  489. MOV ESI, [EBP+features1]
  490. MOV [ESI], EAX
  491. MOV ESI, [EBP+features2]
  492. MOV [ESI], EAX
  493. JMP end
  494. ok:
  495. MOV ESI, [EBP+vendor]
  496. MOV [ESI], EBX
  497. MOV [ESI+4], EDX
  498. MOV [ESI+8], ECX
  499. MOV BYTE [ESI+12], 0
  500. MOV EAX, 1
  501. CPUID
  502. MOV ESI, [EBP+version]
  503. MOV [ESI], EAX
  504. MOV ESI, [EBP+features1]
  505. MOV [ESI], EDX
  506. MOV ESI, [EBP+features2]
  507. MOV [ESI], ECX
  508. end:
  509. END CPUID;
  510. (* If the CPUID instruction is supported, the ID flag (bit 21) of the EFLAGS register is r/w *)
  511. PROCEDURE CpuIdSupported( ) : BOOLEAN;
  512. CODE {SYSTEM.i386}
  513. PUSHFD ; save EFLAGS
  514. POP EAX ; store EFLAGS in EAX
  515. MOV EBX, EAX ; save EBX for later testing
  516. XOR EAX, 00200000H ; toggle bit 21
  517. PUSH EAX ; push to stack
  518. POPFD ; save changed EAX to EFLAGS
  519. PUSHFD ; push EFLAGS to TOS
  520. POP EAX ; store EFLAGS in EAX
  521. CMP EAX, EBX ; see if bit 21 has changed
  522. SETNE AL; ; return TRUE if bit 21 has changed, FALSE otherwise
  523. END CpuIdSupported;
  524. (* setup MMX, SSE and SSE2..SSE5 and AVX extension *)
  525. PROCEDURE SetupSSE2Ext;
  526. CONST
  527. MMXFlag=23;(*IN features from EBX*)
  528. FXSRFlag = 24;
  529. SSEFlag = 25;
  530. SSE2Flag = 26;
  531. SSE3Flag = 0; (*IN features2 from ECX*) (*PH 04/11*)
  532. SSSE3Flag =9;
  533. SSE41Flag =19;
  534. SSE42Flag =20;
  535. SSE5Flag = 11;
  536. AVXFlag = 28;
  537. BEGIN
  538. MMXSupport := MMXFlag IN features;
  539. SSESupport := SSEFlag IN features;
  540. SSE2Support := SSESupport & (SSE2Flag IN features);
  541. SSE3Support := SSE2Support & (SSE3Flag IN features2);
  542. SSSE3Support := SSE3Support & (SSSE3Flag IN features2); (* PH 04/11*)
  543. SSE41Support := SSE3Support & (SSE41Flag IN features2);
  544. SSE42Support := SSE3Support & (SSE42Flag IN features2);
  545. SSE5Support := SSE3Support & (SSE5Flag IN features2);
  546. AVXSupport := SSE3Support & (AVXFlag IN features2);
  547. IF SSESupport & (FXSRFlag IN features) THEN
  548. (* InitSSE(); *) (*! not privileged mode in Windows and Unix, not allowed *)
  549. END;
  550. END SetupSSE2Ext;
  551. (** -- Processor initialization -- *)
  552. PROCEDURE -SetFCR( s: SET );
  553. CODE {SYSTEM.i386, SYSTEM.FPU}
  554. FLDCW [ESP] ; parameter s
  555. POP EAX
  556. END SetFCR;
  557. PROCEDURE -FCR( ): SET;
  558. CODE {SYSTEM.i386, SYSTEM.FPU}
  559. PUSH 0
  560. FNSTCW [ESP]
  561. FWAIT
  562. POP EAX
  563. END FCR;
  564. PROCEDURE -InitFPU;
  565. CODE {SYSTEM.i386, SYSTEM.FPU}
  566. FNINIT
  567. END InitFPU;
  568. (** Setup FPU control word of current processor. *)
  569. PROCEDURE SetupFPU*;
  570. BEGIN
  571. InitFPU; SetFCR( fcr )
  572. END SetupFPU;
  573. (* Initialize locks. *)
  574. PROCEDURE InitLocks;
  575. VAR i: LONGINT; a: ADDRESS;
  576. BEGIN
  577. i := 0;
  578. WHILE i < MaxLocks DO
  579. TRACE(i);
  580. mtx[i] := Unix.MtxInit(0); INC( i ) END;
  581. END InitLocks;
  582. PROCEDURE CleanupLocks*;
  583. VAR i: LONGINT;
  584. BEGIN
  585. i := 0;
  586. WHILE i < MaxLocks DO Unix.MtxDestroy( mtx[i] ); INC( i ) END;
  587. END CleanupLocks;
  588. (** Acquire a spin-lock. *)
  589. PROCEDURE Acquire*( level: LONGINT ); (* non reentrant lock *)
  590. BEGIN
  591. Unix.MtxLock( mtx[level] );
  592. END Acquire;
  593. (** Release a spin-lock. *)
  594. PROCEDURE Release*( level: LONGINT );
  595. BEGIN
  596. Unix.MtxUnlock( mtx[level] );
  597. END Release;
  598. PROCEDURE AcquireGC*( ): BOOLEAN;
  599. VAR res: BOOLEAN;
  600. BEGIN
  601. Unix.MtxLock( mtx[GC] );
  602. IF ~GCacquired THEN GCacquired := TRUE; res := TRUE ELSE res := FALSE END;
  603. Unix.MtxUnlock( mtx[GC] );
  604. RETURN res
  605. END AcquireGC;
  606. (** Release a spin-lock. *)
  607. PROCEDURE ReleaseGC*;
  608. BEGIN
  609. Unix.MtxLock( mtx[GC] );
  610. GCacquired := FALSE;
  611. Unix.MtxUnlock( mtx[GC] )
  612. END ReleaseGC;
  613. PROCEDURE Shutdown*( reboot: BOOLEAN );
  614. VAR ignore: LONGINT;
  615. BEGIN
  616. ignore := Unix.close( logfile );
  617. IF reboot THEN Unix.exit( 0 ) ELSE Unix.exit( 1 ) END;
  618. END Shutdown;
  619. (* Set machine-dependent parameter gcThreshold *)
  620. PROCEDURE SetGCParams*;
  621. BEGIN
  622. gcThreshold := 10*1024*1024; (* 10 MB *)
  623. END SetGCParams;
  624. (* expand heap by allocating a new memory block - called during GC *)
  625. PROCEDURE InitHeap(VAR memoryBlock: MemoryBlock; VAR beginBlockAdr, endBlockAdr: ADDRESS);
  626. CONST MemBlockHeaderSize = BlockHeaderSize + RecordDescSize + BlockHeaderSize;
  627. TypeDescOffset = -AddressSize; (* see Heaps.Mod *)
  628. HeapBlockOffset = - 2 * AddressSize; (* see Heaps.Mod *)
  629. DataAdrOffset = AddressSize; (* offset of dataAdr field in Heaps.HeapBlockDesc *)
  630. VAR memDescSize, memBlkSize, alignOffset: SIZE; adr, memHeaderAdr, memBlockAdr, memBlockHeadAdr: ADDRESS;
  631. memBlock {UNTRACED}: MemoryBlock; i: LONGINT; ch: CHAR; h: HUGEINT; size: LONGINT;
  632. initVal: LONGINT;
  633. BEGIN
  634. (*
  635. HeapBlockPtr -- bootHeapAdr
  636. 4 Type
  637. 8 Mark
  638. 12 DataAdr
  639. 16 Size
  640. 20 HeapBlockPtr
  641. 24 Type
  642. 28 next -- MemoryBlock
  643. 32 startAdr
  644. 36 size
  645. 40 beginBlockAdr
  646. 44 endBlockAdr
  647. 48 --beginBlockAdr
  648. ....
  649. --endBlockAdr
  650. *)
  651. size := 1;
  652. memDescSize := MemBlockHeaderSize + SIZEOF(MemoryBlockDesc);
  653. INC(memDescSize, (-memDescSize) MOD StaticBlockSize); (* round up to multiple of StaticBlockSize *)
  654. INC(size, (-size) MOD StaticBlockSize); (* round up to multiple of StaticBlockSize *)
  655. memBlkSize := memDescSize + size + StaticBlockSize; (* add StaticBlockSize to account for alignments different from multiples of StaticBlockSize *)
  656. IF memBlkSize < MemBlockSize THEN memBlkSize := MemBlockSize END; (* MemBlockSize implicitly multiple of StaticBlockSize *)
  657. initVal := 8*1024*1024;
  658. TRACE(initVal, adr);
  659. IF Unix.posix_memalign( adr, Unix.PageSize, initVal ) # 0 THEN
  660. Unix.Perror( "Machine.ExpandHeap: posix_memalign" );
  661. beginBlockAdr := 0;
  662. endBlockAdr := 0
  663. ELSE
  664. TRACE(adr, initVal);
  665. IF Unix.mprotect( adr, initVal, 7 (* READ WRITE EXEC *) ) # 0 THEN
  666. Unix.Perror( "Machine.ExpandHeap: mprotect" )
  667. END;
  668. TRACE(adr, initVal);
  669. END;
  670. (*
  671. adr := Kernel32.VirtualAlloc(initVal, memBlkSize, {Kernel32.MEMCommit, Kernel32.MEMReserve}, {Kernel32.PageExecuteReadWrite});
  672. IF adr = NilVal THEN (* allocation failed *)
  673. adr := Kernel32.VirtualAlloc(NilVal, memBlkSize, {Kernel32.MEMCommit}, {Kernel32.PageExecuteReadWrite});
  674. END;
  675. *)
  676. Trace.String("first heap block intVal "); Trace.Int(initVal,1); Trace.Ln;
  677. Trace.String("first heap block memBlkSize "); Trace.Int(memBlkSize,1); Trace.Ln;
  678. Trace.String("first heap block adr "); Trace.Int(adr,1); Trace.Ln;
  679. ASSERT(adr # 0);
  680. alignOffset := (-adr) MOD StaticBlockSize;
  681. memHeaderAdr := adr + alignOffset; (* force alignment of memory block start *)
  682. memBlockAdr := memHeaderAdr + MemBlockHeaderSize;
  683. memBlock := S.VAL(MemoryBlock, memBlockAdr);
  684. beginBlockAdr := memHeaderAdr + memDescSize;
  685. memBlock.next := NIL;
  686. memBlock.startAdr := adr;
  687. memBlock.size := memBlkSize;
  688. beginBlockAdr := memHeaderAdr + memDescSize;
  689. endBlockAdr := adr + memBlkSize - alignOffset;
  690. memBlock.beginBlockAdr := beginBlockAdr;
  691. memBlock.endBlockAdr := endBlockAdr;
  692. (* correct fields *)
  693. S.PUT(memBlockAdr + HeapBlockOffset, memHeaderAdr + BlockHeaderSize); (* set reference to header part of memory block correctly *)
  694. S.PUT(memBlockAdr + TypeDescOffset, 0); (* set type descriptor field of memory block to default value, memory blocks are not traced by GC *)
  695. S.PUT(memHeaderAdr + BlockHeaderSize + DataAdrOffset, memBlockAdr); (* set dataAdr of RecordBlockDesc to correct value *)
  696. S.PUT(memHeaderAdr + BlockHeaderSize + 2*AddressSize , memBlkSize);
  697. (* fill first heap block *)
  698. S.PUT(beginBlockAdr,0);
  699. S.PUT(beginBlockAdr+AddressSize,0);
  700. S.PUT(beginBlockAdr+2*AddressSize,0);
  701. S.PUT(beginBlockAdr+3*AddressSize,beginBlockAdr+7*AddressSize);
  702. S.PUT(beginBlockAdr+4*AddressSize,endBlockAdr-beginBlockAdr);
  703. S.PUT(beginBlockAdr+5*AddressSize,beginBlockAdr+2*AddressSize);
  704. S.PUT(beginBlockAdr+6*AddressSize,0);
  705. memoryBlock := memBlock;
  706. TRACE("InitHeap done");
  707. END InitHeap;
  708. (*
  709. PROCEDURE InitHeap;
  710. VAR heapAdr, firstBlock: ADDRESS; size: SIZE;
  711. BEGIN
  712. Unix.Dlsym( 0, "heapAdr", ADDRESSOF( heapAdr ) );
  713. Unix.Dlsym( 0, "heapSize", ADDRESSOF( size ) );
  714. firstBlock := heapAdr + ((-heapAdr - AddrSize) MOD BlockSize);
  715. size := heapAdr + size - BlockSize - firstBlock; DEC( size, size MOD BlockSize + BlockSize );
  716. firstMemBlock.next := NIL;
  717. firstMemBlock.startAdr := heapAdr;
  718. firstMemBlock.beginBlockAdr := firstBlock;
  719. firstMemBlock.endBlockAdr := firstBlock + size;
  720. firstMemBlock.size := size;
  721. memBlockHead := S.VAL( MemoryBlock, ADDRESSOF( firstMemBlock ) );
  722. memBlockTail := memBlockHead;
  723. END InitHeap;
  724. *)
  725. PROCEDURE InitConfig;
  726. VAR a: ADDRESS; i: LONGINT; c: CHAR;
  727. BEGIN
  728. a := Unix.getenv( ADDRESSOF( "AOSCONFIG" ) );
  729. IF a = 0 THEN config := DefaultConfig
  730. ELSE
  731. REPEAT
  732. S.GET( a, c ); INC( a ); config[i] := c; INC( i )
  733. UNTIL c = 0X
  734. END
  735. END InitConfig;
  736. PROCEDURE UpdateTicks*;
  737. BEGIN
  738. ticks := SHORT( (GetTimer() - timer0) DIV (mhz * 1000) );
  739. END UpdateTicks;
  740. PROCEDURE InitThreads;
  741. VAR res: BOOLEAN;
  742. BEGIN
  743. res := Unix.ThrInitialize( prioLow, prioHigh );
  744. IF ~res THEN
  745. Trace.StringLn( "Machine.InitThreads: no threads support in boot environment. teminating" );
  746. Unix.exit( 1 )
  747. END;
  748. IF Glue.debug # {} THEN
  749. Trace.String( "Threads initialized, priorities low, high: " );
  750. Trace.Int( prioLow, 0 ); Trace.String( ", " ); Trace.Int( prioHigh, 0 );
  751. Trace.Ln
  752. END
  753. END InitThreads;
  754. PROCEDURE CPUSpeed;
  755. VAR t0, t1: HUGEINT;
  756. BEGIN
  757. t0 := GetTimer(); Unix.ThrSleep( 100 ); t1 := GetTimer();
  758. mhz := (t1 - t0) DIV 100000;
  759. IF Glue.debug # {} THEN
  760. Trace.String( "CPU speed: ~" ); Trace.Int( SHORT( mhz ), 0); Trace.String( " MHz" ); Trace.Ln
  761. END
  762. END CPUSpeed;
  763. PROCEDURE Log( c: CHAR );
  764. VAR ignore: LONGINT;
  765. BEGIN
  766. ignore := Unix.write( 1, ADDRESSOF( c ), 1 );
  767. ignore := Unix.write( logfile, ADDRESSOF( c ), 1 );
  768. END Log;
  769. PROCEDURE LogFileOnly( c: CHAR );
  770. VAR ignore: LONGINT;
  771. BEGIN
  772. ignore := Unix.write( logfile, ADDRESSOF( c ), 1 );
  773. END LogFileOnly;
  774. PROCEDURE InitLog;
  775. VAR name, cmd: ARRAY 32 OF CHAR; pid, i: LONGINT;
  776. BEGIN
  777. name := "AOS.xxxxx.Log";
  778. pid := Unix.getpid(); i := 8;
  779. REPEAT
  780. name[i] := CHR( pid MOD 10 + ORD( '0' ) ); DEC( i );
  781. pid := pid DIV 10;
  782. UNTIL i = 3;
  783. logfile := Unix.open( ADDRESSOF( name ), Unix.rdwr + Unix.creat + Unix.trunc, Unix.rwrwr );
  784. IF Unix.argc > 2 THEN
  785. Unix.GetArgval( "-x", cmd );
  786. IF cmd # "" THEN SilentLog; standaloneAppl := TRUE
  787. ELSE VerboseLog
  788. END
  789. ELSE
  790. VerboseLog
  791. END
  792. END InitLog;
  793. PROCEDURE SilentLog*;
  794. BEGIN
  795. Trace.Char := LogFileOnly
  796. END SilentLog;
  797. PROCEDURE VerboseLog*;
  798. BEGIN
  799. Trace.Char := Log
  800. END VerboseLog;
  801. PROCEDURE Append( VAR a: ARRAY OF CHAR; CONST this: ARRAY OF CHAR );
  802. VAR i, j: LONGINT;
  803. BEGIN
  804. i := 0; j := 0;
  805. WHILE a[i] # 0X DO INC( i ) END;
  806. WHILE (i < LEN( a ) - 1) & (this[j] # 0X) DO a[i] := this[j]; INC( i ); INC( j ) END;
  807. a[i] := 0X
  808. END Append;
  809. PROCEDURE Init;
  810. VAR vendor: Vendor; ver: LONGINT;
  811. BEGIN
  812. TRACE("Machine Init Start");
  813. (*
  814. Unix.Dlsym( 0, "Unix.ThrInitialize", ADDRESSOF( Unix.ThrInitialize ) );
  815. Unix.Dlsym( 0, "Unix.MtxInit", ADDRESSOF( Unix.MtxInit ) );
  816. Unix.Dlsym( 0, "Unix.MtxDestroy", ADDRESSOF( Unix.MtxDestroy ) );
  817. Unix.Dlsym( 0, "Unix.MtxLock", ADDRESSOF( Unix.MtxLock ) );
  818. Unix.Dlsym( 0, "Unix.MtxUnlock", ADDRESSOF( Unix.MtxUnlock ) );
  819. Unix.Dlsym( 0, "conInit", ADDRESSOF( conInit ) );
  820. Unix.Dlsym( 0, "conDestroy", ADDRESSOF( conDestroy ) );
  821. Unix.Dlsym( 0, "conWait", ADDRESSOF( conWait ) );
  822. Unix.Dlsym( 0, "conSignal", ADDRESSOF( conSignal ) );
  823. Unix.Dlsym( 0, "thrSleep", ADDRESSOF( thrSleep ) );
  824. Unix.Dlsym( 0, "thrThis", ADDRESSOF( thrThis ) );
  825. *)
  826. standaloneAppl := FALSE;
  827. COPY( Unix.Version, version ); Append( version, Version );
  828. timer0 := GetTimer( ); ticks := 0;
  829. InitThreads;
  830. TRACE(0);
  831. InitLocks;
  832. TRACE(1);
  833. traceHeap := 1 IN Glue.debug;
  834. InitConfig;
  835. TRACE(2);
  836. InitLog;
  837. TRACE(3);
  838. CPUSpeed;
  839. TRACE(4);
  840. IF CpuIdSupported() THEN
  841. CPUID( vendor, ver, features, features2 ); SetupSSE2Ext
  842. END;
  843. TRACE(5);
  844. fcr := (FCR() - {0,2,3,10,11}) + {0..5,8,9}; (* default FCR RC=00B *)
  845. TRACE("Machine Init End");
  846. END Init;
  847. PROCEDURE {INITIAL} Init0;
  848. BEGIN
  849. Init;
  850. END Init0;
  851. END Machine.
  852. (*
  853. 03.03.1998 pjm First version
  854. 30.06.1999 pjm ProcessorID moved to AosProcessor
  855. *)
  856. (**
  857. Notes
  858. This module defines an interface to the boot environment of the system. The facilities provided here are only intended for the lowest levels of the system, and should never be directly imported by user modules (exceptions are noted below). They are highly specific to the system hardware and firmware architecture.
  859. Typically a machine has some type of firmware that performs initial testing and setup of the system. The firmware initiates the operating system bootstrap loader, which loads the boot file. This module is the first module in the statically linked boot file that gets control.
  860. There are two more-or-less general procedures in this module: GetConfig and StrToInt. GetConfig is used to query low-level system settings, e.g., the location of the boot file system. StrToInt is a utility procedure that parses numeric strings.
  861. Config strings:
  862. ExtMemSize Specifies size of extended memory (above 1MB) in MB. This value is not checked for validity. Setting it false may cause the system to fail, possible after running for some time. The memory size is usually detected automatically, but if the detection does not work for some reason, or if you want to limit the amount of memory detected, this string can be set. For example, if the machine has 64MB of memory, this value can be set as ExtMemSize="63".
  863. *)