![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bsd_vm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / vm|
Return to bsd_vm.c CVS log | Up to [Apple XNU] / XNU / osfmk / vm |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22:
23: #include <sys/errno.h>
24: #include <kern/host.h>
25: #include <mach/mach_types.h>
26: #include <vm/vm_map.h>
27: #include <vm/vm_kern.h>
28: #include <vm/vm_pageout.h>
29: #include <mach/kern_return.h>
30: #include <mach/memory_object_types.h>
31: #include <mach/port.h>
32: #include <mach/policy.h>
33: #include <ipc/ipc_port.h>
34: #include <ipc/ipc_space.h>
35: #include <kern/thread.h>
36: #include <vm/vm_pageout.h>
37:
38:
39: /* BSD VM COMPONENT INTERFACES */
40: int
41: get_map_nentries(
42: vm_map_t);
43:
44: vm_offset_t
45: get_map_start(
46: vm_map_t);
47:
48: vm_offset_t
49: get_map_end(
50: vm_map_t);
51:
52: void
53: map_ref_fixup(
54: vm_map_t,
55: vm_map_t);
56:
57: /*
58: *
59: */
60: int
61: get_map_nentries(
62: vm_map_t map)
63: {
64: return(map->hdr.nentries);
65: }
66:
67: /*
68: *
69: */
70: vm_offset_t
71: get_map_start(
72: vm_map_t map)
73: {
74: return(vm_map_first_entry(map)->vme_start);
75: }
76:
77: /*
78: *
79: */
80: vm_offset_t
81: get_map_end(
82: vm_map_t map)
83: {
84: return(vm_map_last_entry(map)->vme_end);
85: }
86:
87: /*
88: * TODO: TO BE REMOVED
89: */
90: void
91: map_ref_fixup(
92: vm_map_t old_map,
93: vm_map_t new_map)
94: {
95: if (old_map->ref_count >1)
96: old_map->ref_count = 1;
97: new_map->ref_count =2;
98: }
99:
100: /*
101: * BSD VNODE PAGER
102: */
103:
104: /* until component support available */
105: int vnode_pager_workaround;
106:
107: typedef int vnode_port_t;
108:
109: typedef struct vnode_pager {
110: ipc_port_t pager; /* pager */
111: ipc_port_t pager_handle; /* pager handle */
112: ipc_port_t vm_obj_handle; /* memory object's control handle */
113: vnode_port_t vnode_handle; /* vnode handle */
114: } *vnode_pager_t;
115:
116: typedef struct vnode_port_entry {
117: queue_chain_t links; /* queue links */
118: ipc_port_t name; /* port name */
119: vnode_pager_t pager_rec; /* pager record */
120: } *vnode_port_entry_t;
121:
122:
123: #define VNODE_PORT_HASH_COUNT 127
124: #define vnode_port_hash(name_port) \
125: (((int)(name_port) & 0xffffff) % VNODE_PORT_HASH_COUNT)
126:
127: queue_head_t vnode_port_hashtable[VNODE_PORT_HASH_COUNT];
128: zone_t vnode_port_hash_zone;
129: decl_simple_lock_data(,vnode_port_hash_lock)
130:
131:
132: ipc_port_t
133: trigger_name_to_port(
134: mach_port_t);
135:
136: void
137: vnode_pager_bootstrap(
138: void);
139:
140: void
141: vnode_pager_alloc_map(
142: void);
143:
144: ipc_port_t
145: vnode_pager_setup(
146: vnode_port_t,
147: ipc_port_t);
148:
149: ipc_port_t
150: vnode_pager_lookup(
151: vnode_port_t,
152: ipc_port_t);
153:
154: kern_return_t
155: vnode_pager_init(
156: ipc_port_t,
157: ipc_port_t,
158: vm_size_t);
159:
160: kern_return_t
161: vnode_pager_data_request(
162: ipc_port_t,
163: ipc_port_t,
164: vm_offset_t,
165: vm_size_t,
166: vm_prot_t);
167:
168: kern_return_t
169: vnode_pager_data_return(
170: ipc_port_t,
171: ipc_port_t,
172: vm_offset_t,
173: pointer_t,
174: vm_size_t,
175: boolean_t,
176: boolean_t);
177:
178: void
179: vnode_pager_no_senders(
180: ipc_port_t,
181: mach_port_mscount_t);
182:
183: kern_return_t
184: vnode_pager_terminate(
185: ipc_port_t,
186: ipc_port_t);
187:
188: kern_return_t
189: vnode_pager_cluster_read(
190: vnode_pager_t,
191: vm_offset_t,
192: vm_size_t,
193: vm_object_t);
194:
195: void
196: vnode_pager_cluster_write(
197: vnode_pager_t,
198: vm_offset_t,
199: vm_size_t,
200: vm_object_t);
201:
202: kern_return_t
203: memory_object_change_attributes(
204: vm_object_t,
205: memory_object_flavor_t,
206: memory_object_info_t,
207: mach_msg_type_number_t,
208: ipc_port_t,
209: mach_msg_type_name_t);
210:
211: vnode_pager_t
212: vnode_object_create(
213: vnode_port_t vp);
214:
215: void
216: vnode_port_hash_init(void);
217:
218: void
219: vnode_port_hash_insert(
220: ipc_port_t,
221: vnode_pager_t);
222:
223: vnode_pager_t
224: vnode_port_hash_lookup(
225: ipc_port_t);
226:
227: void
228: vnode_port_hash_delete(
229: ipc_port_t);
230:
231: void
232: vnode_pager_release_from_cache(
233: int *cnt);
234:
235: void
236: vnode_pager_create(
237: vnode_port_t,
238: ipc_port_t);
239:
240: int
241: vnode_pageout(
242: vnode_port_t,
243: vm_offset_t,
244: vm_offset_t,
245: int,
246: int *);
247:
248: int
249: vnode_pagein(
250: vnode_port_t,
251: vm_offset_t,
252: vm_offset_t,
253: int,
254: int *);
255:
256: zone_t vnode_pager_zone;
257:
258:
259: #define VNODE_PAGER_NULL ((vnode_pager_t) 0)
260:
261: /* TODO: Should be set dynamically by vnode_pager_init() */
262: #define CLUSTER_SHIFT 1
263:
264: /* TODO: Should be set dynamically by vnode_pager_bootstrap() */
265: #define MAX_VNODE 10000
266:
267:
268: #if DEBUG
269: int pagerdebug=0;
270:
271: #define PAGER_ALL 0xffffffff
272: #define PAGER_INIT 0x00000001
273: #define PAGER_PAGEIN 0x00000002
274:
275: #define PAGER_DEBUG(LEVEL, A) {if ((pagerdebug & LEVEL)==LEVEL){printf A;}}
276: #else
277: #define PAGER_DEBUG(LEVEL, A)
278: #endif
279:
280: /*
281: * Routine: macx_triggers
282: * Function:
283: * Syscall interface to set the call backs for low and
284: * high water marks.
285: */
286: int
287: macx_triggers(
288: int hi_water,
289: int low_water,
290: int flags,
291: mach_port_t trigger_name)
292: {
293: kern_return_t kr;
294: ipc_port_t default_pager_port = MACH_PORT_NULL;
295: ipc_port_t trigger_port;
296:
297: kr = host_default_memory_manager(realhost.host_priv_self,
298: &default_pager_port, 0);
299: if(kr != KERN_SUCCESS) {
300: return EINVAL;
301: }
302: trigger_port = trigger_name_to_port(trigger_name);
303: if(trigger_port == NULL) {
304: return EINVAL;
305: }
306: /* trigger_port is locked and active */
307: ip_unlock(trigger_port);
308: default_pager_triggers(default_pager_port,
309: hi_water, low_water, flags, trigger_port);
310: ipc_port_make_send(trigger_port);
311:
312: /*
313: * Set thread scheduling priority and policy for the current thread
314: * it is assumed for the time being that the thread setting the alert
315: * is the same one which will be servicing it.
316: */
317: {
318: struct policy_timeshare_base fifo_base;
319: struct policy_timeshare_limit fifo_limit;
320: policy_base_t base;
321: processor_set_t pset;
322: policy_limit_t limit;
323:
324: pset = (current_thread())->processor_set;
325: base = (policy_base_t) &fifo_base;
326: limit = (policy_limit_t) &fifo_limit;
327: fifo_base.base_priority = BASEPRI_KERNEL;
328: fifo_limit.max_priority = BASEPRI_KERNEL;
329: thread_set_policy((current_thread())->top_act, pset, POLICY_FIFO, base, POLICY_TIMESHARE_BASE_COUNT, limit, POLICY_TIMESHARE_LIMIT_COUNT);
330: }
331:
332: current_thread()->vm_privilege = TRUE;
333: }
334:
335: /*
336: *
337: */
338: ipc_port_t
339: trigger_name_to_port(
340: mach_port_t trigger_name)
341: {
342: ipc_port_t trigger_port;
343: ipc_space_t space;
344:
345: if (trigger_name == 0)
346: return (NULL);
347:
348: space = current_space();
349: if(ipc_port_translate_receive(space, (mach_port_name_t)trigger_name,
350: &trigger_port) != KERN_SUCCESS)
351: return (NULL);
352: return trigger_port;
353: }
354:
355: /*
356: *
357: */
358: void
359: vnode_pager_bootstrap(void)
360: {
361: register vm_size_t size;
362:
363: size = (vm_size_t) sizeof(struct vnode_pager);
364: vnode_pager_zone = zinit(size, (vm_size_t) MAX_VNODE*size,
365: PAGE_SIZE, "vnode pager structures");
366: vnode_port_hash_init();
367:
368: return;
369: }
370:
371: /*
372: *
373: */
374: ipc_port_t
375: vnode_pager_setup(
376: vnode_port_t vp,
377: ipc_port_t pager)
378: {
379: vnode_pager_t vnode_object;
380: kern_return_t kr;
381: ipc_port_t previous;
382:
383: if (pager &&
384: (vnode_object = vnode_port_hash_lookup(pager))) {
385: if (vnode_object->vnode_handle == vp)
386: return(pager);
387: }
388:
389: vnode_object = vnode_object_create(vp);
390: if (vnode_object == VNODE_PAGER_NULL)
391: panic("vnode_pager_setup: vnode_object_create() failed");
392:
393: vnode_object->pager = ipc_port_alloc_kernel();
394: assert (vnode_object->pager != IP_NULL);
395: pager_mux_hash_insert(vnode_object->pager,
396: (rpc_subsystem_t)&vnode_pager_workaround);
397:
398: vnode_object->pager_handle = ipc_port_make_send(vnode_object->pager);
399:
400: vnode_port_hash_insert(vnode_object->pager_handle, vnode_object);
401:
402: ipc_port_make_sonce(vnode_object->pager);
403: ip_lock(vnode_object->pager); /* unlocked in nsrequest below */
404: ipc_port_nsrequest(vnode_object->pager, 1, vnode_object->pager, &previous);
405:
406: PAGER_DEBUG(PAGER_INIT, ("vnode_pager_setup: vp %x pager %x vnode_pager %x\n", vp, vnode_object->pager_handle, vnode_object));
407:
408: vnode_pager_create( vp, vnode_object->pager_handle);
409: return(vnode_object->pager_handle);
410: }
411:
412: /*
413: *
414: */
415: ipc_port_t
416: vnode_pager_lookup(
417: vnode_port_t vp,
418: ipc_port_t pager)
419: {
420: vnode_pager_t vnode_object;
421: kern_return_t kr;
422:
423: if (pager &&
424: (vnode_object = vnode_port_hash_lookup(pager))) {
425: if (vnode_object->vnode_handle == vp)
426: return(vnode_object->vm_obj_handle);
427: else
428: return NULL;
429: }
430: else
431: return NULL;
432: }
433:
434: /*
435: *
436: */
437: kern_return_t
438: vnode_pager_init(ipc_port_t pager,
439: ipc_port_t pager_request,
440: vm_size_t pg_size)
441: {
442: vnode_pager_t vnode_object;
443: kern_return_t kr;
444: memory_object_attr_info_data_t attributes;
445: vm_object_t vm_object;
446:
447:
448: PAGER_DEBUG(PAGER_ALL, ("vnode_pager_init: %x, %x, %x\n", pager, pager_request, pg_size));
449:
450: vnode_object = vnode_port_hash_lookup(pager);
451: if (vnode_object == VNODE_PAGER_NULL)
452: panic("vnode_pager_init: lookup failed");
453:
454: vnode_object->vm_obj_handle = pager_request;
455:
456: vm_object = vm_object_lookup(pager_request);
457:
458: if (vm_object == VM_OBJECT_NULL)
459: panic("vnode_pager_init: vm_object_lookup() failed");
460:
461: attributes.copy_strategy = MEMORY_OBJECT_COPY_DELAY;
462: attributes.cluster_size = (1 << (CLUSTER_SHIFT + PAGE_SHIFT));
463: attributes.may_cache_object = TRUE;
464: attributes.temporary = TRUE;
465:
466: kr = memory_object_change_attributes(
467: vm_object,
468: MEMORY_OBJECT_ATTRIBUTE_INFO,
469: (memory_object_info_t) &attributes,
470: MEMORY_OBJECT_ATTR_INFO_COUNT,
471: MACH_PORT_NULL, 0);
472: if (kr != KERN_SUCCESS)
473: panic("vnode_pager_init: memory_object_change_attributes() failed");
474:
475: return(KERN_SUCCESS);
476: }
477:
478: /*
479: *
480: */
481: kern_return_t
482: vnode_pager_data_return(
483: ipc_port_t mem_obj,
484: ipc_port_t control_port,
485: vm_offset_t offset,
486: pointer_t addr,
487: vm_size_t data_cnt,
488: boolean_t dirty,
489: boolean_t kernel_copy)
490: {
491: register vnode_pager_t vnode_object;
492:
493: vnode_object = vnode_port_hash_lookup(mem_obj);
494: if (vnode_object == VNODE_PAGER_NULL)
495: panic("vnode_pager_data_return: lookup failed");
496:
497: vnode_pager_cluster_write(vnode_object, offset, data_cnt, (vm_object_t)control_port->ip_kobject);
498:
499: return KERN_SUCCESS;
500: }
501:
502: /*
503: *
504: */
505: kern_return_t
506: vnode_pager_data_request(
507: ipc_port_t mem_obj,
508: ipc_port_t mem_obj_control,
509: vm_offset_t offset,
510: vm_size_t length,
511: vm_prot_t protection_required)
512: {
513: register vnode_pager_t vnode_object;
514:
515: PAGER_DEBUG(PAGER_ALL, ("vnode_pager_data_request: %x, %x, %x, %x, %x\n", mem_obj, mem_obj_control, offset, length, protection_required));
516:
517: vnode_object = vnode_port_hash_lookup(mem_obj);
518:
519: PAGER_DEBUG(PAGER_PAGEIN, ("vnode_pager_data_request: %x, %x, %x, %x, %x, vnode_object %x\n", mem_obj, mem_obj_control, offset, length, protection_required, vnode_object));
520:
521: if (vnode_object == VNODE_PAGER_NULL)
522: panic("vnode_pager_data_request: lookup failed");
523:
524: vnode_pager_cluster_read(vnode_object, offset, length, (vm_object_t)mem_obj_control->ip_kobject);
525:
526: return KERN_SUCCESS;
527: }
528:
529: /*
530: *
531: */
532: void
533: vnode_pager_no_senders(
534: ipc_port_t mem_obj,
535: mach_port_mscount_t mscount)
536: {
537: register vnode_pager_t vnode_object;
538: boolean_t funnel_state;
539:
540: PAGER_DEBUG(PAGER_ALL, ("vnode_pager_nosenders: %x, %x\n", mem_obj, mscount));
541:
542: vnode_object = vnode_port_hash_lookup(mem_obj);
543: if (vnode_object == VNODE_PAGER_NULL)
544: panic("vnode_pager_no_senders: lookup failed");
545:
546: assert(vnode_object->pager_handle == mem_obj);
547:
548: pager_mux_hash_delete((ipc_port_t) vnode_object->pager_handle);
549: ipc_port_dealloc_kernel(vnode_object->pager);
550: vnode_port_hash_delete(vnode_object->pager_handle);
551: if (vnode_object->vnode_handle != (vnode_port_t) NULL) {
552: funnel_state = thread_set_funneled(TRUE);
553: vrele(vnode_object->vnode_handle);
554: (void) thread_set_funneled(funnel_state);
555: }
556: zfree(vnode_pager_zone, (vm_offset_t) vnode_object);
557:
558: return;
559: }
560:
561: /*
562: *
563: */
564: kern_return_t
565: vnode_pager_terminate(
566: ipc_port_t mem_obj,
567: ipc_port_t mem_obj_control)
568: {
569: register vnode_pager_t vnode_object;
570:
571: PAGER_DEBUG(PAGER_ALL, ("vnode_pager_terminate: %x, %x\n", mem_obj, mem_obj_control));
572:
573: vnode_object = vnode_port_hash_lookup(mem_obj);
574: if (vnode_object == VNODE_PAGER_NULL)
575: panic("vnode_pager_terminate: lookup failed");
576:
577: assert(vnode_object->pager_handle == mem_obj);
578:
579: /* release extra send right created by the fact that the caller */
580: /* of vnode_pager_setup does not establish a mapping between a */
581: /* cache object and the mem_obj (AMO). When a subsequent vm_map */
582: /* is done, vm_map will bump the send right count */
583: ipc_port_release_send(mem_obj);
584:
585: /* release a send right because terminate is called directly and */
586: /* not through IPC, the right won't disappear quietly */
587: ipc_port_release_send(mem_obj);
588:
589: ipc_port_dealloc_kernel(mem_obj_control);
590:
591: return(KERN_SUCCESS);
592: }
593:
594: /*
595: *
596: */
597: kern_return_t
598: vnode_pager_synchronize(
599: ipc_port_t pager,
600: ipc_port_t pager_request,
601: vm_offset_t offset,
602: vm_offset_t length,
603: vm_sync_t sync_flags)
604: {
605: memory_object_synchronize_completed(vm_object_lookup(pager_request), offset, length);
606:
607: return (KERN_SUCCESS);
608: }
609:
610: /*
611: *
612: */
613: void
614: vnode_pager_cluster_write(
615: vnode_pager_t vnode_object,
616: vm_offset_t offset,
617: vm_size_t cnt,
618: vm_object_t object)
619: {
620: vm_offset_t data;
621: upl_t page_list;
622: int error = 0;
623: int size;
624:
625: upl_system_list_request(object, offset,
626: cnt, cnt, &page_list, NULL, 0,
627: (UPL_CLEAN_IN_PLACE | UPL_NO_SYNC | UPL_COPYOUT_FROM));
628: upl_map(kernel_map, page_list, &data);
629:
630: error = vnode_pageout(
631: vnode_object->vnode_handle, data, offset, cnt, NULL);
632:
633: upl_un_map(kernel_map, page_list);
634: if (error == 0) {
635: upl_commit(page_list, NULL);
636: } else {
637: upl_abort(page_list, 0);
638: }
639:
640: return;
641: }
642:
643:
644: /*
645: *
646: */
647: kern_return_t
648: vnode_pager_cluster_read(
649: vnode_pager_t vnode_object,
650: vm_offset_t offset,
651: vm_size_t cnt,
652: vm_object_t object)
653: {
654: vm_offset_t buffer;
655: int error = 0;
656: int local_error = 0;
657: int kret;
658: int size;
659: upl_t page_list;
660: vm_offset_t base, orig_offset;
661: kern_return_t kr;
662:
663: size = PAGE_SIZE;
664: orig_offset = offset;
665: base = offset;
666:
667: kr = upl_system_list_request(object, offset,
668: cnt, cnt, &page_list, NULL, 0,
669: UPL_CLEAN_IN_PLACE | UPL_NO_SYNC);
670: if(kr != KERN_SUCCESS) {
671: panic("VNODE_PAGER_CLUSTER_READ: upl_system_list_request failed");
672: }
673: kr = upl_map(kernel_map, page_list, &buffer);
674: if(kr != KERN_SUCCESS) {
675: upl_abort(page_list, UPL_ABORT_RESTART);
676: return KERN_SUCCESS;
677: }
678:
679: while (cnt) {
680:
681: kret = vnode_pagein(vnode_object->vnode_handle, buffer, offset, size, &local_error);
682:
683: PAGER_DEBUG(PAGER_PAGEIN, ("vnode_pagein ret: vp %x, buf %x buf[0] %x\n", vnode_object->vnode_handle, buffer, *((int *)buffer)));
684:
685: if (local_error != 0) {
686: error = local_error;
687: local_error = 0;
688: if(offset > base) {
689: upl_un_map(kernel_map, page_list);
690: upl_commit_range(page_list, base - orig_offset,
691: offset - base, FALSE, NULL);
692: upl_map(kernel_map, page_list, &buffer);
693: }
694: base = offset+size;
695: }
696:
697: cnt -= size;
698: offset += size;
699: }
700:
701: if(error != 0) {
702: upl_un_map(kernel_map, page_list);
703: if(offset > base) {
704: upl_commit_range(page_list, base - orig_offset,
705: offset - base, FALSE, NULL);
706: }
707: upl_abort(page_list, UPL_ABORT_ERROR);
708: return(KERN_FAILURE);
709: }
710: upl_un_map(kernel_map, page_list);
711: upl_commit(page_list, NULL);
712:
713: return(KERN_SUCCESS);
714: }
715:
716:
717: /*
718: *
719: */
720: void
721: vnode_pager_release_from_cache(
722: int *cnt)
723: {
724: memory_object_free_from_cache(
725: &realhost, (int)&vnode_pager_workaround, cnt);
726: }
727:
728: /*
729: *
730: */
731: vnode_pager_t
732: vnode_object_create(
733: vnode_port_t vp)
734: {
735: register vnode_pager_t vnode_object;
736:
737: vnode_object = (struct vnode_pager *) zalloc(vnode_pager_zone);
738: if (vnode_object == VNODE_PAGER_NULL)
739: return(VNODE_PAGER_NULL);
740: vnode_object->pager_handle = IP_NULL;
741: vnode_object->vm_obj_handle = IP_NULL;
742: vnode_object->vnode_handle = vp;
743:
744: return(vnode_object);
745: }
746:
747: /*
748: *
749: */
750: void
751: vnode_port_hash_init(void)
752: {
753: register vm_size_t size;
754: register int i;
755:
756:
757: size = (vm_size_t) sizeof(struct vnode_port_entry);
758:
759: vnode_port_hash_zone = zinit(size,
760: (vm_size_t) MAX_VNODE * size,
761: PAGE_SIZE, "vnode_pager port hash");
762:
763: for (i = 0; i < VNODE_PORT_HASH_COUNT; i++)
764: queue_init(&vnode_port_hashtable[i]);
765:
766: simple_lock_init(&vnode_port_hash_lock,ETAP_NO_TRACE);
767: }
768:
769: /*
770: *
771: */
772: void
773: vnode_port_hash_insert(
774: ipc_port_t name_port,
775: vnode_pager_t rec)
776: {
777: register vnode_port_entry_t new_entry;
778:
779: new_entry = (vnode_port_entry_t) zalloc(vnode_port_hash_zone);
780: /*
781: * TODO: Delete the following check once MAX_VNODE is removed
782: */
783: if (!new_entry)
784: panic("vnode_port_hash_insert: no space");
785: new_entry->name = name_port;
786: new_entry->pager_rec = rec;
787:
788: simple_lock(&vnode_port_hash_lock);
789: queue_enter(&vnode_port_hashtable[vnode_port_hash(name_port)],
790: new_entry, vnode_port_entry_t, links);
791: simple_unlock(&vnode_port_hash_lock);
792: }
793:
794: /*
795: *
796: */
797: vnode_pager_t
798: vnode_port_hash_lookup(
799: ipc_port_t name_port)
800: {
801: register queue_t bucket;
802: register vnode_port_entry_t entry;
803: vnode_pager_t rec;
804:
805: bucket = (queue_t) &vnode_port_hashtable[vnode_port_hash(name_port)];
806:
807: simple_lock(&vnode_port_hash_lock);
808: entry = (vnode_port_entry_t) queue_first(bucket);
809: while (!queue_end(bucket,&entry->links)) {
810: if (entry->name == name_port) {
811: rec = entry->pager_rec;
812: simple_unlock(&vnode_port_hash_lock);
813: return(rec);
814: }
815: entry = (vnode_port_entry_t)queue_next(&entry->links);
816: }
817: simple_unlock(&vnode_port_hash_lock);
818: return(VNODE_PAGER_NULL);
819: }
820:
821: /*
822: *
823: */
824: void
825: vnode_port_hash_delete(
826: ipc_port_t name_port)
827: {
828: register queue_t bucket;
829: register vnode_port_entry_t entry;
830:
831: bucket = (queue_t) &vnode_port_hashtable[vnode_port_hash(name_port)];
832:
833: simple_lock(&vnode_port_hash_lock);
834: entry = (vnode_port_entry_t) queue_first(bucket);
835: while (!queue_end(bucket,&entry->links)) {
836: if (entry->name == name_port) {
837: queue_remove(bucket, entry, vnode_port_entry_t,links);
838: simple_unlock(&vnode_port_hash_lock);
839: zfree(vnode_port_hash_zone, (vm_offset_t) entry);
840: return;
841: }
842: entry = (vnode_port_entry_t)queue_next(&entry->links);
843: }
844: simple_unlock(&vnode_port_hash_lock);
845: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.