xnu-7195.101.1.tar.gz

[apple/xnu.git] / bsd / sys / eventhandler.h

diff --git a/bsd/sys/eventhandler.h b/bsd/sys/eventhandler.h
index 794aa9acd3a98f66467d5b37c6a036501f836303..0f8ae79fc2af369b70e8cb13ebba7364103812e3 100644 (file)
--- a/bsd/sys/eventhandler.h
+++ b/bsd/sys/eventhandler.h
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2016-2017 Apple Inc. All rights reserved.
+ * Copyright (c) 2016-2018 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *


@@ -56,6 +56,8 @@
 #ifndef _SYS_EVENTHANDLER_H_
 #define _SYS_EVENTHANDLER_H_
 
 #ifndef _SYS_EVENTHANDLER_H_
 #define _SYS_EVENTHANDLER_H_
 

+#include <ptrauth.h>
+

 #include <kern/locks.h>
 #include <sys/queue.h>
 #include <sys/cdefs.h>
 #include <kern/locks.h>
 #include <sys/queue.h>
 #include <sys/cdefs.h>


@@ -63,8 +65,8 @@
 #include <uuid/uuid.h>
 
 extern int evh_debug;
 #include <uuid/uuid.h>
 
 extern int evh_debug;

-extern lck_grp_t        *el_lock_grp;
-extern lck_attr_t       *el_lock_attr;
+extern lck_grp_t        el_lock_grp;
+extern lck_attr_t       el_lock_attr;

 extern struct eventhandler_entry_arg eventhandler_entry_dummy_arg;
 
 struct eventhandler_lists_ctxt {
 extern struct eventhandler_entry_arg eventhandler_entry_dummy_arg;
 
 struct eventhandler_lists_ctxt {


@@ -74,81 +76,70 @@ struct eventhandler_lists_ctxt {
 };
 
 struct eventhandler_entry_arg {
 };
 
 struct eventhandler_entry_arg {

-       union {
-               /* Generic cookie object reference */
-               void            *ee_voidptr;
-               /* Skywalk ids */
-               struct {
-                       pid_t           ee_fe_pid;
-                       uuid_t          ee_fe_uuid;
-                       uuid_t          ee_nx_uuid;
-               } sk_ids;
-               /* Generic UUID */
-               uuid_t          ee_uuid;
-       } ee_arg;
+       uuid_t ee_fm_uuid;      /* Flow manager UUID */
+       uuid_t ee_fr_uuid;      /* Flow route UUID */

 };
 
 };
 

-#define        ee_voidptr      ee_arg.ee_voidptr
-#define        ee_fe_pid       ee_arg.sk_ids.ee_fe_pid
-#define        ee_fe_uuid      ee_arg.sk_ids.ee_fe_uuid
-#define        ee_nx_uuid      ee_arg.sk_ids.ee_nx_uuid
-#define        ee_uuid         ee_arg.ee_uuid
-

 struct eventhandler_entry {
 struct eventhandler_entry {

-       TAILQ_ENTRY(eventhandler_entry) ee_link;
-       int                             ee_priority;
-#define        EHE_DEAD_PRIORITY       (-1)
-       struct eventhandler_entry_arg   ee_arg;
+       TAILQ_ENTRY(eventhandler_entry) ee_link;
+       int                             ee_priority;
+#define EHE_DEAD_PRIORITY       (-1)
+       struct eventhandler_entry_arg   ee_arg;

 };
 
 };
 

+#define EVENTHANDLER_MAX_NAME   32
+

 struct eventhandler_list {
 struct eventhandler_list {

-       char                            *el_name;
-       int                             el_flags;
-#define EHL_INITTED    (1<<0)
-       u_int                           el_runcount;
+       char                            el_name[EVENTHANDLER_MAX_NAME];
+       int                             el_flags;
+#define EHL_INITTED     (1<<0)
+       u_int                           el_runcount;

        decl_lck_mtx_data(, el_lock);
        decl_lck_mtx_data(, el_lock);

-       TAILQ_ENTRY(eventhandler_list)  el_link;
-       TAILQ_HEAD(,eventhandler_entry) el_entries;
+       TAILQ_ENTRY(eventhandler_list)  el_link;
+       TAILQ_HEAD(, eventhandler_entry) el_entries;

 };
 
 };
 

-typedef struct eventhandler_entry      *eventhandler_tag;
+typedef struct eventhandler_entry       *eventhandler_tag;

 
 

-#define EHL_LOCK_INIT(p)       lck_mtx_init(&(p)->el_lock, el_lock_grp, el_lock_attr)
-#define        EHL_LOCK(p)             lck_mtx_lock(&(p)->el_lock)
-#define        EHL_UNLOCK(p)           lck_mtx_unlock(&(p)->el_lock)
-#define        EHL_LOCK_ASSERT(p, x)   LCK_MTX_ASSERT(&(p)->el_lock, x)
-#define        EHL_LOCK_DESTROY(p)     lck_mtx_destroy(&(p)->el_lock, el_lock_grp)
+#define EHL_LOCK_INIT(p)        lck_mtx_init(&(p)->el_lock, &el_lock_grp, &el_lock_attr)
+#define EHL_LOCK(p)             lck_mtx_lock(&(p)->el_lock)
+#define EHL_LOCK_SPIN(p)        lck_mtx_lock_spin(&(p)->el_lock)
+#define EHL_LOCK_CONVERT(p)     lck_mtx_convert_spin(&(p)->el_lock)
+#define EHL_UNLOCK(p)           lck_mtx_unlock(&(p)->el_lock)
+#define EHL_LOCK_ASSERT(p, x)   LCK_MTX_ASSERT(&(p)->el_lock, x)
+#define EHL_LOCK_DESTROY(p)     lck_mtx_destroy(&(p)->el_lock, &el_lock_grp)

 
 #define evhlog(x)       do { if (evh_debug >= 1) log x; } while (0)
 
 /*
  * Macro to invoke the handlers for a given event.
  */
 
 #define evhlog(x)       do { if (evh_debug >= 1) log x; } while (0)
 
 /*
  * Macro to invoke the handlers for a given event.
  */

-#define _EVENTHANDLER_INVOKE(name, list, ...) do {                     \
-       struct eventhandler_entry *_ep;                                 \
-       struct eventhandler_entry_ ## name *_t;                         \
-                                                                       \
-       VERIFY((list)->el_flags & EHL_INITTED);                         \
-       EHL_LOCK_ASSERT((list), LCK_MTX_ASSERT_OWNED);                  \
-       (list)->el_runcount++;                                          \
-       VERIFY((list)->el_runcount > 0);                                \
-       evhlog((LOG_DEBUG, "eventhandler_invoke(\"" __STRING(name) "\")"));     \
-       TAILQ_FOREACH(_ep, &((list)->el_entries), ee_link) {            \
-               if (_ep->ee_priority != EHE_DEAD_PRIORITY) {            \
-                       EHL_UNLOCK((list));                             \
-                       _t = (struct eventhandler_entry_ ## name *)_ep; \
-                       evhlog((LOG_DEBUG, "eventhandler_invoke: executing %p", \
-                           VM_KERNEL_UNSLIDE((void *)_t->eh_func)));   \
-                       _t->eh_func(_ep->ee_arg , ## __VA_ARGS__);      \
-                       EHL_LOCK((list));                               \
-               }                                                       \
-       }                                                               \
-       KASSERT((list)->el_runcount > 0,                                \
-           ("eventhandler_invoke: runcount underflow"));               \
-       (list)->el_runcount--;                                          \
-       if ((list)->el_runcount == 0)                                   \
-               eventhandler_prune_list(list);                          \
-       EHL_UNLOCK((list));                                             \
+#define _EVENTHANDLER_INVOKE(name, list, ...) do {                      \
+       struct eventhandler_entry *_ep;                                 \
+       struct eventhandler_entry_ ## name *_t;                         \
+                                                                        \
+       VERIFY((list)->el_flags & EHL_INITTED);                         \
+       EHL_LOCK_ASSERT((list), LCK_MTX_ASSERT_OWNED);                  \
+       (list)->el_runcount++;                                          \
+       VERIFY((list)->el_runcount > 0);                                \
+       evhlog((LOG_DEBUG, "eventhandler_invoke(\"" __STRING(name) "\")"));     \
+       TAILQ_FOREACH(_ep, &((list)->el_entries), ee_link) {            \
+               if (_ep->ee_priority != EHE_DEAD_PRIORITY) {            \
+                       EHL_UNLOCK((list));                             \
+                       _t = (struct eventhandler_entry_ ## name *)_ep; \
+                       evhlog((LOG_DEBUG, "eventhandler_invoke: executing %p", \
+                           (void *)VM_KERNEL_UNSLIDE((void *)_t->eh_func)));   \
+                       _t->eh_func(_ep->ee_arg , ## __VA_ARGS__);      \
+                       EHL_LOCK_SPIN((list));                          \
+               }                                                       \
+       }                                                               \
+       VERIFY((list)->el_runcount > 0);                                \
+       (list)->el_runcount--;                                          \
+       if ((list)->el_runcount == 0) {                                 \
+               EHL_LOCK_CONVERT((list));                               \
+               eventhandler_prune_list(list);                          \
+       }                                                               \
+       EHL_UNLOCK((list));                                             \

 } while (0)
 
 /*
 } while (0)
 
 /*


@@ -158,64 +149,65 @@ typedef struct eventhandler_entry *eventhandler_tag;
  * Slow handlers need to be declared, but do not need to be defined. The
  * declaration must be in scope wherever the handler is to be invoked.
  */
  * Slow handlers need to be declared, but do not need to be defined. The
  * declaration must be in scope wherever the handler is to be invoked.
  */

-#define EVENTHANDLER_DECLARE(name, type)                               \
-struct eventhandler_entry_ ## name                                     \
-{                                                                      \
-       struct eventhandler_entry       ee;                             \
-       type                            eh_func;                        \
-};                                                                     \
+#define EVENTHANDLER_DECLARE(name, type)                                \
+struct eventhandler_entry_ ## name                                      \
+{                                                                       \
+       struct eventhandler_entry       ee;                             \
+       type                            eh_func;                        \
+};                                                                      \

 struct __hack
 
 /*
  * XXX EVENTHANDLER_DEFINE by itself doesn't do much on XNU
 struct __hack
 
 /*
  * XXX EVENTHANDLER_DEFINE by itself doesn't do much on XNU

- * All it does is that it declares the static eventhandler_tag 
+ * All it does is that it declares the static eventhandler_tag

  * and defines an init routine that still needs to called to put the
  * event and callback on the list.
  * and defines an init routine that still needs to called to put the
  * event and callback on the list.

- */ 
-#define EVENTHANDLER_DEFINE(evthdlr_ref, name, func, arg, priority)                    \
-       static eventhandler_tag name ## _tag;                           \
-       static void name ## _evh_init(void *ctx)                        \
-       {                                                               \
-               name ## _tag = EVENTHANDLER_REGISTER(evthdlr_ref, name, func, ctx,      \
-                   priority);                                          \
-       }                                                               \
-       SYSINIT(name ## _evh_init, SI_SUB_CONFIGURE, SI_ORDER_ANY,      \
-           name ## _evh_init, arg);                                    \
+ */
+#define EVENTHANDLER_DEFINE(evthdlr_ref, name, func, arg, priority)                     \
+       static eventhandler_tag name ## _tag;                           \
+       static void name ## _evh_init(void *ctx)                        \
+       {                                                               \
+               name ## _tag = EVENTHANDLER_REGISTER(evthdlr_ref, name, func, ctx,      \
+                   priority);                                          \
+       }                                                               \
+       SYSINIT(name ## _evh_init, SI_SUB_CONFIGURE, SI_ORDER_ANY,      \
+           name ## _evh_init, arg);                                    \

        struct __hack
 
        struct __hack
 

-#define EVENTHANDLER_INVOKE(evthdlr_ref, name, ...)                                    \
-do {                                                                   \
-       struct eventhandler_list *_el;                                  \
-                                                                       \
-       if ((_el = eventhandler_find_list(evthdlr_ref, #name)) != NULL)                 \
-               _EVENTHANDLER_INVOKE(name, _el , ## __VA_ARGS__);       \
+#define EVENTHANDLER_INVOKE(evthdlr_ref, name, ...)                                     \
+do {                                                                    \
+       struct eventhandler_list *_el;                                  \
+                                                                        \
+       if ((_el = eventhandler_find_list(evthdlr_ref, #name)) != NULL)                 \
+               _EVENTHANDLER_INVOKE(name, _el , ## __VA_ARGS__);       \

 } while (0)
 
 } while (0)
 

-#define EVENTHANDLER_REGISTER(evthdlr_ref, name, func, arg, priority)          \
-       eventhandler_register(evthdlr_ref, NULL, #name, func, arg, priority)
+#define EVENTHANDLER_REGISTER(evthdlr_ref, name, func, arg, priority)           \
+       eventhandler_register(evthdlr_ref, NULL, #name, ptrauth_nop_cast(void *, &func), arg, priority)

 
 

-#define EVENTHANDLER_DEREGISTER(evthdlr_ref, name, tag)                                \
-do {                                                                   \
-       struct eventhandler_list *_el;                                  \
-                                                                       \
-       if ((_el = eventhandler_find_list(evthdlr_ref, #name)) != NULL)         \
-               eventhandler_deregister(_el, tag);                      \
+#define EVENTHANDLER_DEREGISTER(evthdlr_ref, name, tag)                                 \
+do {                                                                    \
+       struct eventhandler_list *_el;                                  \
+                                                                        \
+       if ((_el = eventhandler_find_list(evthdlr_ref, #name)) != NULL)         \
+               eventhandler_deregister(_el, tag);                      \

 } while(0)
 
 void eventhandler_init(void);
 } while(0)
 
 void eventhandler_init(void);

+extern void eventhandler_reap_caches(boolean_t);

 eventhandler_tag eventhandler_register(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt,
     struct eventhandler_list *list, const char *name, void *func, struct eventhandler_entry_arg arg, int priority);
 void eventhandler_deregister(struct eventhandler_list *list,
     eventhandler_tag tag);
 struct eventhandler_list *eventhandler_find_list(
 eventhandler_tag eventhandler_register(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt,
     struct eventhandler_list *list, const char *name, void *func, struct eventhandler_entry_arg arg, int priority);
 void eventhandler_deregister(struct eventhandler_list *list,
     eventhandler_tag tag);
 struct eventhandler_list *eventhandler_find_list(

-    struct eventhandler_lists_ctxt *evthdlr_lists_ctxt, const char *name);
+       struct eventhandler_lists_ctxt *evthdlr_lists_ctxt, const char *name);

 void eventhandler_prune_list(struct eventhandler_list *list);
 void eventhandler_lists_ctxt_init(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt);
 void eventhandler_lists_ctxt_destroy(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt);
 
 /* Generic priority levels */
 void eventhandler_prune_list(struct eventhandler_list *list);
 void eventhandler_lists_ctxt_init(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt);
 void eventhandler_lists_ctxt_destroy(struct eventhandler_lists_ctxt *evthdlr_lists_ctxt);
 
 /* Generic priority levels */

-#define        EVENTHANDLER_PRI_FIRST  0
-#define        EVENTHANDLER_PRI_ANY    10000
-#define        EVENTHANDLER_PRI_LAST   20000
+#define EVENTHANDLER_PRI_FIRST  0
+#define EVENTHANDLER_PRI_ANY    10000
+#define EVENTHANDLER_PRI_LAST   20000

 
 #endif /* _SYS_EVENTHANDLER_H_ */
 
 #endif /* _SYS_EVENTHANDLER_H_ */