![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to RegionManager.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / debug / Common|
Return to RegionManager.m CVS log | Up to [Apple XNU] / GNUtools / debug / Common |
1.1 root 1: #import "RegionManager.h"
2: #import <stdlib.h>
3: #import <string.h>
4: #import <mach/mach.h>
5: #import <mach-o/loader.h>
6: #import <mach/vm_param.h>
7:
8: kern_return_t static inline vmRegion(task_t task,
9: vm_address_t address,
10: Region *region)
11: {
12: vm_offset_t offset;
13: vm_prot_t maxProtection;
14: vm_inherit_t inheritance;
15: boolean_t shared;
16: port_t objectName;
17: region->reloc.address = address;
18: return vm_region(task,
19: ®ion->reloc.address,
20: ®ion->reloc.size,
21: ®ion->protection,
22: &maxProtection,
23: &inheritance,
24: &shared,
25: &objectName,
26: &offset);
27: }
28:
29: @implementation RegionManager
30:
31: -initTask: (vm_task_t)theTask readInRegions: (BOOL)readInRegions
32: {
33: vm_statistics_data_t vm_stats;
34:
35: task = theTask;
36: vm_statistics(theTask, &vm_stats);
37: pageSize = vm_stats.pagesize;
38: relocSize = sizeof(Region);
39: rmFlags.shouldSortRelocs = NO;
40: if (readInRegions)
41: [self readInAllRelocs];
42: else
43: rmFlags.invalid = YES;
44: return self;
45: }
46:
47: -(BOOL)isTask
48: {
49: struct task_basic_info taskInfo;
50: unsigned int taskInfoCount;
51: BOOL ret;
52:
53: taskInfoCount = TASK_BASIC_INFO_COUNT;
54: ret = (task_info(task,
55: TASK_BASIC_INFO,
56: (task_info_t)&taskInfo,
57: &taskInfoCount) == KERN_SUCCESS) ? YES : NO;
58: if (!ret && taskGoneCallBack)
59: (*taskGoneCallBack)();
60: return ret;
61: }
62:
63: -(void)setTaskGoneCallBack: (TaskGoneCallBack)theCallBack
64: {
65: taskGoneCallBack = theCallBack;
66: }
67:
68: +newTask: (vm_task_t)theTask
69: {
70: return [[super new] initTask: theTask readInRegions: YES];
71: }
72:
73: +newTask: (vm_task_t)theTask readInRegions: (BOOL)readInRegions
74: {
75: return [[super new] initTask: theTask readInRegions: readInRegions];
76: }
77:
78: -invalidate
79: {
80: if (rmFlags.invalid)
81: return self;
82: else {
83: Region *region;
84: int count;
85: if (relocs) {
86: for (count = numRelocs, region = (Region *)relocs;
87: count;
88: count--, region++) {
89: if (region->reloc.rFlags.readIn)
90: vm_deallocate(task_self(),
91: region->reloc.data,
92: region->reloc.size);
93: }
94: }
95: if (pages) {
96: free(pages);
97: pages = NULL;
98: }
99: return [super invalidate];
100: }
101: }
102:
103: -(void)getStartPage: (void **)startPage andSize: (int *)sizePage
104: forPointer: (void *)start andSize: (int)numBytes
105: {
106: vm_address_t offset = ((vm_address_t)start % pageSize);
107: vm_address_t s = numBytes + offset;
108:
109: *startPage = start - offset;
110: *sizePage = (s - (s % pageSize)) + pageSize;
111: }
112:
113: -(void)protectDataAt: (const void *)start for: (int)numBytes
114: {
115: vm_address_t offset = ((vm_address_t)start % pageSize);
116: vm_address_t startPage = (vm_address_t)start - offset;
117: size_t sizePage = numBytes + offset;
118:
119: vm_protect(task, startPage, pageSize, NO, VM_PROT_READ);
120: }
121:
122: -(void)unProtectDataAt: (const void *)start for: (int)numBytes
123: {
124: vm_address_t offset = ((vm_address_t)start % pageSize);
125: vm_address_t startPage = (vm_address_t)start - offset;
126: size_t sizePage = numBytes + offset;
127:
128: vm_protect(task, startPage, pageSize, NO, VM_PROT_READ | VM_PROT_WRITE);
129: }
130:
131: -(int)writeDataAt: (const void *)start for: (int)numBytes reloc: (Region *)region markOnly: (BOOL)markOnly
132: {
133: vm_address_t offset = ((vm_address_t)start % pageSize);
134: vm_address_t startPage = (vm_address_t)start - offset;
135: size_t sizePage = numBytes + offset;
136: pointer_t startData;
137: kern_return_t ret = 0;
138: unsigned char *pPage;
139:
140: if (markOnly) {
141: if (!region->pagesInvalid)
142: regionsInvalid++;
143: }
144: for (sizePage += (pageSize - (sizePage % pageSize)),
145: startData = region->reloc.data
146: + ((pointer_t)startPage - region->reloc.address),
147: pPage = region->pages
148: + (((pointer_t)startPage - region->reloc.address) / pageSize);
149: sizePage && !ret;
150: sizePage -= pageSize, startData += pageSize, startPage += pageSize,
151: pPage++) {
152: if (markOnly) {
153: if (!(*pPage & PAGEINVALID)) {
154: *pPage |= PAGEINVALID;
155: region->pagesInvalid++;
156: }
157: } else {
158: *pPage &= ~PAGEINVALID;
159: if (*pPage & VM_PROT_WRITE)
160: ret = vm_write(task, startPage, startData, pageSize);
161: else {
162: vm_protect(task, startPage, pageSize, NO, VM_PROT_WRITE);
163: ret = vm_write(task, startPage, startData, pageSize);
164: vm_protect(task, startPage, pageSize, NO,
165: (vm_prot_t)(*pPage & 0x7));
166: }
167: }
168: }
169: if (ret == KERN_SUCCESS)
170: return numBytes;
171: else {
172: [self isTask];
173: return 0;
174: }
175: }
176:
177: -(int)writeDataAt: (const void *)start for: (int)numBytes reloc: (Region *)region
178: {
179: return [self writeDataAt: start for: numBytes reloc: region markOnly: NO];
180: }
181:
182: -(int)putDataAt: (void *)start for: (int)numBytes from: (const void *)data markOnly: (BOOL)markOnly
183: {
184: int numBytesInRegion;
185: Reloc *reloc = [self relocFor: start];
186: if (reloc) {
187: numBytesInRegion = reloc->maxAddress - (int)start;
188: if (numBytes > numBytesInRegion)
189: numBytes = numBytesInRegion;
190: if (numBytes == 1)
191: *(char *)(reloc->data + ((pointer_t)start - reloc->address))
192: = *(char *)data;
193: else
194: memcpy((void *)(reloc->data + ((pointer_t)start - reloc->address)),
195: data,
196: numBytes);
197: return [self writeDataAt: start for: numBytes reloc: (Region *)reloc markOnly: markOnly];
198: } else
199: return 0;
200: }
201:
202: -(int)putDataAt: (void *)start for: (int)numBytes from: (const void *)data
203: {
204: return [self putDataAt: start for: numBytes from: data markOnly: NO];
205: }
206:
207: -(void)flushMarkedPages
208: {
209: int ret = 0;
210: while (regionsInvalid) {
211: int i;
212: Region *region;
213:
214: for (i = 0, region = (Region *)relocs;
215: i < numRelocs;
216: i++, ((void *)region) += relocSize) {
217: if (region->pagesInvalid) {
218: unsigned char *p = region->pages;
219: while (region->pagesInvalid) {
220: if (*p & PAGEINVALID) {
221: int numPage = p - region->pages;
222: pointer_t startPage, startData;
223:
224: startPage
225: = region->reloc.address + (numPage * pageSize);
226: startData
227: = region->reloc.data + (numPage * pageSize);
228: *p &= ~PAGEINVALID;
229: region->pagesInvalid--;
230: if (*p & VM_PROT_WRITE)
231: ret = vm_write(task, startPage, startData, pageSize);
232: else {
233: vm_protect(task, startPage, pageSize, NO, VM_PROT_WRITE);
234: ret = vm_write(task, startPage, startData, pageSize);
235: vm_protect(task, startPage, pageSize, NO,
236: (vm_prot_t)(*p & 0x7));
237: }
238: }
239: p++;
240: }
241: regionsInvalid--;
242: }
243: }
244: }
245: if (ret)
246: [self isTask];
247: }
248:
249: -(int)writeDataAt: (const void *)start for: (int)numBytes;
250: {
251: Reloc *reloc = [self relocFor: start];
252: if (reloc)
253: return [self writeDataAt: start for: numBytes reloc: (Region *)reloc];
254: else
255: return NO;
256: }
257:
258: -(BOOL)readInReloc: (Reloc *)reloc
259: {
260: kern_return_t ret;
261: unsigned int nData;
262: if (reloc->rFlags.readIn) {
263: return YES;
264: } else {
265: ret = vm_read(task, reloc->address, reloc->size, &reloc->data, &nData);
266: if (ret == KERN_SUCCESS) {
267: reloc->maxData = reloc->data + reloc->size;
268: reloc->displacement = reloc->data - reloc->address;
269: reloc->rFlags.readIn = YES;
270: return YES;
271: } else {
272: [self isTask];
273: return NO;
274: }
275: }
276: }
277:
278: -(void)combineRegions: (BOOL)combineRegions
279: { dontCombineRegions = !combineRegions;}
280:
281: -(void)_readInAllRelocs
282: {
283: kern_return_t error = 0;
284: vm_address_t address = VM_MIN_ADDRESS;
285: Region *theRegion, *regions, *newRegion, *nextRegion, *lastRegion;
286: int count = 0, numPages = 0, numAlloced = 16, nPages;
287: unsigned char *thePage;
288:
289: if ([self isTask]) {
290: theRegion = regions = malloc(numAlloced * sizeof(Region));
291: bzero(regions, numAlloced * sizeof(Region));
292: while (!error) {
293: error = vmRegion(task, address, theRegion);
294: address = theRegion->reloc.address + theRegion->reloc.size;
295: if (!error) {
296: if (theRegion->protection & VM_PROT_READ) {
297: count++;
298: numPages += theRegion->reloc.size / pageSize;
299: if (count < numAlloced)
300: theRegion++;
301: else {
302: numAlloced *= 2;
303: regions = realloc(regions,
304: numAlloced * sizeof(Region));
305: theRegion = regions + count;
306: bzero(theRegion, count * sizeof(Region));
307: }
308: }
309: if (address < theRegion->reloc.address)
310: error = KERN_NO_SPACE;
311: }
312: }
313: if (error == KERN_NO_SPACE) {
314: lastRegion = theRegion;
315:
316: pages = malloc(numPages);
317: for (theRegion = regions, thePage = pages;
318: theRegion < lastRegion;
319: theRegion++) {
320: theRegion->pages = thePage;
321: nPages = theRegion->reloc.size / pageSize;
322: while(nPages--)
323: *(thePage++) = (unsigned char)theRegion->protection;
324: }
325:
326: if (dontCombineRegions) {
327: for (theRegion = regions; theRegion < lastRegion; theRegion++)
328: theRegion->reloc.maxAddress
329: = theRegion->reloc.address + theRegion->reloc.size;
330: relocs = regions;
331: numRelocs = count;
332: } else {
333: relocs = malloc(count * sizeof(Region));
334: bzero(relocs, count * sizeof(Region));
335: for (theRegion = regions, newRegion = relocs;
336: theRegion < lastRegion;
337: theRegion = nextRegion, newRegion++) {
338: for (nextRegion = theRegion + 1;
339: (nextRegion < lastRegion
340: && ((theRegion->reloc.address + theRegion->reloc.size)
341: == nextRegion->reloc.address));
342: nextRegion++) {
343: theRegion->reloc.size += nextRegion->reloc.size;
344: }
345: *newRegion = *theRegion;
346: newRegion->reloc.maxAddress
347: = newRegion->reloc.address + newRegion->reloc.size;
348: }
349: numRelocs = newRegion - (Region *)relocs;
350: relocs = realloc(relocs, numRelocs * sizeof(Region));
351: free(regions);
352: }
353: rmFlags.invalid = NO;
354: } else
355: free(regions);
356:
357: if (error != KERN_NO_SPACE)
358: [self isTask];
359: }
360: }
361:
362: -(struct mach_header *)getMachHeader
363: {
364: Reloc *reloc;
365: int count;
366: struct mach_header *header, *foundHeader;
367:
368: if (rmFlags.invalid)
369: [self readInAllRelocs];
370: reloc = relocs;
371: for (foundHeader = NULL, count = 0;
372: !foundHeader && count < numRelocs;
373: count++) {
374: [self readInReloc: reloc];
375: header = [self pointerFor: (void *)reloc->address
376: withSize: sizeof(*header)];
377: if (header
378: && (header->magic == MH_MAGIC)
379: && ([self pointerFor: (void *)reloc->address
380: withSize: header->sizeofcmds]))
381: foundHeader = header;
382: else
383: ((void *)reloc) += relocSize;
384: }
385: return foundHeader;
386: }
387:
388: -(int)getNumMachHeaders
389: {
390: struct mach_header *myHeader;
391: int numHeaders, i;
392: struct fvmlib_command *loadCmd;
393: if (myHeader = [self getMachHeader]) {
394: numHeaders = 1;
395: for (i = 0, loadCmd = (struct fvmlib_command *)(myHeader + 1);
396: i < myHeader->ncmds;
397: i++,
398: loadCmd = ((void *)loadCmd + loadCmd->cmdsize)) {
399: if (loadCmd->cmd == LC_LOADFVMLIB)
400: numHeaders++;
401: }
402: } else
403: numHeaders = 0;
404: return numHeaders;
405: }
406:
407: -(struct mach_header **)getMachHeadersWithNames: (char ***)names
408: {
409: struct mach_header *myHeader, **headers, *header;
410: char **theNames = NULL;
411: struct fvmlib_command *loadCmd;
412: int numHeaders, headerIndex;
413: numHeaders = [self getNumMachHeaders];
414: myHeader = [self getMachHeader];
415: headers = malloc((numHeaders + 1) * sizeof(*headers));
416: if (names) {
417: *names = theNames = malloc((numHeaders + 1) * sizeof(*theNames));
418: theNames[0] = NULL;
419: }
420: headers[0] = myHeader;
421: for (headerIndex = 1, loadCmd = (struct fvmlib_command *)(myHeader + 1);
422: headerIndex < numHeaders;
423: loadCmd = ((void *)loadCmd + loadCmd->cmdsize)) {
424: if (loadCmd->cmd == LC_LOADFVMLIB) {
425: header = [self pointerFor: (void *)(loadCmd->fvmlib.header_addr)
426: withSize: sizeof(*header)];
427: if (header)
428: headers[headerIndex]
429: = [self pointerFor: (void *)(loadCmd->fvmlib.header_addr)
430: withSize: header->sizeofcmds];
431: if (names)
432: theNames[headerIndex]
433: = (char *)loadCmd
434: + ((struct fvmlib_command *)loadCmd)
435: ->fvmlib.name.offset;
436: headerIndex++;
437: }
438: }
439: headers[numHeaders] = NULL;
440: if (names)
441: theNames[numHeaders] = NULL;
442: return headers;
443: }
444:
445: -(struct mach_header **)getMachHeaders
446: {
447: return [self getMachHeadersWithNames: NULL];
448: }
449:
450: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.