1/*
2 * Copyright (c) 2003-2009 Apple 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
29#include <mach/mach_types.h>
30#include <mach/mach_host.h>
31
32#include <kern/kern_types.h>
33#include <kern/ipc_kobject.h>
34#include <kern/host_notify.h>
35
36#include <kern/queue.h>
37
38#include "mach/host_notify_reply.h"
39
40decl_lck_mtx_data(,host_notify_lock)
41
42lck_mtx_ext_t host_notify_lock_ext;
43lck_grp_t host_notify_lock_grp;
44lck_attr_t host_notify_lock_attr;
45static lck_grp_attr_t host_notify_lock_grp_attr;
46static zone_t host_notify_zone;
47
48static queue_head_t host_notify_queue[HOST_NOTIFY_TYPE_MAX+1];
49
50static mach_msg_id_t host_notify_replyid[HOST_NOTIFY_TYPE_MAX+1] =
51 { HOST_CALENDAR_CHANGED_REPLYID,
52 HOST_CALENDAR_SET_REPLYID };
53
54struct host_notify_entry {
55 queue_chain_t entries;
56 ipc_port_t port;
57};
58
59typedef struct host_notify_entry *host_notify_t;
60
61void
62host_notify_init(void)
63{
64 int i;
65
66 for (i = 0; i <= HOST_NOTIFY_TYPE_MAX; i++)
67 queue_init(&host_notify_queue[i]);
68
69 lck_grp_attr_setdefault(&host_notify_lock_grp_attr);
70 lck_grp_init(&host_notify_lock_grp, "host_notify", &host_notify_lock_grp_attr);
71 lck_attr_setdefault(&host_notify_lock_attr);
72
73 lck_mtx_init_ext(&host_notify_lock, &host_notify_lock_ext, &host_notify_lock_grp, &host_notify_lock_attr);
74
75 i = sizeof (struct host_notify_entry);
76 host_notify_zone =
77 zinit(i, (4096 * i), (16 * i), "host_notify");
78}
79
80kern_return_t
81host_request_notification(
82 host_t host,
83 host_flavor_t notify_type,
84 ipc_port_t port)
85{
86 host_notify_t entry;
87
88 if (host == HOST_NULL)
89 return (KERN_INVALID_ARGUMENT);
90
91 if (!IP_VALID(port))
92 return (KERN_INVALID_CAPABILITY);
93
94 if (notify_type > HOST_NOTIFY_TYPE_MAX || notify_type < 0)
95 return (KERN_INVALID_ARGUMENT);
96
97 entry = (host_notify_t)zalloc(host_notify_zone);
98 if (entry == NULL)
99 return (KERN_RESOURCE_SHORTAGE);
100
101 lck_mtx_lock(&host_notify_lock);
102
103 ip_lock(port);
104 if (!ip_active(port) || port->ip_tempowner || ip_kotype(port) != IKOT_NONE) {
105 ip_unlock(port);
106
107 lck_mtx_unlock(&host_notify_lock);
108 zfree(host_notify_zone, entry);
109
110 return (KERN_FAILURE);
111 }
112
113 entry->port = port;
114 ipc_kobject_set_atomically(port, (ipc_kobject_t)entry, IKOT_HOST_NOTIFY);
115 ip_unlock(port);
116
117 enqueue_tail(&host_notify_queue[notify_type], (queue_entry_t)entry);
118 lck_mtx_unlock(&host_notify_lock);
119
120 return (KERN_SUCCESS);
121}
122
123void
124host_notify_port_destroy(
125 ipc_port_t port)
126{
127 host_notify_t entry;
128
129 lck_mtx_lock(&host_notify_lock);
130
131 ip_lock(port);
132 if (ip_kotype(port) == IKOT_HOST_NOTIFY) {
133 entry = (host_notify_t)port->ip_kobject;
134 assert(entry != NULL);
135 ipc_kobject_set_atomically(port, IKO_NULL, IKOT_NONE);
136 ip_unlock(port);
137
138 assert(entry->port == port);
139 remqueue((queue_entry_t)entry);
140 lck_mtx_unlock(&host_notify_lock);
141 zfree(host_notify_zone, entry);
142
143 ipc_port_release_sonce(port);
144 return;
145 }
146 ip_unlock(port);
147
148 lck_mtx_unlock(&host_notify_lock);
149}
150
151static void
152host_notify_all(
153 host_flavor_t notify_type,
154 mach_msg_header_t *msg,
155 mach_msg_size_t msg_size)
156{
157 queue_t notify_queue = &host_notify_queue[notify_type];
158
159 lck_mtx_lock(&host_notify_lock);
160
161 if (!queue_empty(notify_queue)) {
162 queue_head_t send_queue;
163 host_notify_t entry;
164
165 send_queue = *notify_queue;
166 queue_init(notify_queue);
167
168 send_queue.next->prev = &send_queue;
169 send_queue.prev->next = &send_queue;
170
171 msg->msgh_bits =
172 MACH_MSGH_BITS_SET(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0, 0, 0);
173 msg->msgh_local_port = MACH_PORT_NULL;
174 msg->msgh_voucher_port = MACH_PORT_NULL;
175 msg->msgh_id = host_notify_replyid[notify_type];
176
177 while ((entry = (host_notify_t)dequeue(&send_queue)) != NULL) {
178 ipc_port_t port;
179
180 port = entry->port;
181 assert(port != IP_NULL);
182
183 ip_lock(port);
184 assert(ip_kotype(port) == IKOT_HOST_NOTIFY);
185 assert(port->ip_kobject == (ipc_kobject_t)entry);
186 ipc_kobject_set_atomically(port, IKO_NULL, IKOT_NONE);
187 ip_unlock(port);
188
189 lck_mtx_unlock(&host_notify_lock);
190 zfree(host_notify_zone, entry);
191
192 msg->msgh_remote_port = port;
193
194 (void) mach_msg_send_from_kernel_proper(msg, msg_size);
195
196 lck_mtx_lock(&host_notify_lock);
197 }
198 }
199
200 lck_mtx_unlock(&host_notify_lock);
201}
202
203void
204host_notify_calendar_change(void)
205{
206 __Request__host_calendar_changed_t msg;
207
208 host_notify_all(HOST_NOTIFY_CALENDAR_CHANGE, &msg.Head, sizeof (msg));
209}
210
211void
212host_notify_calendar_set(void)
213{
214 __Request__host_calendar_set_t msg;
215
216 host_notify_all(HOST_NOTIFY_CALENDAR_SET, &msg.Head, sizeof (msg));
217}
218