![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to LazyRegionManager.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 LazyRegionManager.m CVS log | Up to [Apple XNU] / GNUtools / debug / Common |
1.1 root 1: #import "LazyRegionManager.h"
2:
3: #import <string.h>
4:
5: #define VM_PROT_VOLATILE ((vm_prot_t) 0x08) // not cacheable
6: #define VM_PROT_SPARSE ((vm_prot_t) 0x10) // sparse addr space
7:
8: @implementation LazyRegionManager
9:
10: -(BOOL)readInReloc: (Reloc *)reloc
11: {
12: kern_return_t ret;
13:
14: if (!reloc->rFlags.readIn) {
15: ret = vm_allocate(task_self(), &reloc->data, reloc->size, YES);
16: if (ret == KERN_SUCCESS) {
17: reloc->maxData = reloc->data + reloc->size;
18: reloc->displacement = reloc->data - reloc->address;
19: reloc->rFlags.readIn = YES;
20: }
21: }
22: return reloc->rFlags.readIn ? YES : NO;
23: }
24:
25: -(int)pageFor: (const void *)pointer inRegion: (Region *)region
26: {
27: return (((unsigned int)pointer - region->reloc.address) / pageSize);
28: }
29:
30: -(BOOL)readInDataFor: (const void *)pointer into: (void *)data withSize: (int)size
31: {
32: unsigned int error = 0, nData;
33: pointer_t readPage;
34:
35: error = vm_read(task, (vm_address_t)pointer, size, &readPage, &nData);
36: if (!error) {
37: bcopy((void *)readPage, data, size);
38: vm_deallocate(task_self(), readPage, nData);
39: } else
40: [self isTask];
41: return error ? NO : YES;
42: }
43:
44: -(BOOL)readInPage: (unsigned char *)page
45: for: (void *)pointer
46: into: (void *)data
47: {
48: unsigned int error = 0, nData;
49: pointer_t readPage;
50:
51: if (!(*page & PAGEREADIN)) {
52: // printf("Reading in page at %p.\n", pointer);
53: error = vm_read(task, (vm_address_t)pointer, pageSize, &readPage,
54: &nData);
55: if (!error) {
56: bcopy((void *)readPage, data, pageSize);
57: vm_deallocate(task_self(), readPage, nData);
58: if (!(*page & VM_PROT_VOLATILE))
59: *page |= PAGEREADIN;
60: } else
61: [self isTask];
62: }
63: return error ? NO : YES;
64: }
65:
66: -(BOOL)readInPagesFor: (const void *)pointer withSize: (int)size inRegion: (Region *)region
67: {
68: int nPage, offset;
69: unsigned char *page, *endPage;
70: void *data, *address;
71: int ok = YES;
72:
73: // printf("Getting data at: %p for %d bytes.\n", pointer, size);
74:
75: nPage = [self pageFor: pointer inRegion: region];
76: offset = nPage * pageSize;
77: page = region->pages + nPage;
78: if (*page & VM_PROT_SPARSE)
79: ok = [self readInDataFor: pointer
80: into: (void *)pointer + region->reloc.displacement
81: withSize: size];
82: else {
83: endPage = region->pages
84: + [self pageFor: pointer + size inRegion: region];
85: data = (void *)(region->reloc.data + offset);
86: address = (void *)(region->reloc.address + offset);
87: while (ok && page <= endPage) {
88: ok = [self readInPage: page for: address into: data];
89: address += pageSize;
90: data += pageSize;
91: page++;
92: }
93: }
94: return ok;
95: }
96:
97: -(void *)pointerFor: (const void *)pointer withSize: (int)size
98: {
99: Region *region;
100: pointer_t newPointer;
101: if (pointer && (region = (Region *)[self relocFor: pointer])) {
102: newPointer = (pointer_t)pointer + region->reloc.displacement;
103: if (((newPointer + size) <= region->reloc.maxData)
104: && [self readInPagesFor: pointer withSize: size inRegion: region])
105: return (void *)newPointer;
106: else
107: return NULL;
108: } else
109: return NULL;
110: }
111:
112: -(int)getDataAt: (const void *)start for: (int)numBytes into: (void *)data
113: {
114: Reloc *reloc = [self relocFor: start];
115: int numBytesInRegion;
116:
117: // printf("Getting data at: %p for %d bytes.\n", start, numBytes);
118:
119: if (reloc) {
120: numBytesInRegion = reloc->maxAddress - (int)start;
121: if (numBytes > numBytesInRegion)
122: numBytes = numBytesInRegion;
123: if ([self readInPagesFor: start
124: withSize: numBytes
125: inRegion: (Region *)reloc]) {
126: memcpy(data,
127: (void *)(reloc->data
128: + ((pointer_t)start - reloc->address)),
129: numBytes);
130: return numBytes;
131: } else
132: return 0;
133: } else
134: return 0;
135: }
136:
137: -(int)putDataAt: (void *)start for: (int)numBytes from: (const void *)data
138: {
139: int numBytesInRegion;
140: Reloc *reloc = [self relocFor: start];
141:
142: // printf("Putting data at: %p for %d bytes.\n", start, numBytes);
143:
144: if (reloc) {
145: numBytesInRegion = reloc->maxAddress - (int)start;
146: if (numBytes > numBytesInRegion)
147: numBytes = numBytesInRegion;
148: if ([self readInPagesFor: start
149: withSize: numBytes
150: inRegion: (Region *)reloc]) {
151: memcpy((void *)(reloc->data + ((pointer_t)start - reloc->address)),
152: data,
153: numBytes);
154: return [self writeDataAt: start for: numBytes
155: reloc: (Region *)reloc];
156: } else
157: return 0;
158: } else
159: return 0;
160: }
161:
162: -(char *)pointerForString: (const char *)pointer isNullTerminated: (BOOL *)isNT
163: {
164: char *retPointer;
165: Region *region;
166: char *string;
167: int nPage, offset;
168: unsigned char *page;
169: void *data, *address;
170: BOOL ok;
171:
172: if (pointer && (region = (Region *)[self relocFor: pointer])) {
173: retPointer = (char *)((pointer_t)pointer + region->reloc.displacement);
174: nPage = [self pageFor: pointer inRegion: region];
175: page = region->pages + nPage;
176: offset = nPage * pageSize;
177: data = (void *)(region->reloc.data + offset);
178: address = (void *)(region->reloc.address + offset);
179: string = retPointer;
180: do {
181: ok = [self readInPage: page for: address into: data];
182: if (ok) {
183: page++;
184: address += pageSize;
185: data += pageSize;
186: while (*string && (string < (char *)data))
187: string++;
188: }
189: } while (ok && *string && (data < (void *)region->reloc.maxData));
190: *isNT = *string ? NO : YES;
191: return retPointer;
192: } else{
193: *isNT = NO;
194: return NULL;
195: }
196: }
197:
198: -(int)writeDataAt: (const void *)start for: (int)numBytes reloc: (Region *)region
199: {
200: char *page = pages + [self pageFor: start inRegion: region];
201: kern_return_t ret;
202:
203: if (*page & VM_PROT_SPARSE) {
204: ret = vm_write(task,
205: (vm_address_t)start,
206: (pointer_t)(start + region->reloc.displacement),
207: numBytes);
208: if (ret == KERN_SUCCESS)
209: return numBytes;
210: else {
211: [self isTask];
212: return 0;
213: }
214: } else
215: return [super writeDataAt: start for: numBytes reloc: region];
216: }
217:
218: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.