1 | /* |
2 | * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | #include <zone_debug.h> |
29 | #include <mach/boolean.h> |
30 | #include <mach/kern_return.h> |
31 | #include <mach/mig_errors.h> |
32 | #include <mach/port.h> |
33 | #include <mach/vm_param.h> |
34 | #include <mach/notify.h> |
35 | //#include <mach/mach_host_server.h> |
36 | #include <mach/mach_types.h> |
37 | |
38 | #include <machine/machparam.h> /* spl definitions */ |
39 | |
40 | #include <ipc/ipc_port.h> |
41 | #include <ipc/ipc_space.h> |
42 | |
43 | #include <kern/clock.h> |
44 | #include <kern/spl.h> |
45 | #include <kern/counters.h> |
46 | #include <kern/queue.h> |
47 | #include <kern/zalloc.h> |
48 | #include <kern/thread.h> |
49 | #include <kern/task.h> |
50 | #include <kern/sched_prim.h> |
51 | #include <kern/misc_protos.h> |
52 | |
53 | #include <vm/pmap.h> |
54 | #include <vm/vm_map.h> |
55 | #include <vm/vm_kern.h> |
56 | |
57 | #include <device/device_types.h> |
58 | #include <device/device_port.h> |
59 | #include <device/device_server.h> |
60 | |
61 | #include <machine/machparam.h> |
62 | |
63 | #if defined(__i386__) || defined(__x86_64__) |
64 | #include <i386/pmap.h> |
65 | #endif |
66 | #if defined(__arm__) || defined(__arm64__) |
67 | #include <arm/pmap.h> |
68 | #endif |
69 | #include <IOKit/IOKitServer.h> |
70 | |
71 | #define EXTERN |
72 | #define MIGEXTERN |
73 | |
74 | /* |
75 | * Lookup a device by its port. |
76 | * Doesn't consume the naked send right; produces a device reference. |
77 | */ |
78 | static io_object_t |
79 | iokit_lookup_io_object(ipc_port_t port, ipc_kobject_type_t type) |
80 | { |
81 | io_object_t obj; |
82 | |
83 | if (!IP_VALID(port)) |
84 | return (NULL); |
85 | |
86 | iokit_lock_port(port); |
87 | if (ip_active(port) && (ip_kotype(port) == type)) { |
88 | obj = (io_object_t) port->ip_kobject; |
89 | iokit_add_reference( obj, type ); |
90 | } |
91 | else |
92 | obj = NULL; |
93 | |
94 | iokit_unlock_port(port); |
95 | |
96 | return( obj ); |
97 | } |
98 | |
99 | MIGEXTERN io_object_t |
100 | iokit_lookup_object_port( |
101 | ipc_port_t port) |
102 | { |
103 | return (iokit_lookup_io_object(port, IKOT_IOKIT_OBJECT)); |
104 | } |
105 | |
106 | MIGEXTERN io_object_t |
107 | iokit_lookup_connect_port( |
108 | ipc_port_t port) |
109 | { |
110 | return (iokit_lookup_io_object(port, IKOT_IOKIT_CONNECT)); |
111 | } |
112 | |
113 | static io_object_t |
114 | iokit_lookup_object_in_space_with_port_name(mach_port_name_t name, ipc_kobject_type_t type, ipc_space_t space) |
115 | { |
116 | io_object_t obj = NULL; |
117 | |
118 | if (name && MACH_PORT_VALID(name)) { |
119 | ipc_port_t port; |
120 | kern_return_t kr; |
121 | |
122 | kr = ipc_object_translate(space, name, MACH_PORT_RIGHT_SEND, (ipc_object_t *)&port); |
123 | |
124 | if (kr == KERN_SUCCESS) { |
125 | assert(IP_VALID(port)); |
126 | |
127 | ip_reference(port); |
128 | ip_unlock(port); |
129 | |
130 | iokit_lock_port(port); |
131 | if (ip_active(port) && (ip_kotype(port) == type)) { |
132 | obj = (io_object_t) port->ip_kobject; |
133 | iokit_add_reference(obj, type); |
134 | } |
135 | iokit_unlock_port(port); |
136 | |
137 | ip_release(port); |
138 | } |
139 | } |
140 | |
141 | return obj; |
142 | } |
143 | |
144 | EXTERN io_object_t |
145 | iokit_lookup_object_with_port_name(mach_port_name_t name, ipc_kobject_type_t type, task_t task) |
146 | { |
147 | return (iokit_lookup_object_in_space_with_port_name(name, type, task->itk_space)); |
148 | } |
149 | |
150 | EXTERN io_object_t |
151 | iokit_lookup_connect_ref_current_task(mach_port_name_t name) |
152 | { |
153 | return (iokit_lookup_object_in_space_with_port_name(name, IKOT_IOKIT_CONNECT, current_space())); |
154 | } |
155 | |
156 | EXTERN void |
157 | iokit_retain_port( ipc_port_t port ) |
158 | { |
159 | ipc_port_reference( port ); |
160 | } |
161 | |
162 | EXTERN void |
163 | iokit_release_port( ipc_port_t port ) |
164 | { |
165 | ipc_port_release( port ); |
166 | } |
167 | |
168 | EXTERN void |
169 | iokit_release_port_send( ipc_port_t port ) |
170 | { |
171 | ipc_port_release_send( port ); |
172 | } |
173 | |
174 | extern lck_mtx_t iokit_obj_to_port_binding_lock; |
175 | |
176 | EXTERN void |
177 | iokit_lock_port( __unused ipc_port_t port ) |
178 | { |
179 | lck_mtx_lock(&iokit_obj_to_port_binding_lock); |
180 | } |
181 | |
182 | EXTERN void |
183 | iokit_unlock_port( __unused ipc_port_t port ) |
184 | { |
185 | lck_mtx_unlock(&iokit_obj_to_port_binding_lock); |
186 | } |
187 | |
188 | /* |
189 | * Get the port for a device. |
190 | * Consumes a device reference; produces a naked send right. |
191 | */ |
192 | |
193 | static ipc_port_t |
194 | iokit_make_port_of_type(io_object_t obj, ipc_kobject_type_t type) |
195 | { |
196 | ipc_port_t port; |
197 | ipc_port_t sendPort; |
198 | |
199 | if( obj == NULL) |
200 | return IP_NULL; |
201 | |
202 | port = iokit_port_for_object( obj, type ); |
203 | if( port) { |
204 | sendPort = ipc_port_make_send( port); |
205 | iokit_release_port( port ); |
206 | } else |
207 | sendPort = IP_NULL; |
208 | |
209 | iokit_remove_reference( obj ); |
210 | |
211 | return( sendPort); |
212 | } |
213 | |
214 | MIGEXTERN ipc_port_t |
215 | iokit_make_object_port( |
216 | io_object_t obj ) |
217 | { |
218 | return (iokit_make_port_of_type(obj, IKOT_IOKIT_OBJECT)); |
219 | } |
220 | |
221 | MIGEXTERN ipc_port_t |
222 | iokit_make_connect_port( |
223 | io_object_t obj ) |
224 | { |
225 | return (iokit_make_port_of_type(obj, IKOT_IOKIT_CONNECT)); |
226 | } |
227 | |
228 | int gIOKitPortCount; |
229 | |
230 | EXTERN ipc_port_t |
231 | iokit_alloc_object_port( io_object_t obj, ipc_kobject_type_t type ) |
232 | { |
233 | ipc_port_t notify; |
234 | ipc_port_t port; |
235 | |
236 | do { |
237 | |
238 | /* Allocate port, keeping a reference for it. */ |
239 | port = ipc_port_alloc_kernel(); |
240 | if( port == IP_NULL) |
241 | continue; |
242 | |
243 | /* set kobject & type */ |
244 | ipc_kobject_set( port, (ipc_kobject_t) obj, type); |
245 | |
246 | /* Request no-senders notifications on the port. */ |
247 | ip_lock( port); |
248 | notify = ipc_port_make_sonce_locked( port); |
249 | ipc_port_nsrequest( port, 1, notify, ¬ify); |
250 | /* port unlocked */ |
251 | assert( notify == IP_NULL); |
252 | gIOKitPortCount++; |
253 | |
254 | } while( FALSE); |
255 | |
256 | return( port ); |
257 | } |
258 | |
259 | |
260 | EXTERN kern_return_t |
261 | iokit_destroy_object_port( ipc_port_t port ) |
262 | { |
263 | |
264 | iokit_lock_port(port); |
265 | ipc_kobject_set( port, IKO_NULL, IKOT_NONE); |
266 | |
267 | // iokit_remove_reference( obj ); |
268 | iokit_unlock_port(port); |
269 | ipc_port_dealloc_kernel( port); |
270 | gIOKitPortCount--; |
271 | |
272 | return( KERN_SUCCESS); |
273 | } |
274 | |
275 | EXTERN kern_return_t |
276 | iokit_switch_object_port( ipc_port_t port, io_object_t obj, ipc_kobject_type_t type ) |
277 | { |
278 | iokit_lock_port(port); |
279 | ipc_kobject_set( port, (ipc_kobject_t) obj, type); |
280 | iokit_unlock_port(port); |
281 | |
282 | return( KERN_SUCCESS); |
283 | } |
284 | |
285 | EXTERN mach_port_name_t |
286 | iokit_make_send_right( task_t task, io_object_t obj, ipc_kobject_type_t type ) |
287 | { |
288 | ipc_port_t port; |
289 | ipc_port_t sendPort; |
290 | mach_port_name_t name = 0; |
291 | |
292 | if( obj == NULL) |
293 | return MACH_PORT_NULL; |
294 | |
295 | port = iokit_port_for_object( obj, type ); |
296 | if( port) { |
297 | sendPort = ipc_port_make_send( port); |
298 | iokit_release_port( port ); |
299 | } else |
300 | sendPort = IP_NULL; |
301 | |
302 | if (IP_VALID( sendPort )) { |
303 | kern_return_t kr; |
304 | kr = ipc_object_copyout( task->itk_space, (ipc_object_t) sendPort, |
305 | MACH_MSG_TYPE_PORT_SEND, TRUE, &name); |
306 | if ( kr != KERN_SUCCESS) { |
307 | ipc_port_release_send( sendPort ); |
308 | name = MACH_PORT_NULL; |
309 | } |
310 | } else if ( sendPort == IP_NULL) |
311 | name = MACH_PORT_NULL; |
312 | else if ( sendPort == IP_DEAD) |
313 | name = MACH_PORT_DEAD; |
314 | |
315 | return( name ); |
316 | } |
317 | |
318 | EXTERN kern_return_t |
319 | iokit_mod_send_right( task_t task, mach_port_name_t name, mach_port_delta_t delta ) |
320 | { |
321 | return (mach_port_mod_refs( task->itk_space, name, MACH_PORT_RIGHT_SEND, delta )); |
322 | } |
323 | |
324 | /* |
325 | * Handle the No-More_Senders notification generated from a device port destroy. |
326 | * Since there are no longer any tasks which hold a send right to this device |
327 | * port a NMS notification has been generated. |
328 | */ |
329 | |
330 | static void |
331 | iokit_no_senders( mach_no_senders_notification_t * notification ) |
332 | { |
333 | ipc_port_t port; |
334 | io_object_t obj = NULL; |
335 | ipc_kobject_type_t type = IKOT_NONE; |
336 | ipc_port_t notify; |
337 | |
338 | port = (ipc_port_t) notification->not_header.msgh_remote_port; |
339 | |
340 | // convert a port to io_object_t. |
341 | if( IP_VALID(port)) { |
342 | iokit_lock_port(port); |
343 | if( ip_active(port)) { |
344 | obj = (io_object_t) port->ip_kobject; |
345 | type = ip_kotype( port ); |
346 | if( (IKOT_IOKIT_OBJECT == type) |
347 | || (IKOT_IOKIT_CONNECT == type) |
348 | || (IKOT_IOKIT_IDENT == type)) |
349 | iokit_add_reference( obj, IKOT_IOKIT_OBJECT ); |
350 | else |
351 | obj = NULL; |
352 | } |
353 | iokit_unlock_port(port); |
354 | |
355 | if( obj ) { |
356 | |
357 | mach_port_mscount_t mscount = notification->not_count; |
358 | |
359 | if( KERN_SUCCESS != iokit_client_died( obj, port, type, &mscount )) |
360 | { |
361 | /* Re-request no-senders notifications on the port (if still active) */ |
362 | ip_lock(port); |
363 | if (ip_active(port)) { |
364 | notify = ipc_port_make_sonce_locked(port); |
365 | ipc_port_nsrequest( port, mscount + 1, notify, ¬ify); |
366 | /* port unlocked */ |
367 | if ( notify != IP_NULL) |
368 | ipc_port_release_sonce(notify); |
369 | } else { |
370 | ip_unlock(port); |
371 | } |
372 | } |
373 | iokit_remove_reference( obj ); |
374 | } |
375 | } |
376 | } |
377 | |
378 | |
379 | EXTERN |
380 | boolean_t |
381 | iokit_notify( mach_msg_header_t * msg ) |
382 | { |
383 | switch (msg->msgh_id) { |
384 | case MACH_NOTIFY_NO_SENDERS: |
385 | iokit_no_senders((mach_no_senders_notification_t *) msg); |
386 | return TRUE; |
387 | |
388 | case MACH_NOTIFY_PORT_DELETED: |
389 | case MACH_NOTIFY_PORT_DESTROYED: |
390 | case MACH_NOTIFY_SEND_ONCE: |
391 | case MACH_NOTIFY_DEAD_NAME: |
392 | default: |
393 | printf("iokit_notify: strange notification %d\n" , msg->msgh_id); |
394 | return FALSE; |
395 | } |
396 | } |
397 | |
398 | /* need to create a pmap function to generalize */ |
399 | unsigned int IODefaultCacheBits(addr64_t pa) |
400 | { |
401 | return(pmap_cache_attributes((ppnum_t)(pa >> PAGE_SHIFT))); |
402 | } |
403 | |
404 | kern_return_t IOMapPages(vm_map_t map, mach_vm_address_t va, mach_vm_address_t pa, |
405 | mach_vm_size_t length, unsigned int options) |
406 | { |
407 | vm_prot_t prot; |
408 | unsigned int flags; |
409 | ppnum_t pagenum; |
410 | pmap_t pmap = map->pmap; |
411 | |
412 | prot = (options & kIOMapReadOnly) |
413 | ? VM_PROT_READ : (VM_PROT_READ|VM_PROT_WRITE); |
414 | |
415 | pagenum = (ppnum_t)atop_64(pa); |
416 | |
417 | switch(options & kIOMapCacheMask ) { /* What cache mode do we need? */ |
418 | |
419 | case kIOMapDefaultCache: |
420 | default: |
421 | flags = IODefaultCacheBits(pa); |
422 | break; |
423 | |
424 | case kIOMapInhibitCache: |
425 | flags = VM_WIMG_IO; |
426 | break; |
427 | |
428 | case kIOMapWriteThruCache: |
429 | flags = VM_WIMG_WTHRU; |
430 | break; |
431 | |
432 | case kIOMapWriteCombineCache: |
433 | flags = VM_WIMG_WCOMB; |
434 | break; |
435 | |
436 | case kIOMapCopybackCache: |
437 | flags = VM_WIMG_COPYBACK; |
438 | break; |
439 | |
440 | case kIOMapCopybackInnerCache: |
441 | flags = VM_WIMG_INNERWBACK; |
442 | break; |
443 | |
444 | case kIOMapPostedWrite: |
445 | flags = VM_WIMG_POSTED; |
446 | break; |
447 | } |
448 | |
449 | pmap_set_cache_attributes(pagenum, flags); |
450 | |
451 | vm_map_set_cache_attr(map, (vm_map_offset_t)va); |
452 | |
453 | |
454 | // Set up a block mapped area |
455 | return pmap_map_block(pmap, va, pagenum, (uint32_t) atop_64(round_page_64(length)), prot, 0, 0); |
456 | } |
457 | |
458 | kern_return_t IOUnmapPages(vm_map_t map, mach_vm_address_t va, mach_vm_size_t length) |
459 | { |
460 | pmap_t pmap = map->pmap; |
461 | |
462 | pmap_remove(pmap, trunc_page_64(va), round_page_64(va + length)); |
463 | |
464 | return( KERN_SUCCESS ); |
465 | } |
466 | |
467 | kern_return_t IOProtectCacheMode(vm_map_t __unused map, mach_vm_address_t __unused va, |
468 | mach_vm_size_t __unused length, unsigned int __unused options) |
469 | { |
470 | mach_vm_size_t off; |
471 | vm_prot_t prot; |
472 | unsigned int flags; |
473 | pmap_t pmap = map->pmap; |
474 | pmap_flush_context pmap_flush_context_storage; |
475 | boolean_t delayed_pmap_flush = FALSE; |
476 | |
477 | prot = (options & kIOMapReadOnly) |
478 | ? VM_PROT_READ : (VM_PROT_READ|VM_PROT_WRITE); |
479 | |
480 | switch (options & kIOMapCacheMask) |
481 | { |
482 | // what cache mode do we need? |
483 | case kIOMapDefaultCache: |
484 | default: |
485 | return (KERN_INVALID_ARGUMENT); |
486 | |
487 | case kIOMapInhibitCache: |
488 | flags = VM_WIMG_IO; |
489 | break; |
490 | |
491 | case kIOMapWriteThruCache: |
492 | flags = VM_WIMG_WTHRU; |
493 | break; |
494 | |
495 | case kIOMapWriteCombineCache: |
496 | flags = VM_WIMG_WCOMB; |
497 | break; |
498 | |
499 | case kIOMapCopybackCache: |
500 | flags = VM_WIMG_COPYBACK; |
501 | break; |
502 | |
503 | case kIOMapCopybackInnerCache: |
504 | flags = VM_WIMG_INNERWBACK; |
505 | break; |
506 | |
507 | case kIOMapPostedWrite: |
508 | flags = VM_WIMG_POSTED; |
509 | break; |
510 | } |
511 | |
512 | pmap_flush_context_init(&pmap_flush_context_storage); |
513 | delayed_pmap_flush = FALSE; |
514 | |
515 | // enter each page's physical address in the target map |
516 | for (off = 0; off < length; off += page_size) |
517 | { |
518 | ppnum_t ppnum = pmap_find_phys(pmap, va + off); |
519 | if (ppnum) { |
520 | pmap_enter_options(pmap, va + off, ppnum, prot, VM_PROT_NONE, flags, TRUE, |
521 | PMAP_OPTIONS_NOFLUSH, (void *)&pmap_flush_context_storage); |
522 | delayed_pmap_flush = TRUE; |
523 | } |
524 | } |
525 | if (delayed_pmap_flush == TRUE) |
526 | pmap_flush(&pmap_flush_context_storage); |
527 | |
528 | return (KERN_SUCCESS); |
529 | } |
530 | |
531 | ppnum_t IOGetLastPageNumber(void) |
532 | { |
533 | #if __i386__ || __x86_64__ |
534 | ppnum_t lastPage, highest = 0; |
535 | unsigned int idx; |
536 | |
537 | for (idx = 0; idx < pmap_memory_region_count; idx++) |
538 | { |
539 | lastPage = pmap_memory_regions[idx].end - 1; |
540 | if (lastPage > highest) |
541 | highest = lastPage; |
542 | } |
543 | return (highest); |
544 | #elif __arm__ || __arm64__ |
545 | return 0; |
546 | #else |
547 | #error unknown arch |
548 | #endif |
549 | } |
550 | |
551 | |
552 | void IOGetTime( mach_timespec_t * clock_time); |
553 | void IOGetTime( mach_timespec_t * clock_time) |
554 | { |
555 | clock_sec_t sec; |
556 | clock_nsec_t nsec; |
557 | clock_get_system_nanotime(&sec, &nsec); |
558 | clock_time->tv_sec = (typeof(clock_time->tv_sec))sec; |
559 | clock_time->tv_nsec = nsec; |
560 | } |
561 | |
562 | |