![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Atari MiNT] / MiNT / src|
Return to mem.c CVS log | Up to [Atari MiNT] / MiNT / src |
1.1 root 1: /*
2:
3: Copyright 1990,1991,1992 Eric R. Smith. All rights reserved.
4:
5: */
6:
7:
8:
9: /*
10:
11: * mem.c:: routines for managing memory regions
12:
13: */
14:
15:
16:
17: #include "mint.h"
18:
19:
20:
21: static long core_malloc P_((long, int));
22:
23:
24:
25: /* macro for testing whether a memory region is free */
26:
27: #define ISFREE(m) ((m)->links == 0)
28:
29:
30:
31: /*
32:
33: * initialize memory routines
34:
35: */
36:
37:
38:
39: /* initial number of memory regions */
40:
41: #define NREGIONS 512
42:
43:
44:
45: /* number of new regions to allocate when the initial ones are used up */
46:
47: #define NEWREGIONS 256
48:
49:
50:
51: static MEMREGION use_regions[NREGIONS+1];
52:
53: MEMREGION *rfreelist;
54:
55:
56:
57: void
58:
59: init_mem()
60:
61: {
62:
63: int i;
64:
65:
66:
67: use_regions[NREGIONS].next = 0;
68:
69: for (i = 0; i < NREGIONS; i++) {
70:
71: use_regions[i].next = &use_regions[i+1];
72:
73: }
74:
75: rfreelist = use_regions;
76:
77:
78:
79: init_core();
80:
81: init_swap();
82:
83: }
84:
85:
86:
87: /*
88:
89: * init_core(): initialize the core memory map (normal ST ram) and also
90:
91: * the alternate memory map (fast ram on the TT)
92:
93: */
94:
95:
96:
97: static MEMREGION *_core_regions = 0, *_alt_regions = 0,
98:
99: *_ker_regions = 0;
100:
101:
102:
103: MMAP core = &_core_regions;
104:
105: MMAP alt = &_alt_regions;
106:
107: MMAP ker = &_ker_regions;
108:
109:
110:
111: /* note: add_region must adjust both the size and starting
112:
113: * address of the region being added so that memory is
114:
115: * always properly aligned
116:
117: */
118:
119:
120:
121: int
122:
123: add_region(map, place, size, mflags)
124:
125: MMAP map;
126:
127: ulong place, size;
128:
129: unsigned mflags; /* initial flags for region */
130:
131: {
132:
133: MEMREGION *m;
134:
135: ulong newplace;
136:
137:
138:
139: newplace = ROUND(place);
140:
141: size = (place + size) - newplace;
142:
143: size &= ~MASKBITS;
144:
145: if (size <= 0) /* region too small to use */
146:
147: return 1;
148:
149:
150:
151: m = new_region();
152:
153: if (m == 0)
154:
155: return 0; /* failure */
156:
157: m->links = 0;
158:
159: m->len = size;
160:
161: m->loc = newplace;
162:
163: m->next = *map;
164:
165: m->mflags = mflags;
166:
167: *map = m;
168:
169: return 1; /* success */
170:
171: }
172:
173:
174:
175: static long
176:
177: core_malloc(amt, mode)
178:
179: long amt;
180:
181: int mode;
182:
183: {
184:
185: static int mxalloc = -1; /* does GEMDOS know about Mxalloc? */
186:
187: long ret;
188:
189:
190:
191: if (mxalloc < 0) {
192:
193: ret = (long)Mxalloc(-1L, 0);
194:
195: if (ret == -32) mxalloc = 0; /* unknown function */
196:
197: else if (ret >= 0) mxalloc = 1;
198:
199: else {
200:
201: ALERT("GEMDOS returned %ld from Mxalloc", ret);
202:
203: mxalloc = 0;
204:
205: }
206:
207: }
208:
209: if (mxalloc)
210:
211: return Mxalloc(amt, mode);
212:
213: else if (mode == 1)
214:
215: return 0L;
216:
217: else
218:
219: return Malloc(amt);
220:
221: }
222:
223:
224:
225: void
226:
227: init_core()
228:
229: {
230:
231: #ifdef JUNK_MEM
232:
233: extern void fillwjunk();
234:
235: #endif
236:
237: ulong size;
238:
239: ulong place;
240:
241: void *tossave;
242:
243:
244:
245: tossave = (void *)core_malloc((long)TOS_MEM, 0);
246:
247: if (!tossave) {
248:
249: FATAL("Not enough memory to run MiNT");
250:
251: }
252:
253:
254:
255: /* initialize kernel memory */
256:
257: place = (ulong)core_malloc(KERNEL_MEM, 3);
258:
259: if (place != 0) {
260:
261: (void)add_region(ker, place, KERNEL_MEM, M_KER);
262:
263: #ifdef JUNK_MEM
264:
265: fillwjunk(place, (long)KERNEL_MEM);
266:
267: #endif
268:
269: }
270:
271:
272:
273: /* initialize ST RAM */
274:
275: size = (ulong)core_malloc(-1L, 0);
276:
277: while (size > 0) {
278:
279: place = (ulong)core_malloc(size, 0);
280:
281: if (!add_region(core, place, size, M_CORE))
282:
283: FATAL("init_mem: unable to add a region");
284:
285: #ifdef JUNK_MEM
286:
287: fillwjunk(place, size);
288:
289: #endif
290:
291: size = (ulong)core_malloc(-1L, 0);
292:
293: }
294:
295:
296:
297: /* initialize alternate RAM */
298:
299: size = (ulong)core_malloc(-1L, 1);
300:
301: while (size > 0) {
302:
303: place = (ulong)core_malloc(size, 1);
304:
305: if (!add_region(alt, place, size, M_ALT))
306:
307: FATAL("init_mem: unable to add a region");
308:
309: size = (ulong)core_malloc(-1L, 1);
310:
311: }
312:
313:
314:
315: (void)Mfree(tossave); /* leave some memory for TOS to use */
316:
317: }
318:
319:
320:
321: /*
322:
323: * init_swap(): initialize the swap area; for now, this does nothing
324:
325: */
326:
327:
328:
329: MEMREGION *_swap_regions = 0;
330:
331: MMAP swap = &_swap_regions;
332:
333:
334:
335: void
336:
337: init_swap()
338:
339: {
340:
341: }
342:
343:
344:
345: /*
346:
347: * routines for allocating/deallocating memory regions
348:
349: */
350:
351:
352:
353: /*
354:
355: * new_region returns a new memory region descriptor, or NULL
356:
357: */
358:
359:
360:
361: MEMREGION *
362:
363: new_region()
364:
365: {
366:
367: MEMREGION *m, *newfrees;
368:
369: int i;
370:
371:
372:
373: m = rfreelist;
374:
375: if (!m) {
376:
377: ALERT("new_region: ran out of free regions");
378:
379: return 0;
380:
381: }
382:
383: assert(ISFREE(m));
384:
385: rfreelist = m->next;
386:
387: m->next = 0;
388:
389:
390:
391: /* if we're running low on free regions, allocate some more
392:
393: * we have to do this with at least 1 free region left so that get_region
394:
395: * has a chance of working
396:
397: */
398:
399: if (rfreelist && !rfreelist->next) {
400:
401: MEMREGION *newstuff;
402:
403:
404:
405: TRACE("get_region: getting new region descriptors");
406:
407: newstuff = get_region(ker, NEWREGIONS*SIZEOF(MEMREGION));
408:
409: if (!newstuff)
410:
411: newstuff = get_region(alt,NEWREGIONS*SIZEOF(MEMREGION));
412:
413: if (!newstuff)
414:
415: newstuff = get_region(core, NEWREGIONS*SIZEOF(MEMREGION));
416:
417: newfrees = newstuff ? (MEMREGION *)newstuff->loc : 0;
418:
419: if (newfrees) {
420:
421: newfrees[NEWREGIONS-1].next = 0;
422:
423: newfrees[NEWREGIONS-1].links = 0;
424:
425: for (i = 0; i < NEWREGIONS-1; i++) {
426:
427: newfrees[i].next = &newfrees[i+1];
428:
429: newfrees[i].links = 0;
430:
431: }
432:
433: rfreelist = newfrees;
434:
435: } else {
436:
437: DEBUG("couldn't get new region descriptors!");
438:
439: }
440:
441: }
442:
443:
444:
445: return m;
446:
447: }
448:
449:
450:
451: /*
452:
453: * dispose_region destroys a memory region descriptor
454:
455: */
456:
457:
458:
459: void
460:
461: dispose_region(m)
462:
463: MEMREGION *m;
464:
465: {
466:
467: assert(ISFREE(m));
468:
469: m->next = rfreelist;
470:
471: rfreelist = m;
472:
473: }
474:
475:
476:
477: /*
478:
479: * virtaddr
480:
481: * attach_region(proc, reg): attach the region to the given process:
482:
483: * returns the address at which it was attached, or NULL if the process
484:
485: * cannot attach more regions. The region link count is incremented if
486:
487: * the attachment is successful.
488:
489: */
490:
491:
492:
493: virtaddr
494:
495: attach_region(proc, reg)
496:
497: PROC *proc;
498:
499: MEMREGION *reg;
500:
501: {
502:
503: int i;
504:
505: MEMREGION **newmem;
506:
507: virtaddr *newaddr;
508:
509:
510:
511: if (!reg || !reg->loc) {
512:
513: ALERT("attach_region: attaching a null region??");
514:
515: return 0;
516:
517: }
518:
519: for (i = 0; i < proc->num_reg; i++) {
520:
521: if (!proc->mem[i]) {
522:
523: assert(proc->addr[i] == 0);
524:
525: reg->links++;
526:
527: proc->mem[i] = reg;
528:
529: proc->addr[i] = (virtaddr) reg->loc;
530:
531: return proc->addr[i];
532:
533: }
534:
535: }
536:
537:
538:
539: /* Hmmm, OK, we have to expand the process' memory table */
540:
541: TRACE("Expanding process memory table");
542:
543: i = proc->num_reg + NUM_REGIONS;
544:
545:
546:
547: newmem = kmalloc(i * SIZEOF(MEMREGION *));
548:
549: newaddr = kmalloc(i * SIZEOF(virtaddr));
550:
551:
552:
553: if (newmem && newaddr) {
554:
555: /* copy over the old address mapping */
556:
557: for (i = 0; i < proc->num_reg; i++) {
558:
559: newmem[i] = proc->mem[i];
560:
561: newaddr[i] = proc->addr[i];
562:
563: if (newmem[i] == 0)
564:
565: assert(newaddr[i] == 0);
566:
567: }
568:
569: /* initialize the rest of the tables */
570:
571: for(; i < proc->num_reg + NUM_REGIONS; i++) {
572:
573: newmem[i] = 0;
574:
575: newaddr[i] = 0;
576:
577: }
578:
579: /* free the old tables */
580:
581: kfree(proc->mem); kfree(proc->addr);
582:
583: proc->mem = newmem;
584:
585: proc->addr = newaddr;
586:
587: proc->num_reg += NUM_REGIONS;
588:
589: /* this call will succeed */
590:
591: TRACE("recursively calling attach_region");
592:
593: return attach_region(proc, reg);
594:
595: }
596:
597:
598:
599: DEBUG("attach_region: failed");
600:
601: return 0;
602:
603: }
604:
605:
606:
607: /*
608:
609: * detach_region(proc, reg): remove region from the procedure's address
610:
611: * space. If no more processes reference the region, return it to the
612:
613: * system. Note that we search backwards, so that the most recent
614:
615: * attachment of memory gets detached!
616:
617: */
618:
619:
620:
621: void
622:
623: detach_region(proc, reg)
624:
625: PROC *proc;
626:
627: MEMREGION *reg;
628:
629: {
630:
631: int i;
632:
633:
634:
635: if (!reg) return;
636:
637: for (i = proc->num_reg - 1; i >= 0; i--) {
638:
639: if (proc->mem[i] == reg) {
640:
641: reg->links--;
642:
643: proc->mem[i] = 0; proc->addr[i] = 0;
644:
645: if (reg->links == 0) {
646:
647: free_region(reg);
648:
649: }
650:
651: return;
652:
653: }
654:
655: }
656:
657: DEBUG("detach_region: region not attached");
658:
659: }
660:
661:
662:
663: /*
664:
665: * get_region(MMAP map, ulong size) -- allocate a new region of the
666:
667: * given size in the given memory map. if no region big enough is available,
668:
669: * return NULL, otherwise return a pointer to the region.
670:
671: * the "links" field in the region is set to 1
672:
673: *
674:
675: * BEWARE: new_region may call get_region (indirectly), so we have to be
676:
677: * _very_ careful with re-entrancy in this function
678:
679: */
680:
681:
682:
683: MEMREGION *
684:
685: get_region(map, size)
686:
687: MMAP map;
688:
689: ulong size;
690:
691: {
692:
693: MEMREGION *m, *n;
694:
695:
696:
697: /* precautionary measures */
698:
699: if (size == 0) {
700:
701: DEBUG("request for 0 bytes??");
702:
703: size = 1;
704:
705: }
706:
707:
708:
709: size = ROUND(size);
710:
711:
712:
713: n = *map;
714:
715:
716:
717: sanity_check(map);
718:
719: /* exact matches are likely to be rare, so we pre-allocate a new
720:
721: * region here; this helps us to avoid re-entrancy problems
722:
723: * when new_region calls get_region
724:
725: */
726:
727: m = new_region();
728:
729:
730:
731: while (n) {
732:
733: if (ISFREE(n)) {
734:
735: if (n->len == size) {
736:
737: if (m) dispose_region(m);
738:
739: n->links++;
740:
741: return n;
742:
743: }
744:
745: else if (n->len > size) {
746:
747: /* split a new region, 'm', which will contain the free bytes after n */
748:
749: if (m) {
750:
751: m->next = n->next;
752:
753: n->next = m;
754:
755: m->mflags = n->mflags & M_MAP;
756:
757: m->loc = n->loc + size;
758:
759: m->len = n->len - size;
760:
761: n->len = size;
762:
763: n->links++;
764:
765: return n;
766:
767: } else {
768:
769: DEBUG("get_region: no regions left");
770:
771: return 0;
772:
773: }
774:
775: }
776:
777: }
778:
779: n = n->next;
780:
781: }
782:
783:
784:
785: if (m)
786:
787: dispose_region(m);
788:
789: return NULL;
790:
791: }
792:
793:
794:
795: /*
796:
797: * free_region(MEMREGION *reg): free the indicated region. The map
798:
799: * in which the region is contained is given by reg->mflags.
800:
801: * the caller is responsible for making sure that the region
802:
803: * really should be freed, i.e. that reg->links == 0.
804:
805: */
806:
807:
808:
809: void
810:
811: free_region(reg)
812:
813: MEMREGION *reg;
814:
815: {
816:
817: MMAP map;
818:
819: MEMREGION *m;
820:
821:
822:
823: if (!reg) return;
824:
825:
826:
827: assert(ISFREE(reg));
828:
829:
830:
831: if (reg->mflags & M_CORE)
832:
833: map = core;
834:
835: else if (reg->mflags & M_ALT)
836:
837: map = alt;
838:
839: else if (reg->mflags & M_KER)
840:
841: map = ker;
842:
843: else {
844:
845: FATAL("free_region: region flags not valid (%x)", reg->mflags);
846:
847: }
848:
849: reg->mflags &= M_MAP;
850:
851: m = *map;
852:
853: assert(m);
854:
855:
856:
857: if (m == reg) goto merge_after;
858:
859:
860:
861: /* merge previous region if it's free and contiguous with 'reg' */
862:
863:
864:
865: /* first, we find the region */
866:
867: while (m && m->next != reg)
868:
869: m = m->next;
870:
871:
872:
873: assert(m != NULL);
874:
875:
876:
877: if (ISFREE(m) && (m->loc + m->len == reg->loc)) {
878:
879: m->len += reg->len;
880:
881: assert(m->next == reg);
882:
883: m->next = reg->next;
884:
885: reg->next = 0;
886:
887: dispose_region(reg);
888:
889: reg = m;
890:
891: }
892:
893:
894:
895: /* merge next region if it's free and contiguous with 'reg' */
896:
897: merge_after:
898:
899: m = reg->next;
900:
901: if (m && ISFREE(m) && reg->loc + reg->len == m->loc) {
902:
903: reg->len += m->len;
904:
905: reg->next = m->next;
906:
907: m->next = 0;
908:
909: dispose_region(m);
910:
911: }
912:
913:
914:
915: sanity_check(map);
916:
917: }
918:
919:
920:
921: /*
922:
923: * shrink_region(MEMREGION *reg, ulong newsize):
924:
925: * shrink region 'reg', so that it is now 'newsize' bytes long.
926:
927: * if 'newsize' is bigger than the region's current size, return EGSBF;
928:
929: * otherwise return 0.
930:
931: */
932:
933:
934:
935: long
936:
937: shrink_region(reg, newsize)
938:
939: MEMREGION *reg;
940:
941: ulong newsize;
942:
943: {
944:
945: MMAP map;
946:
947: MEMREGION *n;
948:
949: ulong diff;
950:
951:
952:
953:
954:
955: newsize = ROUND(newsize);
956:
957:
958:
959: assert(reg->links > 0);
960:
961:
962:
963: if (reg->mflags & M_CORE)
964:
965: map = core;
966:
967: else if (reg->mflags & M_ALT)
968:
969: map = alt;
970:
971: else if (reg->mflags & M_KER)
972:
973: map = ker;
974:
975: else {
976:
977: FATAL("shrink_region: bad region flags (%x)", reg->mflags);
978:
979: }
980:
981:
982:
983: /* shrinking to 0 is the same as freeing */
984:
985: if (newsize == 0) {
986:
987: detach_region(curproc, reg);
988:
989: return 0;
990:
991: }
992:
993:
994:
995: /* if new size is the same as old size, don't do anything */
996:
997: if (newsize == reg->len) {
998:
999: return 0; /* nothing to do */
1000:
1001: }
1002:
1003:
1004:
1005: if (newsize > reg->len) {
1006:
1007: DEBUG("shrink_region: request to make region bigger");
1008:
1009: return EGSBF; /* growth failure */
1010:
1011: }
1012:
1013:
1014:
1015: /* OK, we're going to free (reg->len - newsize) bytes at the end of
1016:
1017: this block. If the block after us is already free, simply add the
1018:
1019: space to that block.
1020:
1021: */
1022:
1023: n = reg->next;
1024:
1025: diff = reg->len - newsize;
1026:
1027:
1028:
1029: if (n && ISFREE(n) && reg->loc + reg->len == n->loc) {
1030:
1031: reg->len = newsize;
1032:
1033: n->loc -= diff;
1034:
1035: n->len += diff;
1036:
1037: return 0;
1038:
1039: }
1040:
1041: else {
1042:
1043: n = new_region();
1044:
1045: if (!n) {
1046:
1047: DEBUG("shrink_region: new_region failed");
1048:
1049: return EINTRN;
1050:
1051: }
1052:
1053: reg->len = newsize;
1054:
1055: n->loc = reg->loc + newsize;
1056:
1057: n->len = diff;
1058:
1059: n->mflags = reg->mflags & M_MAP;
1060:
1061: n->next = reg->next;
1062:
1063: reg->next = n;
1064:
1065: }
1066:
1067: return 0;
1068:
1069: }
1070:
1071:
1072:
1073: /*
1074:
1075: * max_rsize(map): return the length of the biggest free region
1076:
1077: * in the given memory map, or 0 if no regions remain.
1078:
1079: */
1080:
1081:
1082:
1083: long
1084:
1085: max_rsize(map)
1086:
1087: MMAP map;
1088:
1089: {
1090:
1091: MEMREGION *m, *max = 0;
1092:
1093: long size = 0;
1094:
1095:
1096:
1097: for (m = *map; m; m = m->next) {
1098:
1099: if (ISFREE(m)) {
1100:
1101: if (m->len > size) {
1102:
1103: max = m;
1104:
1105: size = m->len;
1106:
1107: }
1108:
1109: }
1110:
1111: }
1112:
1113: return size;
1114:
1115: }
1116:
1117:
1118:
1119: /*
1120:
1121: * tot_rsize(map, flag): if flag == 1, return the total number of bytes in
1122:
1123: * the given memory map; if flag == 0, return only the number of free
1124:
1125: * bytes
1126:
1127: */
1128:
1129:
1130:
1131: long
1132:
1133: tot_rsize(map, flag)
1134:
1135: MMAP map;
1136:
1137: int flag;
1138:
1139: {
1140:
1141: MEMREGION *m;
1142:
1143: long size = 0;
1144:
1145:
1146:
1147: for (m = *map; m; m = m->next) {
1148:
1149: if (flag || ISFREE(m)) {
1150:
1151: size += m->len;
1152:
1153: }
1154:
1155: }
1156:
1157: return size;
1158:
1159: }
1160:
1161:
1162:
1163: /*
1164:
1165: * alloc_region(MMAP map, ulong size): allocate a new region and attach
1166:
1167: * it to the current process; returns the address at which the region
1168:
1169: * was attached, or NULL. If not enough memory is found, wait a bit
1170:
1171: * and try again before giving up (maybe someone else will free some
1172:
1173: * memory)
1174:
1175: */
1176:
1177:
1178:
1179: virtaddr
1180:
1181: alloc_region(map, size)
1182:
1183: MMAP map;
1184:
1185: ulong size;
1186:
1187: {
1188:
1189: MEMREGION *m;
1190:
1191: PROC *proc = curproc;
1192:
1193: virtaddr v;
1194:
1195:
1196:
1197: m = get_region(map, size);
1198:
1199: if (!m) {
1200:
1201: return 0;
1202:
1203: }
1204:
1205:
1206:
1207: v = attach_region(proc, m);
1208:
1209: /* NOTE: get_region returns a region with link count 1; since attach_region
1210:
1211: * increments the link count, we restore it after calling attach_region
1212:
1213: */
1214:
1215: m->links = 1;
1216:
1217: if (!v) {
1218:
1219: m->links = 0;
1220:
1221: free_region(m);
1222:
1223: return 0;
1224:
1225: }
1226:
1227: return v;
1228:
1229: }
1230:
1231:
1232:
1233: /*
1234:
1235: * routines for creating a copy of an environment, and a new basepage.
1236:
1237: * note that the memory regions created should immediately be attached to
1238:
1239: * a process! Also note that create_env always operates in ST RAM, but
1240:
1241: * create_base might not.
1242:
1243: */
1244:
1245:
1246:
1247: MEMREGION *
1248:
1249: create_env(env)
1250:
1251: const char *env;
1252:
1253: {
1254:
1255: long size;
1256:
1257: MEMREGION *m;
1258:
1259: virtaddr v;
1260:
1261: const char *old;
1262:
1263: char *new;
1264:
1265:
1266:
1267: if (!env) {
1268:
1269: env = ((BASEPAGE *)curproc->base)->p_env;
1270:
1271: /* duplicate parent's environment */
1272:
1273: }
1274:
1275: size = 2;
1276:
1277: old = env;
1278:
1279: while (*env || *(env+1))
1280:
1281: env++,size++;
1282:
1283: v = alloc_region(core, size);
1284:
1285: if (!v) {
1286:
1287: DEBUG("create_env: alloc_region failed");
1288:
1289: return (MEMREGION *)0;
1290:
1291: }
1292:
1293: m = addr2mem(v);
1294:
1295:
1296:
1297: /* copy the old environment into the new */
1298:
1299: new = (char *) m->loc;
1300:
1301: while (size > 0) {
1302:
1303: *new++ = *old++;
1304:
1305: --size;
1306:
1307: }
1308:
1309: return m;
1310:
1311: }
1312:
1313:
1314:
1315: MEMREGION *
1316:
1317: create_base(cmd, env, flags, prgsize)
1318:
1319: const char *cmd;
1320:
1321: MEMREGION *env;
1322:
1323: ulong flags, prgsize;
1324:
1325: {
1326:
1327: long len, coresize, altsize;
1328:
1329: MMAP map;
1330:
1331: MEMREGION *m;
1332:
1333: BASEPAGE *b;
1334:
1335:
1336:
1337: /* if flags & F_ALTLOAD == 1, then we might decide to load in alternate
1338:
1339: RAM if enough is available. "enough" is: if more alt ram than ST ram,
1340:
1341: load there; otherwise, if more than (minalt+1)*128K alt ram available
1342:
1343: for heap space, load in alt ram ("minalt" is the high byte of flags)
1344:
1345: */
1346:
1347: if (flags & F_ALTLOAD) {
1348:
1349: coresize = max_rsize(core);
1350:
1351: altsize = max_rsize(alt);
1352:
1353: if (altsize >= coresize)
1354:
1355: map = alt;
1356:
1357: else {
1358:
1359: len = (flags & 0xf0000000) >> 28L;
1360:
1361: len = (len+1)*128*1024L + prgsize + 256;
1362:
1363: if (altsize >= len)
1364:
1365: map = alt;
1366:
1367: else
1368:
1369: map = core;
1370:
1371: }
1372:
1373: }
1374:
1375: else
1376:
1377: map = core;
1378:
1379:
1380:
1381: len = max_rsize(map);
1382:
1383:
1384:
1385: /* make sure that a little bit of memory is left over */
1386:
1387: if (len > 2*KEEP_MEM) {
1388:
1389: len -= KEEP_MEM;
1390:
1391: }
1392:
1393: m = addr2mem(alloc_region(map, len));
1394:
1395: if (!m) {
1396:
1397: DEBUG("create_base: alloc_region failed");
1398:
1399: return 0;
1400:
1401: }
1402:
1403: b = (BASEPAGE *)(m->loc);
1404:
1405:
1406:
1407: zero((char *)b, (long)sizeof(BASEPAGE));
1408:
1409: b->p_lowtpa = (long)b;
1410:
1411: b->p_hitpa = m->loc + m->len;
1412:
1413: b->p_env = (char *)env->loc;
1414:
1415: b->p_flags = flags;
1416:
1417:
1418:
1419: if (cmd)
1420:
1421: strncpy(b->p_cmdlin, cmd, 126);
1422:
1423: return m;
1424:
1425: }
1426:
1427:
1428:
1429: /*
1430:
1431: * load_region(filename): loads the program with the given file name
1432:
1433: * into a new region, and returns a pointer to that region. On an error,
1434:
1435: * returns 0 and leaves the error number in mint_errno.
1436:
1437: */
1438:
1439:
1440:
1441: static struct fileheader {
1442:
1443: short fmagic;
1444:
1445: long ftext;
1446:
1447: long fdata;
1448:
1449: long fbss;
1450:
1451: long fsym;
1452:
1453: long reserved;
1454:
1455: long flag;
1456:
1457: short reloc;
1458:
1459: } fh;
1460:
1461:
1462:
1463: MEMREGION *
1464:
1465: load_region(filename, env, cmdlin, xp)
1466:
1467: const char *filename;
1468:
1469: MEMREGION *env;
1470:
1471: const char *cmdlin;
1472:
1473: XATTR *xp; /* attributes for the file just loaded */
1474:
1475: {
1476:
1477: FILEPTR *f;
1478:
1479: DEVDRV *dev;
1480:
1481: MEMREGION *reg;
1482:
1483: BASEPAGE *b;
1484:
1485: long size, fixup, base, bytes_read;
1486:
1487: unsigned char c, *next;
1488:
1489: #define LRBUFSIZ 8196
1490:
1491: static unsigned char buffer[LRBUFSIZ];
1492:
1493: int trycount = 0;
1494:
1495:
1496:
1497: next = buffer;
1498:
1499:
1500:
1501: f = do_open(filename, O_DENYNONE | O_EXEC, 0, xp);
1502:
1503: if (!f) {
1504:
1505: return 0; /* mint_errno set by do_open */
1506:
1507: }
1508:
1509:
1510:
1511: dev = f->dev; /* could be different from fs */
1512:
1513: if ( (*dev->read)(f, (void *)&fh, (long)sizeof(fh)) != sizeof(fh) ||
1514:
1515: fh.fmagic != 0x601a ) {
1516:
1517: DEBUG("load_region: file not executable");
1518:
1519: mint_errno = ENOEXEC;
1520:
1521: failed:
1522:
1523: do_close(f);
1524:
1525: return 0;
1526:
1527: }
1528:
1529:
1530:
1531: size = fh.ftext + fh.fdata + fh.fbss;
1532:
1533: reg = 0;
1534:
1535: for (trycount = 0; (trycount < 1) && (reg == 0); trycount++) {
1536:
1537: reg = create_base(cmdlin, env, fh.flag, size);
1538:
1539: if (size+1024L > reg->len) {
1540:
1541: DEBUG("load_region: insufficient memory to load");
1542:
1543: detach_region(curproc, reg);
1544:
1545: reg = 0;
1546:
1547: }
1548:
1549: if (!reg) {
1550:
1551: /* maybe the memory shortage is short-term; sleep a bit to see */
1552:
1553: nap(10);
1554:
1555: }
1556:
1557: }
1558:
1559:
1560:
1561: if (reg == 0) {
1562:
1563: mint_errno = ENSMEM;
1564:
1565: goto failed;
1566:
1567: }
1568:
1569:
1570:
1571: b = (BASEPAGE *)reg->loc;
1572:
1573: b->p_flags = fh.flag;
1574:
1575: b->p_tbase = b->p_lowtpa + 256;
1576:
1577: b->p_tlen = fh.ftext;
1578:
1579: b->p_dbase = b->p_tbase + b->p_tlen;
1580:
1581: b->p_dlen = fh.fdata;
1582:
1583: b->p_bbase = b->p_dbase + b->p_dlen;
1584:
1585: size = (*dev->read)(f, (void *)b->p_tbase, fh.ftext+fh.fdata);
1586:
1587: if (size != fh.ftext + fh.fdata) {
1588:
1589: DEBUG("load_region: unexpected EOF");
1590:
1591: failed_reloc: /* come here when loading/relocation fails */
1592:
1593: mint_errno = ENOEXEC;
1594:
1595: detach_region(curproc, reg);
1596:
1597: goto failed;
1598:
1599: }
1600:
1601:
1602:
1603: b->p_blen = fh.fbss;
1604:
1605: if (fh.flag & F_FASTLOAD) /* fastload bit */
1606:
1607: size = b->p_blen;
1608:
1609: else
1610:
1611: size = b->p_hitpa - b->p_bbase;
1612:
1613: zero((char *)b->p_bbase, size);
1614:
1615: (*dev->lseek)(f, fh.fsym, SEEK_CUR); /* skip over symbol table */
1616:
1617: base = b->p_tbase;
1618:
1619:
1620:
1621: /* now read the relocation info; we use the temporary buffer provided
1622:
1623: * above to speed things up
1624:
1625: */
1626:
1627:
1628:
1629: if (fh.reloc == 0 && (*dev->read)(f, (char *)&fixup, 4L) && fixup) {
1630:
1631: fixup += base;
1632:
1633: size = LRBUFSIZ;
1634:
1635: bytes_read = 0;
1636:
1637: do {
1638:
1639: if (fixup >= b->p_hitpa) {
1640:
1641: DEBUG("load_region: bad relocation");
1642:
1643: goto failed_reloc;
1644:
1645: }
1646:
1647: else
1648:
1649: *((long *)fixup) += base;
1650:
1651: do {
1652:
1653: if (!bytes_read) {
1654:
1655: bytes_read =
1656:
1657: (*dev->read)(f,(char *)buffer,size);
1658:
1659: next = buffer;
1660:
1661: }
1662:
1663: if (bytes_read < 0) {
1664:
1665: DEBUG("load_region: EOF in relocation");
1666:
1667: goto failed_reloc;
1668:
1669: }
1670:
1671: else if (bytes_read == 0)
1672:
1673: c = 0;
1674:
1675: else {
1676:
1677: c = *next++; bytes_read--;
1678:
1679: }
1680:
1681: if (c == 1) fixup += 254;
1682:
1683: } while (c == 1);
1684:
1685: fixup += ( (unsigned) c) & 0xff;
1686:
1687: } while (c);
1688:
1689: }
1690:
1691:
1692:
1693: do_close(f);
1694:
1695: return reg;
1696:
1697: }
1698:
1699:
1700:
1701: /*
1702:
1703: * exec_region(p, mem, thread): create a child process out of a mem region
1704:
1705: * "p" is the process structure set up by the parent; it may be "curproc",
1706:
1707: * if we're overlaying. "mem" is the loaded memory region returned by
1708:
1709: * "load region". Any open files (other than the standard handles) owned
1710:
1711: * by "p" are closed, and if thread !=0 all memory is released; the caller
1712:
1713: * must explicitly attach the environment and base region. The caller must
1714:
1715: * also put "p" on the appropriate queue (most likely READY_Q).
1716:
1717: */
1718:
1719:
1720:
1721: extern long mint_dos(), mint_bios();
1722:
1723:
1724:
1725: void rts() {} /* dummy termination routine */
1726:
1727:
1728:
1729: PROC *
1730:
1731: exec_region(p, mem, thread)
1732:
1733: PROC *p;
1734:
1735: MEMREGION *mem;
1736:
1737: int thread;
1738:
1739: {
1740:
1741: BASEPAGE *b;
1742:
1743: FILEPTR *f;
1744:
1745: int i;
1746:
1747: MEMREGION *m;
1748:
1749:
1750:
1751: TRACE("exec_region");
1752:
1753:
1754:
1755: b = (BASEPAGE *) mem->loc;
1756:
1757:
1758:
1759: /* set some (undocumented) variables in the basepage */
1760:
1761: b->p_defdrv = p->curdrv;
1762:
1763: for (i = 0; i < 6; i++)
1764:
1765: b->p_devx[i] = i;
1766:
1767:
1768:
1769: p->dta = (DTABUF *)(b->p_dta = &b->p_cmdlin[0]);
1770:
1771: p->base = b;
1772:
1773:
1774:
1775: /* close extra open files */
1776:
1777: for (i = MIN_OPEN; i < MAX_OPEN; i++) {
1778:
1779: if ( (f = p->handle[i]) && (p->fdflags[i] & FD_CLOEXEC) ) {
1780:
1781: do_pclose(p, f);
1782:
1783: p->handle[i] = 0;
1784:
1785: }
1786:
1787: }
1788:
1789:
1790:
1791: /* initialize memory */
1792:
1793: recalc_maxmem(p);
1794:
1795: if (p->maxmem) {
1796:
1797: shrink_region(mem, p->maxmem);
1798:
1799: b->p_hitpa = b->p_lowtpa + mem->len;
1800:
1801: }
1802:
1803:
1804:
1805: p->memflags = b->p_flags;
1806:
1807:
1808:
1809: if (!thread) {
1810:
1811: for (i = 0; i < p->num_reg; i++) {
1812:
1813: m = p->mem[i];
1814:
1815: if (m) {
1816:
1817: m->links--;
1818:
1819: if (m->links <= 0)
1820:
1821: free_region(m);
1822:
1823: }
1824:
1825: }
1826:
1827: if (p->num_reg > NUM_REGIONS) {
1828:
1829: kfree(p->mem); kfree(p->addr);
1830:
1831: p->mem = kmalloc(NUM_REGIONS * SIZEOF(MEMREGION *));
1832:
1833: p->addr = kmalloc(NUM_REGIONS * SIZEOF(virtaddr));
1834:
1835: /* note: the mallocs have succeeded, since we just freed bigger areas */
1836:
1837: assert(p->mem && p->addr);
1838:
1839: p->num_reg = NUM_REGIONS;
1840:
1841: }
1842:
1843: zero((char *)p->mem, (p->num_reg)*SIZEOF(MEMREGION *));
1844:
1845: zero((char *)p->addr, (p->num_reg)*SIZEOF(virtaddr));
1846:
1847: }
1848:
1849:
1850:
1851: /* initialize signals */
1852:
1853: p->sigmask = 0;
1854:
1855: for (i = 0; i < NSIG; i++) {
1856:
1857: if (p->sighandle[i] != SIG_IGN) {
1858:
1859: p->sighandle[i] = SIG_DFL;
1860:
1861: p->sigflags[i] = 0;
1862:
1863: p->sigextra[i] = 0;
1864:
1865: }
1866:
1867: }
1868:
1869:
1870:
1871: /* zero the user registers, and set the FPU in a "clear" state */
1872:
1873: for (i = 0; i < 15; i++)
1874:
1875: p->ctxt[CURRENT].regs[i] = 0;
1876:
1877: p->ctxt[CURRENT].sr = 0;
1878:
1879: p->ctxt[CURRENT].fstate[0] = 0;
1880:
1881:
1882:
1883: /* set PC, stack registers, etc. appropriately */
1884:
1885: p->ctxt[CURRENT].pc = b->p_tbase;
1886:
1887:
1888:
1889: /* The "-0x20" is to make sure that syscall.s won't run past the end of
1890:
1891: * memory when the user makes a system call and doesn't push very many
1892:
1893: * parameters -- syscall always tries to copy the maximum possible number
1894:
1895: * of parms.
1896:
1897: *
1898:
1899: * NOTE: there's a sanity check here in case programs Mshrink a basepage
1900:
1901: * without fixing the p_hitpa field in the basepage; this is to ensure
1902:
1903: * compatibility with older versions of MiNT, which ignore p_hitpa.
1904:
1905: */
1906:
1907: if (valid_address(b->p_hitpa - 0x20))
1908:
1909: p->ctxt[CURRENT].usp = b->p_hitpa - 0x20;
1910:
1911: else
1912:
1913: p->ctxt[CURRENT].usp = mem->loc + mem->len - 0x20;
1914:
1915:
1916:
1917: p->ctxt[CURRENT].ssp = (long)(p->stack + ISTKSIZE);
1918:
1919: p->ctxt[CURRENT].term_vec = (long)rts;
1920:
1921:
1922:
1923: /* set up stack for process */
1924:
1925: *((long *)(p->ctxt[CURRENT].usp + 4)) = (long) b;
1926:
1927:
1928:
1929: /* check for a valid text region. some compilers (e.g. Lattice 3) just throw
1930:
1931: everything into the text region, including data; fork() must be careful
1932:
1933: to save the whole region, then. We assume that if the compiler (or
1934:
1935: assembler, or whatever) goes to the trouble of making separate text, data,
1936:
1937: and bss regions, then the text region is code and isn't modified and
1938:
1939: fork doesn't have to save it.
1940:
1941: */
1942:
1943: if (b->p_tlen != 0 && b->p_blen != 0 && b->p_dlen != 0)
1944:
1945: p->txtsize = b->p_tlen;
1946:
1947: else
1948:
1949: p->txtsize = 0;
1950:
1951:
1952:
1953: /*
1954:
1955: * An ugly hack: dLibs tries to poke around in the parent's address space
1956:
1957: * to find stuff. For now, we'll allow this by faking a pointer into
1958:
1959: * the parent's address space in the place in the basepage where dLibs is
1960:
1961: * expecting it. This ugly hack only works correctly if the Pexec'ing
1962:
1963: * program (i.e. curproc) is in user mode.
1964:
1965: */
1966:
1967: curproc->base->p_usp = curproc->ctxt[SYSCALL].usp - 0x32;
1968:
1969:
1970:
1971: return p;
1972:
1973: }
1974:
1975:
1976:
1977: /*
1978:
1979: * misc. utility routines
1980:
1981: */
1982:
1983:
1984:
1985: /*
1986:
1987: * long memused(p): return total memory allocated to process p
1988:
1989: */
1990:
1991:
1992:
1993: long
1994:
1995: memused(p)
1996:
1997: PROC *p;
1998:
1999: {
2000:
2001: int i;
2002:
2003: long size;
2004:
2005:
2006:
2007: size = 0;
2008:
2009: for (i = 0; i < p->num_reg; i++) {
2010:
2011: if (p->mem[i])
2012:
2013: size += p->mem[i]->len;
2014:
2015: }
2016:
2017: return size;
2018:
2019: }
2020:
2021:
2022:
2023: /*
2024:
2025: * recalculate the maximum memory limit on a process; this limit depends
2026:
2027: * on the max. allocated memory and max. total memory limits set by
2028:
2029: * p_setlimit (see dos.c), and (perhaps) on the size of the program
2030:
2031: * that the process is executing. whenever any of these things
2032:
2033: * change (through p_exec or p_setlimit) this routine must be called
2034:
2035: */
2036:
2037:
2038:
2039: void
2040:
2041: recalc_maxmem(p)
2042:
2043: PROC *p;
2044:
2045: {
2046:
2047: BASEPAGE *b;
2048:
2049: long siz;
2050:
2051:
2052:
2053: b = (BASEPAGE *)p->base;
2054:
2055: if (b)
2056:
2057: siz = b->p_tlen + b->p_dlen + b->p_blen;
2058:
2059: else
2060:
2061: siz = 0;
2062:
2063: p->maxmem = 0;
2064:
2065: if (p->maxdata) {
2066:
2067: p->maxmem = p->maxdata + siz;
2068:
2069: }
2070:
2071:
2072:
2073: if (p->maxcore) {
2074:
2075: if (p->maxmem == 0 || p->maxmem > p->maxcore)
2076:
2077: p->maxmem = p->maxcore;
2078:
2079: }
2080:
2081: if (p->maxmem && p->maxmem < siz)
2082:
2083: p->maxmem = siz;
2084:
2085: }
2086:
2087:
2088:
2089: /*
2090:
2091: * valid_address: checks to see if the indicated address falls within
2092:
2093: * memory attached to the current process
2094:
2095: */
2096:
2097:
2098:
2099: int
2100:
2101: valid_address(addr)
2102:
2103: long addr;
2104:
2105: {
2106:
2107: int i;
2108:
2109: MEMREGION *m;
2110:
2111:
2112:
2113: for (i = 0; i < curproc->num_reg; i++) {
2114:
2115: if ((m = curproc->mem[i]) != 0) {
2116:
2117: if (addr >= m->loc && addr <= m->loc + m->len)
2118:
2119: return 1;
2120:
2121: }
2122:
2123: }
2124:
2125: return 0;
2126:
2127: }
2128:
2129:
2130:
2131: /*
2132:
2133: * some debugging stuff
2134:
2135: */
2136:
2137:
2138:
2139: void
2140:
2141: DUMPMEM(map)
2142:
2143: MMAP map;
2144:
2145: {
2146:
2147: MEMREGION *m;
2148:
2149:
2150:
2151: m = *map;
2152:
2153: ALERT("memory dump: starting at region %lx", m);
2154:
2155: while (m) {
2156:
2157: ALERT("%ld bytes at %lx (%d links); next region %lx", m->len, m->loc,
2158:
2159: m->links, m->next);
2160:
2161: m = m->next;
2162:
2163: }
2164:
2165: }
2166:
2167:
2168:
2169: void
2170:
2171: sanity_check(map)
2172:
2173: MMAP map;
2174:
2175: {
2176:
2177: #ifdef SANITY_CHECK
2178:
2179: MEMREGION *m, *nxt;
2180:
2181: long end;
2182:
2183:
2184:
2185: m = *map;
2186:
2187: while (m) {
2188:
2189: nxt = m->next;
2190:
2191: if (nxt) {
2192:
2193: end = m->loc + m->len;
2194:
2195: if (m->loc < nxt->loc && end > nxt->loc) {
2196:
2197: FATAL("MEMORY CHAIN CORRUPTED");
2198:
2199: }
2200:
2201: else if (end == nxt->loc && ISFREE(m) && ISFREE(nxt)) {
2202:
2203: ALERT("Continguous memory regions not merged!");
2204:
2205: }
2206:
2207: }
2208:
2209: m = nxt;
2210:
2211: }
2212:
2213: #endif
2214:
2215: }
2216:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.