Change Details

diff --git a/sys/cddl/contrib/opensolaris/uts/common/dtrace/fasttrap.c b/sys/cddl/contrib/opensolaris/uts/common/dtrace/fasttrap.c index 82353cbb235..a5b667b52b4 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/dtrace/fasttrap.c +++ b/sys/cddl/contrib/opensolaris/uts/common/dtrace/fasttrap.c @@ -2530,7 +2530,7 @@ fasttrap_load(void) * This event handler must run before kdtrace_thread_dtor() since it * accesses the thread's struct kdtrace_thread. */ - fasttrap_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor, + fasttrap_thread_dtor_tag = EVENTHANDLER_STATIC_REGISTER(thread_dtor, fasttrap_thread_dtor, NULL, EVENTHANDLER_PRI_FIRST); #endif @@ -2633,7 +2633,7 @@ fasttrap_unload(void) #endif #ifndef illumos - EVENTHANDLER_DEREGISTER(thread_dtor, fasttrap_thread_dtor_tag); + EVENTHANDLER_STATIC_DEREGISTER(thread_dtor, fasttrap_thread_dtor_tag); for (i = 0; i < fasttrap_tpoints.fth_nent; i++) mutex_destroy(&fasttrap_tpoints.fth_table[i].ftb_mtx); diff --git a/sys/compat/linux/linux_common.c b/sys/compat/linux/linux_common.c index b9e35311bdf..96af7221e3e 100644 --- a/sys/compat/linux/linux_common.c +++ b/sys/compat/linux/linux_common.c @@ -61,11 +61,12 @@ linux_common_modevent(module_t mod, int type, void *data) switch(type) { case MOD_LOAD: linux_osd_jail_register(); - linux_exit_tag = EVENTHANDLER_REGISTER(process_exit, + linux_exit_tag = EVENTHANDLER_STATIC_REGISTER(process_exit, linux_proc_exit, NULL, 1000); - linux_exec_tag = EVENTHANDLER_REGISTER(process_exec, + linux_exec_tag = EVENTHANDLER_STATIC_REGISTER(process_exec, linux_proc_exec, NULL, 1000); - linux_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor, + linux_thread_dtor_tag = + EVENTHANDLER_STATIC_REGISTER(thread_dtor, linux_thread_dtor, NULL, EVENTHANDLER_PRI_ANY); SET_FOREACH(ldhp, linux_device_handler_set) linux_device_register_handler(*ldhp); @@ -74,9 +75,10 @@ linux_common_modevent(module_t mod, int type, void *data) linux_osd_jail_deregister(); SET_FOREACH(ldhp, linux_device_handler_set) linux_device_unregister_handler(*ldhp); - EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag); - EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag); - EVENTHANDLER_DEREGISTER(thread_dtor, linux_thread_dtor_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exit, linux_exit_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exec, linux_exec_tag); + EVENTHANDLER_STATIC_DEREGISTER(thread_dtor, + linux_thread_dtor_tag); break; default: return (EOPNOTSUPP); diff --git a/sys/compat/linuxkpi/common/src/linux_current.c b/sys/compat/linuxkpi/common/src/linux_current.c index 331f6e2d2b7..48da75f261c 100644 --- a/sys/compat/linuxkpi/common/src/linux_current.c +++ b/sys/compat/linuxkpi/common/src/linux_current.c @@ -218,7 +218,7 @@ linux_get_pid_task(pid_t pid) static void linux_current_init(void *arg __unused) { - linuxkpi_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor, + linuxkpi_thread_dtor_tag = EVENTHANDLER_STATIC_REGISTER(thread_dtor, linuxkpi_thread_dtor, NULL, EVENTHANDLER_PRI_ANY); } SYSINIT(linux_current, SI_SUB_EVENTHANDLER, SI_ORDER_SECOND, linux_current_init, NULL); @@ -243,6 +243,6 @@ linux_current_uninit(void *arg __unused) } sx_sunlock(&allproc_lock); - EVENTHANDLER_DEREGISTER(thread_dtor, linuxkpi_thread_dtor_tag); + EVENTHANDLER_STATIC_DEREGISTER(thread_dtor, linuxkpi_thread_dtor_tag); } SYSUNINIT(linux_current, SI_SUB_EVENTHANDLER, SI_ORDER_SECOND, linux_current_uninit, NULL); diff --git a/sys/dev/filemon/filemon_wrapper.c b/sys/dev/filemon/filemon_wrapper.c index 6c71d27a767..cb46eec3911 100644 --- a/sys/dev/filemon/filemon_wrapper.c +++ b/sys/dev/filemon/filemon_wrapper.c @@ -436,11 +436,11 @@ filemon_wrapper_install(void) freebsd32_sysent[FREEBSD32_SYS_linkat].sy_call = (sy_call_t *) filemon_wrapper_linkat; #endif /* COMPAT_FREEBSD32 */ - filemon_exec_tag = EVENTHANDLER_REGISTER(process_exec, + filemon_exec_tag = EVENTHANDLER_STATIC_REGISTER(process_exec, filemon_event_process_exec, NULL, EVENTHANDLER_PRI_LAST); - filemon_exit_tag = EVENTHANDLER_REGISTER(process_exit, + filemon_exit_tag = EVENTHANDLER_STATIC_REGISTER(process_exit, filemon_event_process_exit, NULL, EVENTHANDLER_PRI_LAST); - filemon_fork_tag = EVENTHANDLER_REGISTER(process_fork, + filemon_fork_tag = EVENTHANDLER_STATIC_REGISTER(process_fork, filemon_event_process_fork, NULL, EVENTHANDLER_PRI_LAST); } @@ -468,7 +468,7 @@ filemon_wrapper_deinstall(void) freebsd32_sysent[FREEBSD32_SYS_linkat].sy_call = (sy_call_t *)sys_linkat; #endif /* COMPAT_FREEBSD32 */ - EVENTHANDLER_DEREGISTER(process_exec, filemon_exec_tag); - EVENTHANDLER_DEREGISTER(process_exit, filemon_exit_tag); - EVENTHANDLER_DEREGISTER(process_fork, filemon_fork_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exec, filemon_exec_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exit, filemon_exit_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_fork, filemon_fork_tag); } diff --git a/sys/dev/hwpmc/hwpmc_mod.c b/sys/dev/hwpmc/hwpmc_mod.c index 821617138ec..0cb49eb4285 100644 --- a/sys/dev/hwpmc/hwpmc_mod.c +++ b/sys/dev/hwpmc/hwpmc_mod.c @@ -4993,9 +4993,9 @@ pmc_initialize(void) pmc_processhash, pmc_processhashmask); /* register process {exit,fork,exec} handlers */ - pmc_exit_tag = EVENTHANDLER_REGISTER(process_exit, + pmc_exit_tag = EVENTHANDLER_STATIC_REGISTER(process_exit, pmc_process_exit, NULL, EVENTHANDLER_PRI_ANY); - pmc_fork_tag = EVENTHANDLER_REGISTER(process_fork, + pmc_fork_tag = EVENTHANDLER_STATIC_REGISTER(process_fork, pmc_process_fork, NULL, EVENTHANDLER_PRI_ANY); /* register kld event handlers */ @@ -5059,8 +5059,8 @@ pmc_cleanup(void) pmc_hook = NULL; /* prevent new threads from entering module */ /* deregister event handlers */ - EVENTHANDLER_DEREGISTER(process_fork, pmc_fork_tag); - EVENTHANDLER_DEREGISTER(process_exit, pmc_exit_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_fork, pmc_fork_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exit, pmc_exit_tag); EVENTHANDLER_DEREGISTER(kld_load, pmc_kld_load_tag); EVENTHANDLER_DEREGISTER(kld_unload, pmc_kld_unload_tag); diff --git a/sys/fs/pseudofs/pseudofs_vncache.c b/sys/fs/pseudofs/pseudofs_vncache.c index 093d80565ea..5fb23511256 100644 --- a/sys/fs/pseudofs/pseudofs_vncache.c +++ b/sys/fs/pseudofs/pseudofs_vncache.c @@ -86,8 +86,8 @@ pfs_vncache_load(void) { mtx_init(&pfs_vncache_mutex, "pfs_vncache", NULL, MTX_DEF); - pfs_exit_tag = EVENTHANDLER_REGISTER(process_exit, pfs_exit, NULL, - EVENTHANDLER_PRI_ANY); + pfs_exit_tag = EVENTHANDLER_STATIC_REGISTER(process_exit, pfs_exit, + NULL, EVENTHANDLER_PRI_ANY); } /* @@ -97,7 +97,7 @@ void pfs_vncache_unload(void) { - EVENTHANDLER_DEREGISTER(process_exit, pfs_exit_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exit, pfs_exit_tag); mtx_lock(&pfs_vncache_mutex); pfs_purge_locked(NULL, true); mtx_unlock(&pfs_vncache_mutex); diff --git a/sys/i386/linux/linux_sysvec.c b/sys/i386/linux/linux_sysvec.c index 422645b67dc..d0c466089f4 100644 --- a/sys/i386/linux/linux_sysvec.c +++ b/sys/i386/linux/linux_sysvec.c @@ -1159,11 +1159,11 @@ linux_elf_modevent(module_t mod, int type, void *data) linux_ioctl_register_handler(*lihp); LIST_INIT(&futex_list); mtx_init(&futex_mtx, "ftllk", NULL, MTX_DEF); - linux_exit_tag = EVENTHANDLER_REGISTER(process_exit, linux_proc_exit, - NULL, 1000); - linux_exec_tag = EVENTHANDLER_REGISTER(process_exec, linux_proc_exec, - NULL, 1000); - linux_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor, + linux_exit_tag = EVENTHANDLER_STATIC_REGISTER(process_exit, + linux_proc_exit, NULL, 1000); + linux_exec_tag = EVENTHANDLER_STATIC_REGISTER(process_exec, + linux_proc_exec, NULL, 1000); + linux_thread_dtor_tag = EVENTHANDLER_STATIC_REGISTER(thread_dtor, linux_thread_dtor, NULL, EVENTHANDLER_PRI_ANY); linux_get_machine(&linux_kplatform); linux_szplatform = roundup(strlen(linux_kplatform) + 1, @@ -1190,9 +1190,9 @@ linux_elf_modevent(module_t mod, int type, void *data) SET_FOREACH(lihp, linux_ioctl_handler_set) linux_ioctl_unregister_handler(*lihp); mtx_destroy(&futex_mtx); - EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag); - EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag); - EVENTHANDLER_DEREGISTER(thread_dtor, linux_thread_dtor_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exit, linux_exit_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exec, linux_exec_tag); + EVENTHANDLER_STATIC_DEREGISTER(thread_dtor, linux_thread_dtor_tag); linux_osd_jail_deregister(); if (bootverbose) printf("Linux ELF exec handler removed\n"); diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c index f71ba6efaf5..3bb0becb9c9 100644 --- a/sys/kern/init_main.c +++ b/sys/kern/init_main.c @@ -569,10 +569,10 @@ proc0_init(void *dummy __unused) * Call the init and ctor for the new thread and proc. We wait * to do this until all other structures are fairly sane. */ - EVENTHANDLER_INVOKE(process_init, p); - EVENTHANDLER_INVOKE(thread_init, td); - EVENTHANDLER_INVOKE(process_ctor, p); - EVENTHANDLER_INVOKE(thread_ctor, td); + EVENTHANDLER_STATIC_INVOKE(process_init, p); + EVENTHANDLER_STATIC_INVOKE(thread_init, td); + EVENTHANDLER_STATIC_INVOKE(process_ctor, p); + EVENTHANDLER_STATIC_INVOKE(thread_ctor, td); /* * Charge root for one process. diff --git a/sys/kern/kern_dtrace.c b/sys/kern/kern_dtrace.c index adc36a8e3a8..acdc454aa49 100644 --- a/sys/kern/kern_dtrace.c +++ b/sys/kern/kern_dtrace.c @@ -113,13 +113,13 @@ static void init_dtrace(void *dummy __unused) { - EVENTHANDLER_REGISTER(process_ctor, kdtrace_proc_ctor, NULL, + EVENTHANDLER_STATIC_REGISTER(process_ctor, kdtrace_proc_ctor, NULL, EVENTHANDLER_PRI_ANY); - EVENTHANDLER_REGISTER(process_dtor, kdtrace_proc_dtor, NULL, + EVENTHANDLER_STATIC_REGISTER(process_dtor, kdtrace_proc_dtor, NULL, EVENTHANDLER_PRI_ANY); - EVENTHANDLER_REGISTER(thread_ctor, kdtrace_thread_ctor, NULL, + EVENTHANDLER_STATIC_REGISTER(thread_ctor, kdtrace_thread_ctor, NULL, EVENTHANDLER_PRI_ANY); - EVENTHANDLER_REGISTER(thread_dtor, kdtrace_thread_dtor, NULL, + EVENTHANDLER_STATIC_REGISTER(thread_dtor, kdtrace_thread_dtor, NULL, EVENTHANDLER_PRI_ANY); } diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c index 953da2d908a..70fa5f1577c 100644 --- a/sys/kern/kern_exec.c +++ b/sys/kern/kern_exec.c @@ -1074,7 +1074,7 @@ exec_new_vmspace(struct image_params *imgp, struct sysentvec *sv) imgp->sysent = sv; /* May be called with Giant held */ - EVENTHANDLER_INVOKE(process_exec, p, imgp); + EVENTHANDLER_STATIC_INVOKE(process_exec, p, imgp); /* * Blow away entire process VM, if address space not shared, diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c index d05951e150c..ad86035b75c 100644 --- a/sys/kern/kern_exit.c +++ b/sys/kern/kern_exit.c @@ -329,7 +329,7 @@ exit1(struct thread *td, int rval, int signo) * Event handler could change exit status. * XXX what if one of these generates an error? */ - EVENTHANDLER_INVOKE(process_exit, p); + EVENTHANDLER_STATIC_INVOKE(process_exit, p); /* * If parent is waiting for us to exit or exec, diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c index 997a783522e..bac4787815c 100644 --- a/sys/kern/kern_fork.c +++ b/sys/kern/kern_fork.c @@ -699,7 +699,7 @@ do_fork(struct thread *td, struct fork_req *fr, struct proc *p2, struct thread * * Both processes are set up, now check if any loadable modules want * to adjust anything. */ - EVENTHANDLER_INVOKE(process_fork, p1, p2, fr->fr_flags); + EVENTHANDLER_STATIC_INVOKE(process_fork, p1, p2, fr->fr_flags); /* * Set the child start time and mark the process as being complete. diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c index de829228b1d..8324ffe8a4e 100644 --- a/sys/kern/kern_proc.c +++ b/sys/kern/kern_proc.c @@ -164,6 +164,14 @@ CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE); CTASSERT(sizeof(struct kinfo_proc32) == KINFO_PROC32_SIZE); #endif +EVENTHANDLER_STATIC_DEFINE(process_ctor, proc_ctor_fn); +EVENTHANDLER_STATIC_DEFINE(process_dtor, proc_dtor_fn); +EVENTHANDLER_STATIC_DEFINE(process_init, proc_init_fn); +EVENTHANDLER_STATIC_DEFINE(process_fini, proc_fini_fn); +EVENTHANDLER_STATIC_DEFINE(process_exit, exitlist_fn); +EVENTHANDLER_STATIC_DEFINE(process_fork, forklist_fn); +EVENTHANDLER_STATIC_DEFINE(process_exec, execlist_fn); + /* * Initialize global process hashing structures. */ @@ -195,12 +203,12 @@ proc_ctor(void *mem, int size, void *arg, int flags) p = (struct proc *)mem; SDT_PROBE4(proc, , ctor , entry, p, size, arg, flags); - EVENTHANDLER_INVOKE(process_ctor, p); + EVENTHANDLER_STATIC_INVOKE(process_ctor, p); SDT_PROBE4(proc, , ctor , return, p, size, arg, flags); td = FIRST_THREAD_IN_PROC(p); if (td != NULL) { /* Make sure all thread constructors are executed */ - EVENTHANDLER_INVOKE(thread_ctor, td); + EVENTHANDLER_STATIC_INVOKE(thread_ctor, td); } return (0); } @@ -230,9 +238,9 @@ proc_dtor(void *mem, int size, void *arg) MPASS(td->td_su == NULL); /* Make sure all thread destructors are executed */ - EVENTHANDLER_INVOKE(thread_dtor, td); + EVENTHANDLER_STATIC_INVOKE(thread_dtor, td); } - EVENTHANDLER_INVOKE(process_dtor, p); + EVENTHANDLER_STATIC_INVOKE(process_dtor, p); if (p->p_ksi != NULL) KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue")); SDT_PROBE3(proc, , dtor, return, p, size, arg); @@ -256,7 +264,7 @@ proc_init(void *mem, int size, int flags) cv_init(&p->p_pwait, "ppwait"); cv_init(&p->p_dbgwait, "dbgwait"); TAILQ_INIT(&p->p_threads); /* all threads in proc */ - EVENTHANDLER_INVOKE(process_init, p); + EVENTHANDLER_STATIC_INVOKE(process_init, p); p->p_stats = pstats_alloc(); p->p_pgrp = NULL; SDT_PROBE3(proc, , init, return, p, size, flags); @@ -274,7 +282,7 @@ proc_fini(void *mem, int size) struct proc *p; p = (struct proc *)mem; - EVENTHANDLER_INVOKE(process_fini, p); + EVENTHANDLER_STATIC_INVOKE(process_fini, p); pstats_free(p->p_stats); thread_free(FIRST_THREAD_IN_PROC(p)); mtx_destroy(&p->p_mtx); diff --git a/sys/kern/kern_thread.c b/sys/kern/kern_thread.c index d3e7e306a68..92553f60678 100644 --- a/sys/kern/kern_thread.c +++ b/sys/kern/kern_thread.c @@ -144,6 +144,11 @@ struct tidhashhead *tidhashtbl; u_long tidhash; struct rwlock tidhash_lock; +EVENTHANDLER_STATIC_DEFINE(thread_ctor, thread_ctor_fn); +EVENTHANDLER_STATIC_DEFINE(thread_dtor, thread_dtor_fn); +EVENTHANDLER_STATIC_DEFINE(thread_init, thread_init_fn); +EVENTHANDLER_STATIC_DEFINE(thread_fini, thread_fini_fn); + static lwpid_t tid_alloc(void) { @@ -201,7 +206,7 @@ thread_ctor(void *mem, int size, void *arg, int flags) */ td->td_critnest = 1; td->td_lend_user_pri = PRI_MAX; - EVENTHANDLER_INVOKE(thread_ctor, td); + EVENTHANDLER_STATIC_INVOKE(thread_ctor, td); #ifdef AUDIT audit_thread_alloc(td); #endif @@ -247,7 +252,7 @@ thread_dtor(void *mem, int size, void *arg) td_softdep_cleanup(td); MPASS(td->td_su == NULL); - EVENTHANDLER_INVOKE(thread_dtor, td); + EVENTHANDLER_STATIC_INVOKE(thread_dtor, td); tid_free(td->td_tid); } @@ -264,7 +269,7 @@ thread_init(void *mem, int size, int flags) td->td_sleepqueue = sleepq_alloc(); td->td_turnstile = turnstile_alloc(); td->td_rlqe = NULL; - EVENTHANDLER_INVOKE(thread_init, td); + EVENTHANDLER_STATIC_INVOKE(thread_init, td); umtx_thread_init(td); td->td_kstack = 0; td->td_sel = NULL; @@ -280,7 +285,7 @@ thread_fini(void *mem, int size) struct thread *td; td = (struct thread *)mem; - EVENTHANDLER_INVOKE(thread_fini, td); + EVENTHANDLER_STATIC_INVOKE(thread_fini, td); rlqentry_free(td->td_rlqe); turnstile_free(td->td_turnstile); sleepq_free(td->td_sleepqueue); diff --git a/sys/kern/kern_time.c b/sys/kern/kern_time.c index 92672438253..29909e7f509 100644 --- a/sys/kern/kern_time.c +++ b/sys/kern/kern_time.c @@ -1102,9 +1102,9 @@ itimer_start(void) p31b_setcfg(CTL_P1003_1B_TIMERS, 200112L); p31b_setcfg(CTL_P1003_1B_DELAYTIMER_MAX, INT_MAX); p31b_setcfg(CTL_P1003_1B_TIMER_MAX, TIMER_MAX); - EVENTHANDLER_REGISTER(process_exit, itimers_event_hook_exit, + EVENTHANDLER_STATIC_REGISTER(process_exit, itimers_event_hook_exit, (void *)ITIMER_EV_EXIT, EVENTHANDLER_PRI_ANY); - EVENTHANDLER_REGISTER(process_exec, itimers_event_hook_exec, + EVENTHANDLER_STATIC_REGISTER(process_exec, itimers_event_hook_exec, (void *)ITIMER_EV_EXEC, EVENTHANDLER_PRI_ANY); } diff --git a/sys/kern/kern_umtx.c b/sys/kern/kern_umtx.c index d72c57d5f59..b4ac3007295 100644 --- a/sys/kern/kern_umtx.c +++ b/sys/kern/kern_umtx.c @@ -448,7 +448,7 @@ umtxq_sysinit(void *arg __unused) umtx_init_profiling(); #endif mtx_init(&umtx_lock, "umtx lock", NULL, MTX_DEF); - EVENTHANDLER_REGISTER(process_exec, umtx_exec_hook, NULL, + EVENTHANDLER_STATIC_REGISTER(process_exec, umtx_exec_hook, NULL, EVENTHANDLER_PRI_ANY); umtx_shm_init(); } diff --git a/sys/kern/sysv_sem.c b/sys/kern/sysv_sem.c index 60688960e24..e57543c0117 100644 --- a/sys/kern/sysv_sem.c +++ b/sys/kern/sysv_sem.c @@ -302,7 +302,7 @@ seminit(void) LIST_INIT(&semu_list); mtx_init(&sem_mtx, "sem", NULL, MTX_DEF); mtx_init(&sem_undo_mtx, "semu", NULL, MTX_DEF); - semexit_tag = EVENTHANDLER_REGISTER(process_exit, semexit_myhook, NULL, + semexit_tag = EVENTHANDLER_STATIC_REGISTER(process_exit, semexit_myhook, NULL, EVENTHANDLER_PRI_ANY); /* Set current prisons according to their allow.sysvipc. */ @@ -352,7 +352,7 @@ semunload(void) syscall32_helper_unregister(sem32_syscalls); #endif syscall_helper_unregister(sem_syscalls); - EVENTHANDLER_DEREGISTER(process_exit, semexit_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exit, semexit_tag); if (sem_prison_slot != 0) osd_jail_deregister(sem_prison_slot); #ifdef MAC diff --git a/sys/kern/uipc_mqueue.c b/sys/kern/uipc_mqueue.c index f299858708c..8c16eed21fc 100644 --- a/sys/kern/uipc_mqueue.c +++ b/sys/kern/uipc_mqueue.c @@ -682,7 +682,7 @@ mqfs_init(struct vfsconf *vfc) mqfs_fileno_init(mi); mqfs_fileno_alloc(mi, root); mqfs_fixup_dir(root); - exit_tag = EVENTHANDLER_REGISTER(process_exit, mq_proc_exit, NULL, + exit_tag = EVENTHANDLER_STATIC_REGISTER(process_exit, mq_proc_exit, NULL, EVENTHANDLER_PRI_ANY); mq_fdclose = mqueue_fdclose; p31b_setcfg(CTL_P1003_1B_MESSAGE_PASSING, _POSIX_MESSAGE_PASSING); @@ -701,7 +701,7 @@ mqfs_uninit(struct vfsconf *vfc) if (!unloadable) return (EOPNOTSUPP); osd_jail_deregister(mqfs_osd_jail_slot); - EVENTHANDLER_DEREGISTER(process_exit, exit_tag); + EVENTHANDLER_STATIC_DEREGISTER(process_exit, exit_tag); mi = &mqfs_data; mqfs_destroy(mi->mi_root); mi->mi_root = NULL; diff --git a/sys/kern/vfs_aio.c b/sys/kern/vfs_aio.c index 302ab9e3b13..e47861cd32b 100644 --- a/sys/kern/vfs_aio.c +++ b/sys/kern/vfs_aio.c @@ -399,9 +399,9 @@ aio_onceonly(void) if (aio_listio_max > MIN(MAX_AIO_QUEUE_PER_PROC, max_queue_count)) aio_listio_max = MIN(MAX_AIO_QUEUE_PER_PROC, max_queue_count); - exit_tag = EVENTHANDLER_REGISTER(process_exit, aio_proc_rundown, NULL, + exit_tag = EVENTHANDLER_STATIC_REGISTER(process_exit, aio_proc_rundown, NULL, EVENTHANDLER_PRI_ANY); - exec_tag = EVENTHANDLER_REGISTER(process_exec, aio_proc_rundown_exec, + exec_tag = EVENTHANDLER_STATIC_REGISTER(process_exec, aio_proc_rundown_exec, NULL, EVENTHANDLER_PRI_ANY); kqueue_add_filteropts(EVFILT_AIO, &aio_filtops); kqueue_add_filteropts(EVFILT_LIO, &lio_filtops); diff --git a/sys/sys/eventhandler.h b/sys/sys/eventhandler.h index 7fccffffa8a..aa744f98a69 100644 --- a/sys/sys/eventhandler.h +++ b/sys/sys/eventhandler.h @@ -97,11 +97,57 @@ typedef struct eventhandler_entry *eventhandler_tag; EHL_UNLOCK((list)); \ } while (0) + +/* + * Static event handler lists require the eventhandler list be present at link + * time. They don't allow addition of entries to unknown eventhandler lists. + * + * Static handler lists must be defined once by the "owner" of the eventhandler + * list, and the declaration must be in scope at any point the list is + * manipulated. + */ +#define EVENTHANDLER_STATIC_DECLARE(name, type) \ +extern struct eventhandler_list Xeventhandler_list_ ## name ; \ +struct eventhandler_entry_ ## name { \ + struct eventhandler_entry ee; \ + type eh_func; \ +}; \ +struct __hack + +#define EVENTHANDLER_STATIC_DEFINE(name, type) \ +struct eventhandler_list Xeventhandler_list_ ## name = { #name }; \ +struct __hack + +#define EVENTHANDLER_STATIC_INVOKE(name, ...) \ +do { \ + struct eventhandler_list *_el = &Xeventhandler_list_ ## name ; \ + \ + if (_el->el_flags & EHL_INITTED) { \ + EHL_LOCK(_el); \ + _EVENTHANDLER_INVOKE(name, _el , ## __VA_ARGS__); \ + } \ +} while (0) + +#define EVENTHANDLER_STATIC_REGISTER(name, func, arg, priority) \ + eventhandler_register(&Xeventhandler_list_ ## name, \ + #name, func, arg, priority) + +#define EVENTHANDLER_STATIC_DEREGISTER(name, tag) \ +do { \ + struct eventhandler_list *_el = &Xeventhandler_list_ ## name ; \ + \ + KASSERT(_el->el_flags & EHL_INITTED, \ + ("eventhandler_fast_deregister on un-inited list %s", \ + #name)); \ + EHL_LOCK(_el); \ + eventhandler_deregister(_el, tag); \ +} while (0) + /* - * Slow handlers are entirely dynamic; lists are created + * Non-static handlers are entirely dynamic; lists are created * when entries are added to them, and thus have no concept of "owner", * - * Slow handlers need to be declared, but do not need to be defined. The + * These 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) \ @@ -228,13 +274,13 @@ typedef void (*proc_ctor_fn)(void *, struct proc *); typedef void (*proc_dtor_fn)(void *, struct proc *); typedef void (*proc_init_fn)(void *, struct proc *); typedef void (*proc_fini_fn)(void *, struct proc *); -EVENTHANDLER_DECLARE(process_ctor, proc_ctor_fn); -EVENTHANDLER_DECLARE(process_dtor, proc_dtor_fn); -EVENTHANDLER_DECLARE(process_init, proc_init_fn); -EVENTHANDLER_DECLARE(process_fini, proc_fini_fn); -EVENTHANDLER_DECLARE(process_exit, exitlist_fn); -EVENTHANDLER_DECLARE(process_fork, forklist_fn); -EVENTHANDLER_DECLARE(process_exec, execlist_fn); +EVENTHANDLER_STATIC_DECLARE(process_ctor, proc_ctor_fn); +EVENTHANDLER_STATIC_DECLARE(process_dtor, proc_dtor_fn); +EVENTHANDLER_STATIC_DECLARE(process_init, proc_init_fn); +EVENTHANDLER_STATIC_DECLARE(process_fini, proc_fini_fn); +EVENTHANDLER_STATIC_DECLARE(process_exit, exitlist_fn); +EVENTHANDLER_STATIC_DECLARE(process_fork, forklist_fn); +EVENTHANDLER_STATIC_DECLARE(process_exec, execlist_fn); /* * application dump event @@ -253,10 +299,10 @@ typedef void (*thread_ctor_fn)(void *, struct thread *); typedef void (*thread_dtor_fn)(void *, struct thread *); typedef void (*thread_fini_fn)(void *, struct thread *); typedef void (*thread_init_fn)(void *, struct thread *); -EVENTHANDLER_DECLARE(thread_ctor, thread_ctor_fn); -EVENTHANDLER_DECLARE(thread_dtor, thread_dtor_fn); -EVENTHANDLER_DECLARE(thread_init, thread_init_fn); -EVENTHANDLER_DECLARE(thread_fini, thread_fini_fn); +EVENTHANDLER_STATIC_DECLARE(thread_ctor, thread_ctor_fn); +EVENTHANDLER_STATIC_DECLARE(thread_dtor, thread_dtor_fn); +EVENTHANDLER_STATIC_DECLARE(thread_init, thread_init_fn); +EVENTHANDLER_STATIC_DECLARE(thread_fini, thread_fini_fn); typedef void (*uma_zone_chfn)(void *); EVENTHANDLER_DECLARE(nmbclusters_change, uma_zone_chfn);