![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_unix.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / vm|
Return to vm_unix.c CVS log | Up to [Apple Darwin 0.x] / kernel / vm |
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: * Mach Operating System
27: * Copyright (c) 1987 Carnegie-Mellon University
28: * All rights reserved. The CMU software License Agreement specifies
29: * the terms and conditions for use and redistribution.
30: */
31:
32: /*
33: */
34: #import <cputypes.h>
35: #import <mach_nbc.h>
36: #import <mach/features.h>
37:
38: #import <kern/task.h>
39: #import <kern/thread.h>
40: #import <mach/time_value.h>
41: #import <mach/vm_param.h>
42: #import <vm/vm_map.h>
43: #import <vm/vm_page.h>
44: #import <kern/parallel.h>
45:
46: #import <sys/param.h>
47: #import <sys/systm.h>
48: #import <sys/dir.h>
49: #import <sys/proc.h>
50: #import <sys/vm.h>
51: #import <sys/file.h>
52: #import <sys/vnode.h>
53: #import <sys/buf.h>
54: #import <sys/mount.h>
55: #import <sys/trace.h>
56: #import <sys/kernel.h>
57:
58: #import <kern/kalloc.h>
59: #import <mach/port.h>
60:
61: #import <machine/spl.h>
62:
63: useracc(addr, len, prot)
64: caddr_t addr;
65: u_int len;
66: int prot;
67: {
68: return (vm_map_check_protection(
69: current_task()->map,
70: trunc_page(addr), round_page(addr+len),
71: prot == B_READ ? VM_PROT_READ : VM_PROT_WRITE));
72: }
73:
74: vslock(addr, len)
75: caddr_t addr;
76: int len;
77: {
78: vm_map_pageable(current_task()->map, trunc_page(addr),
79: round_page(addr+len), FALSE);
80: }
81:
82: vsunlock(addr, len, dirtied)
83: caddr_t addr;
84: int len;
85: int dirtied;
86: {
87: #if NeXT
88: pmap_t pmap;
89: vm_page_t pg;
90: vm_offset_t vaddr, paddr;
91:
92: if (dirtied) {
93: pmap = current_task()->map->pmap;
94: for (vaddr = trunc_page(addr); vaddr < round_page(addr+len);
95: vaddr += PAGE_SIZE) {
96: paddr = pmap_extract(pmap, vaddr);
97: pg = PHYS_TO_VM_PAGE(paddr);
98: vm_page_set_modified(pg);
99: }
100: }
101: #endif /* NeXT */
102: #ifdef lint
103: dirtied++;
104: #endif /* lint */
105: vm_map_pageable(current_task()->map, trunc_page(addr),
106: round_page(addr+len), TRUE);
107: }
108:
109: #if defined(sun) || BALANCE || defined(m88k) || defined(i386)
110: #else defined(sun) || BALANCE || defined(m88k) || defined(i386)
111: subyte(addr, byte)
112: void * addr;
113: int byte;
114: {
115: char character;
116:
117: character = (char)byte;
118: return (copyout((void *)&(character), addr, sizeof(char)) == 0 ? 0 : -1);
119: }
120:
121: suibyte(addr, byte)
122: void * addr;
123: int byte;
124: {
125: char character;
126:
127: character = (char)byte;
128: return (copyout((void *) &(character), addr, sizeof(char)) == 0 ? 0 : -1);
129: }
130:
131: int fubyte(addr)
132: void * addr;
133: {
134: unsigned char byte;
135:
136: if (copyin(addr, (void *) &byte, sizeof(char)))
137: return(-1);
138: return(byte);
139: }
140:
141: int fuibyte(addr)
142: void * addr;
143: {
144: unsigned char byte;
145:
146: if (copyin(addr, (void *) &(byte), sizeof(char)))
147: return(-1);
148: return(byte);
149: }
150:
151: suword(addr, word)
152: void * addr;
153: long word;
154: {
155: return (copyout((void *) &word, addr, sizeof(int)) == 0 ? 0 : -1);
156: }
157:
158: long fuword(addr)
159: void * addr;
160: {
161: long word;
162:
163: if (copyin(addr, (void *) &word, sizeof(int)))
164: return(-1);
165: return(word);
166: }
167:
168: /* suiword and fuiword are the same as suword and fuword, respectively */
169:
170: suiword(addr, word)
171: void * addr;
172: long word;
173: {
174: return (copyout((void *) &word, addr, sizeof(int)) == 0 ? 0 : -1);
175: }
176:
177: long fuiword(addr)
178: void * addr;
179: {
180: long word;
181:
182: if (copyin(addr, (void *) &word, sizeof(int)))
183: return(-1);
184: return(word);
185: }
186: #endif /* defined(sun) || BALANCE || defined(m88k) || defined(i386) */
187:
188: swapon()
189: {
190: /* Not yet implemented */
191: printf("swapon(): not supported!\n");
192: return(EPERM);
193: }
194:
195: thread_t procdup(child, parent)
196: struct proc *child, *parent;
197: {
198: thread_t thread;
199: task_t task;
200: kern_return_t result;
201: boolean_t inherit_memory = TRUE;
202:
203: if (parent->task == kernel_task)
204: inherit_memory = FALSE;
205:
206: result = task_create(parent->task, inherit_memory, &task);
207: if(result != KERN_SUCCESS)
208: printf("fork/procdup: task_create failed. result: %d\n", result);
209: child->task = task; /* retained reference */
210: task->proc = child;
211:
212: result = thread_create(task, &thread);
213: if(result != KERN_SUCCESS)
214: printf("fork/procdup: thread_create failed. Code: 0x%x\n", result);
215: thread_deallocate(thread); /* release reference */
216:
217: /*
218: * Don't need to lock thread here because it can't
219: * possibly execute and no one else knows about it.
220: */
221: compute_priority(thread, FALSE);
222:
223: return(thread);
224: }
225:
226: chgprot(_addr, prot)
227: caddr_t _addr;
228: vm_prot_t prot;
229: {
230: vm_offset_t addr = (vm_offset_t) _addr;
231:
232: return(vm_map_protect(current_task()->map,
233: trunc_page(addr),
234: round_page(addr + 1),
235: prot, FALSE) == KERN_SUCCESS);
236: }
237:
238: kern_return_t unix_pid(t, x)
239: task_t t;
240: int *x;
241: {
242: if (t == TASK_NULL) {
243: *x = -1;
244: return(KERN_FAILURE);
245: } else {
246: if (t->proc)
247: *x = t->proc->p_pid;
248: else {
249: *x = -1;
250: return(KERN_FAILURE);
251: }
252: return(KERN_SUCCESS);
253: }
254: }
255:
256: /*
257: * Routine: task_by_unix_pid
258: * Purpose:
259: * Get the task port for another "process", named by its
260: * process ID on the same host as "target_task".
261: *
262: * Only permitted to privileged processes, or processes
263: * with the same user ID.
264: */
265: kern_return_t task_by_unix_pid(target_task, pid, t)
266: task_t target_task;
267: int pid;
268: task_t *t;
269: {
270: struct proc *p;
271:
272: unix_master();
273:
274: if (
275: ((p = pfind(pid)) != (struct proc *) 0)
276: && (target_task->proc != (struct proc *) 0)
277: && ((p->p_ucred->cr_uid == target_task->proc->p_ucred->cr_uid)
278: || !(suser(target_task->proc->p_ucred, &target_task->proc->p_acflag)))
279: && (p->p_stat != SZOMB)
280: ) {
281: if (p->task != TASK_NULL)
282: task_reference(p->task);
283: *t = p->task;
284: /* compatibility with NeXT 2.0 debuggers, launchers */
285: if (suser(p->p_ucred, &p->p_acflag)) {
286: /* don't set it for anyone; could exec a careless nameserver */
287: struct proc *p = current_task()->proc;
288:
289: if (p)
290: p->p_debugger = 1;
291: }
292: unix_release();
293: return(KERN_SUCCESS);
294: }
295: *t = TASK_NULL;
296: unix_release();
297: return(KERN_FAILURE);
298: }
299:
300: /*
301: * Routine: task_by_pid
302: * Purpose:
303: * Trap form of "task_by_unix_pid"; soon to be eliminated.
304: */
305: port_t task_by_pid(pid)
306: int pid;
307: {
308: task_t self = current_task();
309: port_t t = PORT_NULL;
310: task_t result_task;
311:
312: if (task_by_unix_pid(self, pid, &result_task) == KERN_SUCCESS) {
313: t = convert_task_to_port(result_task);
314: if (t != PORT_NULL)
315: object_copyout(self, t, MSG_TYPE_PORT, &t);
316: }
317:
318: return(t);
319: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.