![[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 Darwin 0.x] / objc / Test / ostats|
Return to RegionManager.m CVS log | Up to [Apple Darwin 0.x] / objc / Test / ostats |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.0 (the 'License'). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License."
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: #import "RegionManager.h"
25:
26: #import <stdlib.h>
27: #import <string.h>
28: #import <sys/loader.h>
29:
30: @implementation RegionManager
31:
32: -initialize: (vm_task_t)theTask
33: {
34: regions = [Storage newCount: 0
35: elementSize: sizeof(Region)
36: description: @encode(Region)];
37: task = theTask;
38: return self;
39: }
40: +newTask: (vm_task_t)theTask
41: {
42: return [[super new] initialize: theTask];
43: }
44:
45: -free
46: {
47: int count;
48: Region *region;
49: for (count = [regions count]; count; count--) {
50: region = [regions elementAt: (count - 1)];
51: vm_deallocate(task_self(), region->data, region->dataCount);
52: }
53: [regions free];
54: return [super free];
55: }
56:
57: -(Region *)regionFor: (void *)pointer
58: {
59: Region newRegion;
60: kern_return_t error = NO;
61: Region *region = NULL;
62: int count;
63: BOOL found;
64: for (count = [regions count], found = NO; count && !found; count--) {
65: region = [regions elementAt: (count - 1)];
66: if ( (region->address <= (pointer_t)pointer)
67: && ((pointer_t)pointer < (region->maxAddress)))
68: found = YES;
69: }
70: if (!found) {
71: newRegion.address = (vm_address_t)pointer;
72: error = vm_region( task,
73: &newRegion.address,
74: &newRegion.size,
75: &newRegion.protection,
76: &newRegion.maxProtection,
77: &newRegion.inheritance,
78: &newRegion.shared,
79: &newRegion.objectName,
80: &newRegion.offset);
81: if (!error && (newRegion.protection & VM_PROT_READ)) {
82: error = vm_read( task,
83: newRegion.address,
84: newRegion.size,
85: &newRegion.data,
86: &newRegion.dataCount);
87: if (!error) {
88: newRegion.maxAddress = newRegion.address + newRegion.size;
89: newRegion.maxData = newRegion.data + newRegion.size;
90: newRegion.displacement = newRegion.data - newRegion.address;
91: [regions addElement: &newRegion];
92: region = &newRegion;
93: } else
94: region = NULL;
95: } else
96: region = NULL;
97: }
98: return region;
99: }
100:
101: -invalidate
102: {
103: int count;
104: Region *region;
105: for (count = [regions count]; count; count--) {
106: region = [regions elementAt: (count - 1)];
107: vm_deallocate(task_self(), region->data, region->dataCount);
108: }
109: [regions empty];
110: return self;
111: }
112:
113: -(Region *)oldRegionFor: (void *)pointer
114: {
115: Region *region = NULL;
116: int count;
117: BOOL found;
118: for (count = [regions count], found = NO; count && !found; count--) {
119: region = [regions elementAt: (count - 1)];
120: if ((region->data <= (pointer_t)pointer)
121: && ((pointer_t)pointer < region->maxData))
122: found = YES;
123: }
124: if (found)
125: return region;
126: else
127: return NULL;
128: }
129:
130: -(void *)originalPointerFor: (void *)pointer
131: {
132: Region *region = [self oldRegionFor: pointer];
133: if (region)
134: return (region->address + (pointer - region->data));
135: else
136: return NULL;
137: }
138:
139: -(void *)pointerFor: (void *)pointer
140: {
141: Region *region;
142: if (pointer && (region = [self regionFor: pointer]))
143: return (void *)((pointer_t)pointer + region->displacement);
144: else
145: return NULL;
146: }
147:
148: -(void *)pointerFor: (void *)pointer withSize: (int)size
149: {
150: Region *region;
151: pointer_t newPointer;
152: if (pointer && (region = [self regionFor: pointer])) {
153: newPointer = (pointer_t)pointer + region->displacement;
154: if ((newPointer + size) < region->maxData)
155: return (void *)newPointer;
156: else
157: return NULL;
158: } else
159: return NULL;
160: }
161:
162: -(id)pointerForID: (id)pointer
163: {
164: Region *region;
165: pointer_t newID;
166: Class theClass;
167: if (pointer && (region = [self regionFor: pointer])) {
168: newID = (pointer_t)pointer + region->displacement;
169: if ( ((newID + sizeof(id)) < region->maxData)
170: && (theClass = [self pointerFor: ((id)newID)->isa withSize: sizeof(Class)])
171: && ((newID + theClass->instance_size) < region->maxData))
172: return (id)newID;
173: else
174: return NULL;
175: } else
176: return NULL;
177: }
178:
179:
180: -(BOOL)getDataAt: (void *)start for: (int)numBytes into: (void *)data
181: {
182: Region *region = [self regionFor: start];
183: if (region) {
184: if (((pointer_t)start + numBytes) < (region->address + region->size)) {
185: memcpy(data, (void *)(region->data + ((pointer_t)start - region->address)), numBytes);
186: return YES;
187: } else
188: return NO;
189: } else
190: return NO;
191: }
192:
193: -(struct mach_header *)getMachHeader
194: {
195: BOOL found;
196: Region *region;
197: Region newRegion;
198: struct mach_header *myHeader = NULL, *hisHeader;
199: for ( found = NO, hisHeader = 0x0000;
200: !found;
201: hisHeader = (struct mach_header *)(region->address + region->size)) {
202: region = [self regionFor: hisHeader];
203: if (region) {
204: myHeader = (struct mach_header *)(region->data + ((pointer_t)hisHeader - region->address));
205: if (myHeader->magic == MH_MAGIC)
206: found = YES;
207: } else {
208: newRegion.address = (vm_address_t) hisHeader;
209: vm_region( task,
210: &newRegion.address,
211: &newRegion.size,
212: &newRegion.protection,
213: &newRegion.maxProtection,
214: &newRegion.inheritance,
215: &newRegion.shared,
216: &newRegion.objectName,
217: &newRegion.offset);
218: region = &newRegion;
219: }
220: }
221: return myHeader;
222: }
223:
224: -(struct mach_header **)getMachHeaders
225: {
226: struct mach_header *myHeader, **headers;
227: struct fvmlib_command *loadCmd;
228: int numHeaders, i, headerIndex;
229: myHeader = [self getMachHeader];
230: for ( i = 0, numHeaders = 0, loadCmd = (struct fvmlib_command *)(myHeader + 1);
231: i < myHeader->ncmds;
232: i++, loadCmd = (struct fvmlib_command *)((char *)loadCmd + loadCmd->cmdsize)) {
233: if (loadCmd->cmd == LC_LOADFVMLIB)
234: numHeaders++;
235: }
236: headers = malloc((numHeaders + 2) * sizeof(*headers));
237: headers[0] = myHeader;
238: for ( headerIndex = 1, loadCmd = (struct fvmlib_command *)(myHeader + 1);
239: headerIndex <= numHeaders;
240: loadCmd = (struct fvmlib_command *)((char *)loadCmd + loadCmd->cmdsize)) {
241: if (loadCmd->cmd == LC_LOADFVMLIB) {
242: headers[headerIndex] = [self pointerFor: (void *)(loadCmd->fvmlib.header_addr)];
243: /* snaroff */
244: headers[headerIndex]->flags =
245: (char *)[self originalPointerFor:loadCmd] +
246: loadCmd->fvmlib.name.offset;
247: headerIndex++;
248: }
249: }
250: headers[headerIndex] = NULL;
251: return headers;
252: }
253:
254: -(void *) getSectData: (STR)segName
255: section: (STR)sectName
256: size: (int *)pSize
257: forHeader: (struct mach_header *)header
258: {
259: void *data = getsectdatafromheader(header, segName, sectName, pSize);
260: return [self pointerFor: data];
261: }
262:
263: -(void *) getSectData: (STR)segName
264: section: (STR)sectName
265: size: (int *)pSize
266: {
267: return [self getSectData: segName section: sectName size: pSize forHeader: [self getMachHeader]];
268: }
269:
270: @end
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.