Masterwork From Distant Lands
ActivePublic
Actions

Authored by mjoras on Oct 19 2017, 7:03 PM.

Project Tags

None

Referenced Files

	F2937141: Masterwork From Distant Lands
	Oct 19 2017, 7:03 PM

Subscribers

None

	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.

Masterwork From Distant LandsActivePublicActions

Event Timeline

Masterwork From Distant Lands
ActivePublic
Actions