1 /* 2 * Copyright (c) 2016-2023 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 * Copyright (c) 1999 Michael Smith <[email protected]> 30 * All rights reserved. 31 * 32 * Redistribution and use in source and binary forms, with or without 33 * modification, are permitted provided that the following conditions 34 * are met: 35 * 1. Redistributions of source code must retain the above copyright 36 * notice, this list of conditions and the following disclaimer. 37 * 2. Redistributions in binary form must reproduce the above copyright 38 * notice, this list of conditions and the following disclaimer in the 39 * documentation and/or other materials provided with the distribution. 40 * 41 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 * 53 * $FreeBSD$ 54 */ 55 56 #ifndef _SYS_EVENTHANDLER_H_ 57 #define _SYS_EVENTHANDLER_H_ 58 59 #include <ptrauth.h> 60 61 #include <kern/locks.h> 62 #include <sys/queue.h> 63 #include <sys/cdefs.h> 64 #include <sys/syslog.h> 65 #include <uuid/uuid.h> 66 67 extern int evh_debug; 68 extern lck_grp_t el_lock_grp; 69 extern lck_attr_t el_lock_attr; 70 extern struct eventhandler_entry_arg eventhandler_entry_dummy_arg; 71 72 struct eventhandler_lists_ctxt { 73 TAILQ_HEAD(, eventhandler_list) eventhandler_lists; 74 int eventhandler_lists_initted; 75 decl_lck_mtx_data(, eventhandler_mutex); 76 }; 77 78 struct eventhandler_entry_arg { 79 uuid_t ee_fm_uuid; /* Flow manager UUID */ 80 uuid_t ee_fr_uuid; /* Flow route UUID */ 81 }; 82 83 struct eventhandler_entry { 84 TAILQ_ENTRY(eventhandler_entry) ee_link; 85 int ee_priority; 86 #define EHE_DEAD_PRIORITY (-1) 87 struct eventhandler_entry_arg ee_arg; 88 }; 89 90 #define EVENTHANDLER_MAX_NAME 32 91 92 struct eventhandler_list { 93 char el_name[EVENTHANDLER_MAX_NAME]; 94 int el_flags; 95 #define EHL_INITTED (1<<0) 96 u_int el_runcount; 97 decl_lck_mtx_data(, el_lock); 98 TAILQ_ENTRY(eventhandler_list) el_link; 99 TAILQ_HEAD(, eventhandler_entry) el_entries; 100 }; 101 102 typedef struct eventhandler_entry *eventhandler_tag; 103 104 #define EHL_LOCK_INIT(p) lck_mtx_init(&(p)->el_lock, &el_lock_grp, &el_lock_attr) 105 #define EHL_LOCK(p) lck_mtx_lock(&(p)->el_lock) 106 #define EHL_LOCK_SPIN(p) lck_mtx_lock_spin(&(p)->el_lock) 107 #define EHL_LOCK_CONVERT(p) lck_mtx_convert_spin(&(p)->el_lock) 108 #define EHL_UNLOCK(p) lck_mtx_unlock(&(p)->el_lock) 109 #define EHL_LOCK_ASSERT(p, x) LCK_MTX_ASSERT(&(p)->el_lock, x) 110 #define EHL_LOCK_DESTROY(p) lck_mtx_destroy(&(p)->el_lock, &el_lock_grp) 111 112 #define evhlog(type, ...) do { if (__improbable(evh_debug >= 1)) os_log_##type(OS_LOG_DEFAULT, __VA_ARGS__); } while (0) 113 #define evhlog2(type, ...) do { if (__improbable(evh_debug >= 2)) os_log_##type(OS_LOG_DEFAULT, __VA_ARGS__); } while (0) 114 115 /* 116 * Macro to invoke the handlers for a given event. 117 */ 118 #define _EVENTHANDLER_INVOKE(name, list, ...) do { \ 119 struct eventhandler_entry * _ep __single; \ 120 struct eventhandler_entry_ ## name * _t __single; \ 121 \ 122 VERIFY((list)->el_flags & EHL_INITTED); \ 123 EHL_LOCK_ASSERT((list), LCK_MTX_ASSERT_OWNED); \ 124 (list)->el_runcount++; \ 125 VERIFY((list)->el_runcount > 0); \ 126 evhlog2(debug, "eventhandler_invoke(\"" __STRING(name) "\")"); \ 127 TAILQ_FOREACH(_ep, &((list)->el_entries), ee_link) { \ 128 if (_ep->ee_priority != EHE_DEAD_PRIORITY) { \ 129 EHL_UNLOCK((list)); \ 130 _t = (struct eventhandler_entry_ ## name *)_ep; \ 131 evhlog2(debug, "eventhandler_invoke: executing %p", \ 132 (void *)VM_KERNEL_UNSLIDE((uint64_t)(_t->eh_func))); \ 133 _t->eh_func(_ep->ee_arg , ## __VA_ARGS__); \ 134 EHL_LOCK_SPIN((list)); \ 135 } \ 136 } \ 137 VERIFY((list)->el_runcount > 0); \ 138 (list)->el_runcount--; \ 139 if ((list)->el_runcount == 0) { \ 140 EHL_LOCK_CONVERT((list)); \ 141 eventhandler_prune_list(list); \ 142 } \ 143 EHL_UNLOCK((list)); \ 144 } while (0) 145 146 /* 147 * Slow handlers are entirely dynamic; lists are created 148 * when entries are added to them, and thus have no concept of "owner", 149 * 150 * Slow handlers need to be declared, but do not need to be defined. The 151 * declaration must be in scope wherever the handler is to be invoked. 152 */ 153 #define EVENTHANDLER_DECLARE(name, type) \ 154 struct eventhandler_entry_ ## name \ 155 { \ 156 struct eventhandler_entry ee; \ 157 type eh_func; \ 158 }; \ 159 struct __hack 160 161 /* 162 * XXX EVENTHANDLER_DEFINE by itself doesn't do much on XNU 163 * All it does is that it declares the static eventhandler_tag 164 * and defines an init routine that still needs to called to put the 165 * event and callback on the list. 166 */ 167 #define EVENTHANDLER_DEFINE(evthdlr_ref, name, func, arg, priority) \ 168 static eventhandler_tag name ## _tag; \ 169 static void name ## _evh_init(void *ctx) \ 170 { \ 171 name ## _tag = EVENTHANDLER_REGISTER(evthdlr_ref, name, func, ctx, \ 172 priority); \ 173 } \ 174 SYSINIT(name ## _evh_init, SI_SUB_CONFIGURE, SI_ORDER_ANY, \ 175 name ## _evh_init, arg); \ 176 struct __hack 177 178 #define EVENTHANDLER_INVOKE(evthdlr_ref, name, ...) \ 179 do { \ 180 struct eventhandler_list *__single _el; \ 181 \ 182 if ((_el = eventhandler_find_list(evthdlr_ref, #name)) != NULL) \ 183 _EVENTHANDLER_INVOKE(name, _el , ## __VA_ARGS__); \ 184 } while (0) 185 186 #define EVENTHANDLER_REGISTER(evthdlr_ref, name, func, arg, priority) \ 187 eventhandler_register(evthdlr_ref, NULL, #name, ptrauth_nop_cast(void * __single, func), arg, priority) 188 189 #define EVENTHANDLER_DEREGISTER(evthdlr_ref, name, tag) \ 190 do { \ 191 struct eventhandler_list *__single _el; \ 192 \ 193 if ((_el = eventhandler_find_list(evthdlr_ref, #name)) != NULL) \ 194 { \ 195 evhlog2(debug, "eventhandler_deregister event_type=" __STRING(name) ); \ 196 eventhandler_deregister(_el, tag); \ 197 } \ 198 } while(0) 199 200 void eventhandler_init(void); 201 eventhandler_tag eventhandler_register(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt, 202 struct eventhandler_list *list, const char *name, void *func, struct eventhandler_entry_arg arg, int priority); 203 void eventhandler_deregister(struct eventhandler_list *list, 204 eventhandler_tag tag); 205 struct eventhandler_list *eventhandler_find_list( 206 struct eventhandler_lists_ctxt *evthdlr_lists_ctxt, const char *name); 207 void eventhandler_prune_list(struct eventhandler_list *list); 208 void eventhandler_lists_ctxt_init(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt); 209 void eventhandler_lists_ctxt_destroy(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt); 210 211 /* Generic priority levels */ 212 #define EVENTHANDLER_PRI_FIRST 0 213 #define EVENTHANDLER_PRI_ANY 10000 214 #define EVENTHANDLER_PRI_LAST 20000 215 216 #endif /* _SYS_EVENTHANDLER_H_ */ 217