2 * Copyright (c) 2003-2009 Apple Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
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.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
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.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
29 #include <mach/mach_types.h>
30 #include <mach/mach_host.h>
32 #include <kern/kern_types.h>
33 #include <kern/ipc_kobject.h>
34 #include <kern/host_notify.h>
36 #include <kern/queue.h>
38 #include "mach/host_notify_reply.h"
40 decl_lck_mtx_data(,host_notify_lock
)
42 lck_mtx_ext_t host_notify_lock_ext
;
43 lck_grp_t host_notify_lock_grp
;
44 lck_attr_t host_notify_lock_attr
;
45 static lck_grp_attr_t host_notify_lock_grp_attr
;
46 static zone_t host_notify_zone
;
48 static queue_head_t host_notify_queue
[HOST_NOTIFY_TYPE_MAX
+1];
50 static mach_msg_id_t host_notify_replyid
[HOST_NOTIFY_TYPE_MAX
+1] =
51 { HOST_CALENDAR_CHANGED_REPLYID
};
53 struct host_notify_entry
{
54 queue_chain_t entries
;
58 typedef struct host_notify_entry
*host_notify_t
;
61 host_notify_init(void)
65 for (i
= 0; i
<= HOST_NOTIFY_TYPE_MAX
; i
++)
66 queue_init(&host_notify_queue
[i
]);
68 lck_grp_attr_setdefault(&host_notify_lock_grp_attr
);
69 lck_grp_init(&host_notify_lock_grp
, "host_notify", &host_notify_lock_grp_attr
);
70 lck_attr_setdefault(&host_notify_lock_attr
);
72 lck_mtx_init_ext(&host_notify_lock
, &host_notify_lock_ext
, &host_notify_lock_grp
, &host_notify_lock_attr
);
74 i
= sizeof (struct host_notify_entry
);
76 zinit(i
, (4096 * i
), (16 * i
), "host_notify");
80 host_request_notification(
82 host_flavor_t notify_type
,
87 if (host
== HOST_NULL
)
88 return (KERN_INVALID_ARGUMENT
);
91 return (KERN_INVALID_CAPABILITY
);
93 if (notify_type
> HOST_NOTIFY_TYPE_MAX
|| notify_type
< 0)
94 return (KERN_INVALID_ARGUMENT
);
96 entry
= (host_notify_t
)zalloc(host_notify_zone
);
98 return (KERN_RESOURCE_SHORTAGE
);
100 lck_mtx_lock(&host_notify_lock
);
103 if (!ip_active(port
) || ip_kotype(port
) != IKOT_NONE
) {
106 lck_mtx_unlock(&host_notify_lock
);
107 zfree(host_notify_zone
, entry
);
109 return (KERN_FAILURE
);
113 ipc_kobject_set_atomically(port
, (ipc_kobject_t
)entry
, IKOT_HOST_NOTIFY
);
116 enqueue_tail(&host_notify_queue
[notify_type
], (queue_entry_t
)entry
);
117 lck_mtx_unlock(&host_notify_lock
);
119 return (KERN_SUCCESS
);
123 host_notify_port_destroy(
128 lck_mtx_lock(&host_notify_lock
);
131 if (ip_kotype(port
) == IKOT_HOST_NOTIFY
) {
132 entry
= (host_notify_t
)port
->ip_kobject
;
133 assert(entry
!= NULL
);
134 ipc_kobject_set_atomically(port
, IKO_NULL
, IKOT_NONE
);
137 assert(entry
->port
== port
);
138 remqueue((queue_entry_t
)entry
);
139 lck_mtx_unlock(&host_notify_lock
);
140 zfree(host_notify_zone
, entry
);
142 ipc_port_release_sonce(port
);
147 lck_mtx_unlock(&host_notify_lock
);
152 host_flavor_t notify_type
,
153 mach_msg_header_t
*msg
,
154 mach_msg_size_t msg_size
)
156 queue_t notify_queue
= &host_notify_queue
[notify_type
];
158 lck_mtx_lock(&host_notify_lock
);
160 if (!queue_empty(notify_queue
)) {
161 queue_head_t send_queue
;
164 send_queue
= *notify_queue
;
165 queue_init(notify_queue
);
167 send_queue
.next
->prev
= &send_queue
;
168 send_queue
.prev
->next
= &send_queue
;
170 msg
->msgh_bits
= MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE
, 0);
171 msg
->msgh_local_port
= MACH_PORT_NULL
;
172 msg
->msgh_id
= host_notify_replyid
[notify_type
];
173 msg
->msgh_reserved
= 0;
175 while ((entry
= (host_notify_t
)dequeue(&send_queue
)) != NULL
) {
179 assert(port
!= IP_NULL
);
182 assert(ip_kotype(port
) == IKOT_HOST_NOTIFY
);
183 assert(port
->ip_kobject
== (ipc_kobject_t
)entry
);
184 ipc_kobject_set_atomically(port
, IKO_NULL
, IKOT_NONE
);
187 lck_mtx_unlock(&host_notify_lock
);
188 zfree(host_notify_zone
, entry
);
190 msg
->msgh_remote_port
= port
;
192 (void) mach_msg_send_from_kernel_proper(msg
, msg_size
);
194 lck_mtx_lock(&host_notify_lock
);
198 lck_mtx_unlock(&host_notify_lock
);
202 host_notify_calendar_change(void)
204 __Request__host_calendar_changed_t msg
;
206 host_notify_all(HOST_NOTIFY_CALENDAR_CHANGE
, &msg
.Head
, sizeof (msg
));