Page MenuHomeFreeBSD
Paste P147

Masterwork From Distant Lands
ActivePublic

Authored by mjoras on Oct 19 2017, 7:03 PM.
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);

Event Timeline

mjoras edited the content of this paste. (Show Details)Oct 19 2017, 7:03 PM
mjoras changed the title of this paste from untitled to Masterwork From Distant Lands.
mjoras updated the paste's language from autodetect to autodetect.