![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to PCinit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / i386 / pc_support|
Return to PCinit.c CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / i386 / pc_support |
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.1 (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:
25: /*
26: * Copyright (c) 1993 NeXT Computer, Inc.
27: *
28: * PC support initialization.
29: *
30: * HISTORY
31: *
32: * 9 Mar 1993 ? at NeXT
33: * Created.
34: */
35:
36: #import <mach/mach_types.h>
37:
38: #import <kern/kern_port.h>
39:
40: #import <vm/vm_kern.h>
41:
42: #import "PCprivate.h"
43:
44: kern_return_t
45: PCcreate(
46: port_t th_port,
47: vm_offset_t paddress,
48: boolean_t anywhere
49: )
50: {
51: kern_return_t result;
52: task_t target_task = current_task();
53: vm_offset_t address;
54: thread_t thread;
55: kern_port_t th_kport;
56: PCprivate_t priv;
57:
58: if (!suser())
59: return (KERN_FAILURE);
60:
61: if (!anywhere) {
62: if (copyin(paddress, &address, sizeof (address)))
63: return (KERN_INVALID_ARGUMENT);
64:
65: address = trunc_page(address);
66: }
67: else
68: address = vm_map_min(target_task->map);
69:
70: if (!object_copyin(
71: target_task,
72: th_port, MSG_TYPE_PORT,
73: FALSE, (void *)&th_kport))
74: return (KERN_INVALID_ARGUMENT);
75:
76: thread = convert_port_to_thread(th_kport);
77:
78: port_release(th_kport);
79:
80: if (thread == THREAD_NULL)
81: return (KERN_INVALID_ARGUMENT);
82:
83: if (thread->pcb->PCpriv) {
84: if (anywhere) {
85: address = thread->pcb->PCpriv->taskShared;
86:
87: if (copyout(&address, paddress, sizeof (address)))
88: result = KERN_INVALID_ARGUMENT;
89: else
90: result = KERN_SUCCESS;
91: }
92: else {
93: if (address == thread->pcb->PCpriv->taskShared)
94: result = KERN_SUCCESS;
95: else
96: result = KERN_INVALID_ADDRESS;
97: }
98:
99: thread_deallocate(thread);
100:
101: return (result);
102: }
103:
104: result = vm_map_find(
105: target_task->map,
106: VM_OBJECT_NULL, 0,
107: &address, round_page(sizeof (struct PCshared)),
108: anywhere);
109:
110: if (result != KERN_SUCCESS) {
111: thread_deallocate(thread);
112:
113: return (result);
114: }
115:
116: if (anywhere) {
117: if (copyout(&address, paddress, sizeof (address))) {
118: thread_deallocate(thread);
119:
120: return (KERN_INVALID_ARGUMENT);
121: }
122: }
123:
124: vm_map_reference(target_task->map);
125:
126: priv = (PCprivate_t)kalloc(sizeof (struct PCprivate));
127: *priv = (struct PCprivate) { 0 };
128:
129: (void) kmem_alloc_wired(kernel_map,
130: (PCshared_t *)&priv->shared,
131: sizeof (struct PCshared));
132: priv->task = target_task->map;
133: priv->taskShared = address;
134:
135: pmap_enter_shared_range(
136: vm_map_pmap(priv->task),
137: priv->taskShared,
138: sizeof (struct PCshared),
139: (vm_offset_t)priv->shared);
140:
141: priv->shared->versionNumber = PCVERSIONNUMBER;
142: priv->shared->releaseNumber = PCRELEASENUMBER;
143:
144: thread->pcb->PCpriv = priv;
145:
146: thread_deallocate(thread);
147:
148: return (KERN_SUCCESS);
149: }
150:
151: void
152: PCdestroy(
153: thread_t thread
154: )
155: {
156: PCprivate_t priv = thread->pcb->PCpriv;
157:
158: pmap_remove(
159: vm_map_pmap(priv->task),
160: priv->taskShared,
161: round_page(priv->taskShared + sizeof (struct PCshared)));
162:
163: (void) vm_map_remove(
164: priv->task,
165: priv->taskShared,
166: round_page(priv->taskShared + sizeof (struct PCshared)));
167:
168: vm_map_deallocate(priv->task);
169:
170: PCcancelAllTimers(thread);
171:
172: kmem_free(
173: kernel_map,
174: (vm_offset_t)priv->shared,
175: round_page(sizeof (struct PCshared)));
176:
177: kfree(priv, sizeof (struct PCprivate));
178: }
179:
180: kern_return_t
181: PCldt(
182: port_t th_port,
183: vm_offset_t address,
184: vm_size_t size
185: )
186: {
187: kern_return_t result;
188: thread_t thread;
189: kern_port_t th_kport;
190: thread_saved_state_t *saved_state;
191:
192: if (!suser())
193: return (KERN_FAILURE);
194:
195: if (!object_copyin(
196: current_task(),
197: th_port, MSG_TYPE_PORT,
198: FALSE, (void *)&th_kport))
199: return (KERN_INVALID_ARGUMENT);
200:
201: thread = convert_port_to_thread(th_kport);
202:
203: port_release(th_kport);
204:
205: if (thread == THREAD_NULL)
206: return (KERN_INVALID_ARGUMENT);
207:
208: saved_state = USER_REGS(thread);
209:
210: if (address == (vm_offset_t)-1 && size == (vm_offset_t)-1)
211: result = task_default_ldt(thread->task);
212: else
213: result = task_locate_ldt(thread->task, address, size);
214:
215: if (result == KERN_SUCCESS) {
216: saved_state->frame.cs = UCODE_SEL;
217: saved_state->frame.ss = UDATA_SEL;
218: saved_state->regs.ds = UDATA_SEL;
219: saved_state->regs.es = UDATA_SEL;
220: saved_state->regs.fs = NULL_SEL;
221: saved_state->regs.gs = NULL_SEL;
222: }
223:
224: thread_deallocate(thread);
225:
226: return (result);
227: }
228:
229: kern_return_t
230: PCcopyBIOSData(
231: vm_address_t dest
232: )
233: {
234: if (dest == (vm_address_t)0)
235: return (KERN_INVALID_ARGUMENT);
236:
237: if (copyout((vm_address_t)BIOS_DATA_ADDR, dest, BIOS_DATA_SIZE))
238: return (KERN_INVALID_ARGUMENT);
239:
240: return (KERN_SUCCESS);
241: }
242:
243: vm_size_t
244: PCsizeBIOSExtData(void)
245: {
246: return (CNV_MEM_END_ADDR - bios_extdata_addr());
247: }
248:
249: kern_return_t
250: PCcopyBIOSExtData(
251: vm_address_t dest
252: )
253: {
254: vm_address_t data = bios_extdata_addr();
255:
256: if (dest == (vm_address_t)0)
257: return (KERN_INVALID_ARGUMENT);
258:
259: if (copyout(data, dest, CNV_MEM_END_ADDR - data))
260: return (KERN_INVALID_ARGUMENT);
261:
262: return (KERN_SUCCESS);
263: }
264:
265: kern_return_t
266: PCmapBIOSRom(
267: port_t task_port,
268: vm_offset_t paddress,
269: boolean_t anywhere
270: )
271: {
272: kern_return_t result;
273: vm_offset_t address;
274: task_t target_task;
275: kern_port_t task_kport;
276:
277: if (!anywhere) {
278: if (copyin(paddress, &address, sizeof (address)))
279: return (KERN_INVALID_ARGUMENT);
280:
281: address = trunc_page(address);
282: }
283: else
284: address = vm_map_min(target_task->map);
285:
286: if (!object_copyin(
287: current_task(),
288: task_port, MSG_TYPE_PORT,
289: FALSE, (void *)&task_kport))
290: return (KERN_INVALID_ARGUMENT);
291:
292: target_task = convert_port_to_task(task_kport);
293:
294: port_release(task_kport);
295:
296: if (target_task == TASK_NULL)
297: return (KERN_INVALID_ARGUMENT);
298:
299: result = vm_map_find(
300: target_task->map,
301: VM_OBJECT_NULL, 0,
302: &address, round_page(BIOS_ROM_SIZE),
303: anywhere);
304:
305: if (result != KERN_SUCCESS) {
306: task_deallocate(target_task);
307:
308: return (result);
309: }
310:
311: if (anywhere) {
312: if (copyout(&address, paddress, sizeof (address))) {
313: task_deallocate(target_task);
314:
315: return (KERN_INVALID_ARGUMENT);
316: }
317: }
318:
319: {
320: vm_offset_t end = round_page(address + BIOS_ROM_SIZE);
321: vm_offset_t phys = trunc_page(BIOS_ROM_ADDR);
322:
323: while (address < end) {
324: pmap_enter(
325: vm_map_pmap(target_task->map),
326: address,
327: phys,
328: VM_PROT_READ,
329: TRUE);
330:
331: address += PAGE_SIZE; phys += PAGE_SIZE;
332: }
333: }
334:
335: task_deallocate(target_task);
336:
337: return (KERN_SUCCESS);
338: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.