From 9f64a441abd698125eee7a8fe478cb3cf8c1f0a3 Mon Sep 17 00:00:00 2001 From: Mateusz Guzik Date: Tue, 16 Aug 2022 12:27:06 +0000 Subject: [PATCH 2/7] Switch proc eventhandlers to the new API --- sys/dev/filemon/filemon_wrapper.c | 39 ++++++++++++++++-------------- sys/dev/hwpmc/hwpmc_mod.c | 36 +++++++++++++++------------ sys/fs/pseudofs/pseudofs_vncache.c | 12 ++++----- sys/kern/init_main.c | 4 +-- sys/kern/kern_exec.c | 5 +++- sys/kern/kern_exit.c | 2 +- sys/kern/kern_fork.c | 6 ++++- sys/kern/kern_proc.c | 22 ++++++++--------- sys/kern/sysv_sem.c | 13 +++++----- sys/kern/uipc_mqueue.c | 12 ++++----- sys/kern/vfs_aio.c | 31 ++++++++++++++---------- sys/sys/eventhandler.h | 23 ------------------ sys/sys/proc.h | 25 +++++++++++++------ 13 files changed, 119 insertions(+), 111 deletions(-) diff --git a/sys/dev/filemon/filemon_wrapper.c b/sys/dev/filemon/filemon_wrapper.c index 4e64d8254f8d..f05d54863d47 100644 --- a/sys/dev/filemon/filemon_wrapper.c +++ b/sys/dev/filemon/filemon_wrapper.c @@ -44,10 +44,6 @@ __FBSDID("$FreeBSD$"); static void filemon_output_event(struct filemon *filemon, const char *fmt, ...) __printflike(2, 3); -static eventhandler_tag filemon_exec_tag; -static eventhandler_tag filemon_exit_tag; -static eventhandler_tag filemon_fork_tag; - static void filemon_output(struct filemon *filemon, char *msg, size_t len) { @@ -116,11 +112,15 @@ filemon_wrapper_chdir(struct thread *td, struct chdir_args *uap) } static void -filemon_event_process_exec(void *arg __unused, struct proc *p, - struct image_params *imgp) +filemon_event_process_exec(void *arg) { + struct process_exec_arg *pea = arg; + struct proc *p; + struct image_params *imgp; struct filemon *filemon; + p = pea->p; + imgp = pea->imgp; if ((filemon = filemon_proc_get(p)) != NULL) { filemon_output_event(filemon, "E %d %s\n", p->p_pid, @@ -317,9 +317,10 @@ filemon_wrapper_linkat(struct thread *td, struct linkat_args *uap) } static void -filemon_event_process_exit(void *arg __unused, struct proc *p) +filemon_event_process_exit(void *arg) { struct filemon *filemon; + struct proc *p = arg; if ((filemon = filemon_proc_get(p)) != NULL) { filemon_output_event(filemon, "X %d %d %d\n", @@ -365,10 +366,15 @@ filemon_wrapper_unlink(struct thread *td, struct unlink_args *uap) } static void -filemon_event_process_fork(void *arg __unused, struct proc *p1, - struct proc *p2, int flags __unused) +filemon_event_process_fork(void *arg) { + struct process_fork_arg *pfa; struct filemon *filemon; + struct proc *p1, *p2; + + pfa = arg; + p1 = pfa->p1; + p2 = pfa->p2; if ((filemon = filemon_proc_get(p1)) != NULL) { filemon_output_event(filemon, "F %d %d\n", @@ -422,12 +428,9 @@ 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_event_process_exec, NULL, EVENTHANDLER_PRI_LAST); - filemon_exit_tag = EVENTHANDLER_REGISTER(process_exit, - filemon_event_process_exit, NULL, EVENTHANDLER_PRI_LAST); - filemon_fork_tag = EVENTHANDLER_REGISTER(process_fork, - filemon_event_process_fork, NULL, EVENTHANDLER_PRI_LAST); + EVENTHANDLER_SLEEPABLE_REGISTER(process_exec, filemon_event_process_exec, LAST); + EVENTHANDLER_SLEEPABLE_REGISTER(process_exit, filemon_event_process_exit, LAST); + EVENTHANDLER_SLEEPABLE_REGISTER(process_fork, filemon_event_process_fork, LAST); } static void @@ -454,7 +457,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_SLEEPABLE_DEREGISTER(process_exec, filemon_event_process_exec); + EVENTHANDLER_SLEEPABLE_DEREGISTER(process_exit, filemon_event_process_exit); + EVENTHANDLER_SLEEPABLE_DEREGISTER(process_fork, filemon_event_process_fork); } diff --git a/sys/dev/hwpmc/hwpmc_mod.c b/sys/dev/hwpmc/hwpmc_mod.c index e5a12b666e1b..2a795178486f 100644 --- a/sys/dev/hwpmc/hwpmc_mod.c +++ b/sys/dev/hwpmc/hwpmc_mod.c @@ -142,8 +142,7 @@ static int *pmc_pmcdisp; /* PMC row dispositions */ /* various event handlers */ -static eventhandler_tag pmc_exit_tag, pmc_fork_tag, pmc_kld_load_tag, - pmc_kld_unload_tag; +static eventhandler_tag pmc_kld_load_tag, pmc_kld_unload_tag; /* Module statistics */ struct pmc_driverstats pmc_stats; @@ -239,9 +238,8 @@ static void pmc_log_process_mappings(struct pmc_owner *po, struct proc *p); static void pmc_maybe_remove_owner(struct pmc_owner *po); static void pmc_process_csw_in(struct thread *td); static void pmc_process_csw_out(struct thread *td); -static void pmc_process_exit(void *arg, struct proc *p); -static void pmc_process_fork(void *arg, struct proc *p1, - struct proc *p2, int n); +static void pmc_process_exit(void *arg); +static void pmc_process_fork(void *arg); static void pmc_process_samples(int cpu, ring_type_t soft); static void pmc_release_pmc_descriptor(struct pmc *pmc); static void pmc_process_thread_add(struct thread *td); @@ -5054,7 +5052,7 @@ pmc_process_samples(int cpu, ring_type_t ring) */ static void -pmc_process_exit(void *arg __unused, struct proc *p) +pmc_process_exit(void *arg) { struct pmc *pm; int adjri, cpu; @@ -5064,6 +5062,9 @@ pmc_process_exit(void *arg __unused, struct proc *p) struct pmc_process *pp; struct pmc_classdep *pcd; pmc_value_t newvalue, tmp; + struct proc *p; + + p = (struct proc *)arg; PROC_LOCK(p); is_using_hwpmcs = p->p_flag & P_HWPMC; @@ -5237,8 +5238,7 @@ pmc_process_exit(void *arg __unused, struct proc *p) */ static void -pmc_process_fork(void *arg __unused, struct proc *p1, struct proc *newproc, - int flags) +pmc_process_fork(void *arg) { int is_using_hwpmcs; unsigned int ri; @@ -5247,7 +5247,15 @@ pmc_process_fork(void *arg __unused, struct proc *p1, struct proc *newproc, struct pmc_owner *po; struct pmc_process *ppnew, *ppold; - (void) flags; /* unused parameter */ + struct proc *p1; + struct proc *newproc; + + struct process_fork_arg *pfa; + + pfa = (struct process_fork_arg *)arg; + + p1 = pfa->p1; + newproc = pfa->p2; PROC_LOCK(p1); is_using_hwpmcs = p1->p_flag & P_HWPMC; @@ -5730,10 +5738,8 @@ pmc_initialize(void) TASK_INIT(&free_task, 0, pmc_thread_descriptor_pool_free_task, NULL); /* register process {exit,fork,exec} handlers */ - pmc_exit_tag = EVENTHANDLER_REGISTER(process_exit, - pmc_process_exit, NULL, EVENTHANDLER_PRI_ANY); - pmc_fork_tag = EVENTHANDLER_REGISTER(process_fork, - pmc_process_fork, NULL, EVENTHANDLER_PRI_ANY); + EVENTHANDLER_SLEEPABLE_REGISTER(process_exit, pmc_process_exit, ANY); + EVENTHANDLER_SLEEPABLE_REGISTER(process_fork, pmc_process_fork, ANY); /* register kld event handlers */ pmc_kld_load_tag = EVENTHANDLER_REGISTER(kld_load, pmc_kld_load, @@ -5800,8 +5806,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_SLEEPABLE_DEREGISTER(process_fork, pmc_process_fork); + EVENTHANDLER_SLEEPABLE_DEREGISTER(process_exit, pmc_process_exit); 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 15892b510973..501fa1e04498 100644 --- a/sys/fs/pseudofs/pseudofs_vncache.c +++ b/sys/fs/pseudofs/pseudofs_vncache.c @@ -50,8 +50,7 @@ __FBSDID("$FreeBSD$"); static MALLOC_DEFINE(M_PFSVNCACHE, "pfs_vncache", "pseudofs vnode cache"); static struct mtx pfs_vncache_mutex; -static eventhandler_tag pfs_exit_tag; -static void pfs_exit(void *arg, struct proc *p); +static void pfs_exit(void *arg); static void pfs_purge_all(void); static SYSCTL_NODE(_vfs_pfs, OID_AUTO, vncache, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, @@ -92,8 +91,7 @@ pfs_vncache_load(void) mtx_init(&pfs_vncache_mutex, "pfs_vncache", NULL, MTX_DEF); pfs_vncache_hashtbl = hashinit(maxproc / 4, M_PFSVNCACHE, &pfs_vncache_hash); - pfs_exit_tag = EVENTHANDLER_REGISTER(process_exit, pfs_exit, NULL, - EVENTHANDLER_PRI_ANY); + EVENTHANDLER_SLEEPABLE_REGISTER(process_exit, pfs_exit, ANY); } /* @@ -103,7 +101,7 @@ void pfs_vncache_unload(void) { - EVENTHANDLER_DEREGISTER(process_exit, pfs_exit_tag); + EVENTHANDLER_SLEEPABLE_DEREGISTER(process_exit, pfs_exit); pfs_purge_all(); KASSERT(pfs_vncache_entries == 0, ("%d vncache entries remaining", pfs_vncache_entries)); @@ -337,13 +335,15 @@ pfs_purge_all(void) * Free all vnodes associated with a defunct process */ static void -pfs_exit(void *arg, struct proc *p) +pfs_exit(void *arg) { struct pfs_vncache_head *hash; struct pfs_vdata *pvd; struct vnode *vnp; + struct proc *p; int pid; + p = arg; pid = p->p_pid; hash = PFS_VNCACHE_HASH(pid); if (SLIST_EMPTY(hash)) diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c index 739114c6bd3d..13c4044a88f8 100644 --- a/sys/kern/init_main.c +++ b/sys/kern/init_main.c @@ -621,13 +621,13 @@ 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_DIRECT_INVOKE(process_init, p); + EVENTHANDLER_SLEEPABLE_INVOKE(process_init, p); EVENTHANDLER_SLEEPABLE_INVOKE(thread_init, td); #ifdef KDTRACE_HOOKS kdtrace_proc_ctor(p); kdtrace_thread_ctor(td); #endif - EVENTHANDLER_DIRECT_INVOKE(process_ctor, p); + EVENTHANDLER_SLEEPABLE_INVOKE(process_ctor, p); EVENTHANDLER_SLEEPABLE_INVOKE(thread_ctor, td); /* diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c index 364c10987ea6..40da9dd15c5e 100644 --- a/sys/kern/kern_exec.c +++ b/sys/kern/kern_exec.c @@ -1115,6 +1115,7 @@ exec_free_abi_mappings(struct proc *p) int exec_new_vmspace(struct image_params *imgp, struct sysentvec *sv) { + struct process_exec_arg pea; int error; struct proc *p = imgp->proc; struct vmspace *vmspace = p->p_vmspace; @@ -1129,7 +1130,9 @@ exec_new_vmspace(struct image_params *imgp, struct sysentvec *sv) p->p_sysent->sv_onexec_old(td); itimers_exec(p); - EVENTHANDLER_DIRECT_INVOKE(process_exec, p, imgp); + pea.p = p; + pea.imgp = imgp; + EVENTHANDLER_SLEEPABLE_INVOKE(process_exec, &pea); /* * 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 cb51193a26e0..58a9f95bf2d7 100644 --- a/sys/kern/kern_exit.c +++ b/sys/kern/kern_exit.c @@ -364,7 +364,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_DIRECT_INVOKE(process_exit, p); + EVENTHANDLER_SLEEPABLE_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 b4f96686caba..70a1aea560ee 100644 --- a/sys/kern/kern_fork.c +++ b/sys/kern/kern_fork.c @@ -370,6 +370,7 @@ static void do_fork(struct thread *td, struct fork_req *fr, struct proc *p2, struct thread *td2, struct vmspace *vm2, struct file *fp_procdesc) { + struct process_fork_arg pfa; struct proc *p1, *pptr; struct filedesc *fd; struct filedesc_to_leader *fdtol; @@ -704,7 +705,10 @@ 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_DIRECT_INVOKE(process_fork, p1, p2, fr->fr_flags); + pfa.p1 = p1; + pfa.p2 = p2; + pfa.flags = fr->fr_flags; + EVENTHANDLER_SLEEPABLE_INVOKE(process_fork, &pfa); /* * 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 62e888500e1a..9b908785ab61 100644 --- a/sys/kern/kern_proc.c +++ b/sys/kern/kern_proc.c @@ -154,13 +154,13 @@ const int thread_off_td_oncpu = offsetof(struct thread, td_oncpu); const int thread_off_td_pcb = offsetof(struct thread, td_pcb); const int thread_off_td_plist = offsetof(struct thread, td_plist); -EVENTHANDLER_LIST_DEFINE(process_ctor); -EVENTHANDLER_LIST_DEFINE(process_dtor); -EVENTHANDLER_LIST_DEFINE(process_init); -EVENTHANDLER_LIST_DEFINE(process_fini); -EVENTHANDLER_LIST_DEFINE(process_exit); -EVENTHANDLER_LIST_DEFINE(process_fork); -EVENTHANDLER_LIST_DEFINE(process_exec); +EVENTHANDLER_SLEEPABLE_DEFINE(process_ctor); +EVENTHANDLER_SLEEPABLE_DEFINE(process_dtor); +EVENTHANDLER_SLEEPABLE_DEFINE(process_init); +EVENTHANDLER_SLEEPABLE_DEFINE(process_fini); +EVENTHANDLER_SLEEPABLE_DEFINE(process_exit); +EVENTHANDLER_SLEEPABLE_DEFINE(process_fork); +EVENTHANDLER_SLEEPABLE_DEFINE(process_exec); int kstack_pages = KSTACK_PAGES; SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0, @@ -217,7 +217,7 @@ proc_ctor(void *mem, int size, void *arg, int flags) #ifdef KDTRACE_HOOKS kdtrace_proc_ctor(p); #endif - EVENTHANDLER_DIRECT_INVOKE(process_ctor, p); + EVENTHANDLER_SLEEPABLE_INVOKE(process_ctor, p); td = FIRST_THREAD_IN_PROC(p); if (td != NULL) { /* Make sure all thread constructors are executed */ @@ -251,7 +251,7 @@ proc_dtor(void *mem, int size, void *arg) /* Make sure all thread destructors are executed */ EVENTHANDLER_SLEEPABLE_INVOKE(thread_dtor, td); } - EVENTHANDLER_DIRECT_INVOKE(process_dtor, p); + EVENTHANDLER_SLEEPABLE_INVOKE(process_dtor, p); #ifdef KDTRACE_HOOKS kdtrace_proc_dtor(p); #endif @@ -275,7 +275,7 @@ proc_init(void *mem, int size, int flags) mtx_init(&p->p_profmtx, "pprofl", NULL, MTX_SPIN | MTX_NEW); cv_init(&p->p_pwait, "ppwait"); TAILQ_INIT(&p->p_threads); /* all threads in proc */ - EVENTHANDLER_DIRECT_INVOKE(process_init, p); + EVENTHANDLER_SLEEPABLE_INVOKE(process_init, p); p->p_stats = pstats_alloc(); p->p_pgrp = NULL; return (0); @@ -292,7 +292,7 @@ proc_fini(void *mem, int size) struct proc *p; p = (struct proc *)mem; - EVENTHANDLER_DIRECT_INVOKE(process_fini, p); + EVENTHANDLER_SLEEPABLE_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/sysv_sem.c b/sys/kern/sysv_sem.c index 4104f1343cb7..74da297593b7 100644 --- a/sys/kern/sysv_sem.c +++ b/sys/kern/sysv_sem.c @@ -86,7 +86,7 @@ static MALLOC_DEFINE(M_SEM, "sem", "SVID compatible semaphores"); static int seminit(void); static int sysvsem_modload(struct module *, int, void *); static int semunload(void); -static void semexit_myhook(void *arg, struct proc *p); +static void semexit_myhook(void *arg); static int sysctl_sema(SYSCTL_HANDLER_ARGS); static int semvalid(int semid, struct prison *rpr, struct semid_kernel *semakptr); @@ -122,7 +122,6 @@ static struct sem *sem; /* semaphore pool */ LIST_HEAD(, sem_undo) semu_list; /* list of active undo structures */ LIST_HEAD(, sem_undo) semu_free_list; /* list of free undo structures */ static int *semu; /* undo structure pool */ -static eventhandler_tag semexit_tag; static unsigned sem_prison_slot; /* prison OSD slot */ #define SEMUNDO_MTX sem_undo_mtx @@ -306,8 +305,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, - EVENTHANDLER_PRI_ANY); + EVENTHANDLER_SLEEPABLE_REGISTER(process_exit, semexit_myhook, ANY); /* Set current prisons according to their allow.sysvipc. */ sem_prison_slot = osd_jail_register(NULL, methods); @@ -356,7 +354,7 @@ semunload(void) syscall32_helper_unregister(sem32_syscalls); #endif syscall_helper_unregister(sem_syscalls); - EVENTHANDLER_DEREGISTER(process_exit, semexit_tag); + EVENTHANDLER_SLEEPABLE_DEREGISTER(process_exit, semexit_myhook); if (sem_prison_slot != 0) osd_jail_deregister(sem_prison_slot); #ifdef MAC @@ -1442,13 +1440,16 @@ kern_semop(struct thread *td, int usemid, struct sembuf *usops, * semaphores. */ static void -semexit_myhook(void *arg, struct proc *p) +semexit_myhook(void *arg) { struct sem_undo *suptr; struct semid_kernel *semakptr; struct mtx *sema_mtxp; int semid, semnum, adjval, ix; unsigned short seq; + struct proc *p; + + p = arg; /* * Go through the chain of undo vectors looking for one diff --git a/sys/kern/uipc_mqueue.c b/sys/kern/uipc_mqueue.c index 745c1174638e..3cfeb84dea06 100644 --- a/sys/kern/uipc_mqueue.c +++ b/sys/kern/uipc_mqueue.c @@ -220,8 +220,6 @@ SYSCTL_INT(_kern_mqueue, OID_AUTO, curmq, CTLFLAG_RW, static int unloadable = 0; static MALLOC_DEFINE(M_MQUEUEDATA, "mqdata", "mqueue data"); -static eventhandler_tag exit_tag; - /* Only one instance per-system */ static struct mqfs_info mqfs_data; static uma_zone_t mqnode_zone; @@ -267,7 +265,7 @@ static int _mqueue_recv(struct mqueue *mq, struct mqueue_msg **msg, int timo); static void mqueue_send_notification(struct mqueue *mq); static void mqueue_fdclose(struct thread *td, int fd, struct file *fp); -static void mq_proc_exit(void *arg, struct proc *p); +static void mq_proc_exit(void *arg); /* * kqueue filters @@ -683,8 +681,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, - EVENTHANDLER_PRI_ANY); + EVENTHANDLER_SLEEPABLE_REGISTER(process_exit, mq_proc_exit, ANY); mq_fdclose = mqueue_fdclose; p31b_setcfg(CTL_P1003_1B_MESSAGE_PASSING, _POSIX_MESSAGE_PASSING); mqfs_osd_jail_slot = osd_jail_register(NULL, methods); @@ -702,7 +699,7 @@ mqfs_uninit(struct vfsconf *vfc) if (!unloadable) return (EOPNOTSUPP); osd_jail_deregister(mqfs_osd_jail_slot); - EVENTHANDLER_DEREGISTER(process_exit, exit_tag); + EVENTHANDLER_SLEEPABLE_DEREGISTER(process_exit, mq_proc_exit); mi = &mqfs_data; mqfs_destroy(mi->mi_root); mi->mi_root = NULL; @@ -2472,8 +2469,9 @@ mqueue_fdclose(struct thread *td, int fd, struct file *fp) } static void -mq_proc_exit(void *arg __unused, struct proc *p) +mq_proc_exit(void *arg) { + struct proc *p = arg; struct filedesc *fdp; struct file *fp; struct mqueue *mq; diff --git a/sys/kern/vfs_aio.c b/sys/kern/vfs_aio.c index c9489ee5b4ad..f50f98edd70a 100644 --- a/sys/kern/vfs_aio.c +++ b/sys/kern/vfs_aio.c @@ -319,9 +319,9 @@ int aio_aqueue(struct thread *td, struct aiocb *ujob, struct aioliojob *lio, int type, struct aiocb_ops *ops); static int aio_queue_file(struct file *fp, struct kaiocb *job); static void aio_biowakeup(struct bio *bp); -static void aio_proc_rundown(void *arg, struct proc *p); -static void aio_proc_rundown_exec(void *arg, struct proc *p, - struct image_params *imgp); +static void aio_proc_rundown(struct proc *p); +static void aio_proc_rundown_exit(void *); +static void aio_proc_rundown_exec(void *); static int aio_qbio(struct proc *p, struct kaiocb *job); static void aio_daemon(void *param); static void aio_bio_done_notify(struct proc *userp, struct kaiocb *job); @@ -358,8 +358,6 @@ static struct filterops lio_filtops = { .f_event = filt_lio }; -static eventhandler_tag exit_tag, exec_tag; - TASKQUEUE_DEFINE_THREAD(aiod_kick); /* @@ -399,10 +397,8 @@ static int aio_onceonly(void) { - exit_tag = EVENTHANDLER_REGISTER(process_exit, aio_proc_rundown, NULL, - EVENTHANDLER_PRI_ANY); - exec_tag = EVENTHANDLER_REGISTER(process_exec, aio_proc_rundown_exec, - NULL, EVENTHANDLER_PRI_ANY); + EVENTHANDLER_SLEEPABLE_REGISTER(process_exit, aio_proc_rundown_exit, ANY); + EVENTHANDLER_SLEEPABLE_REGISTER(process_exec, aio_proc_rundown_exec, ANY); kqueue_add_filteropts(EVFILT_AIO, &aio_filtops); kqueue_add_filteropts(EVFILT_LIO, &lio_filtops); TAILQ_INIT(&aio_freeproc); @@ -565,10 +561,19 @@ aio_free_entry(struct kaiocb *job) } static void -aio_proc_rundown_exec(void *arg, struct proc *p, - struct image_params *imgp __unused) +aio_proc_rundown_exit(void *arg) { - aio_proc_rundown(arg, p); + struct proc *p = arg; + + aio_proc_rundown(p); +} + +static void +aio_proc_rundown_exec(void *arg) +{ + struct process_exec_arg *pea = arg; + + aio_proc_rundown(pea->p); } static int @@ -626,7 +631,7 @@ aio_cancel_job(struct proc *p, struct kaioinfo *ki, struct kaiocb *job) * Rundown the jobs for a given process. */ static void -aio_proc_rundown(void *arg, struct proc *p) +aio_proc_rundown(struct proc *p) { struct kaioinfo *ki; struct aioliojob *lj; diff --git a/sys/sys/eventhandler.h b/sys/sys/eventhandler.h index d09c85651c58..634f8c526396 100644 --- a/sys/sys/eventhandler.h +++ b/sys/sys/eventhandler.h @@ -230,29 +230,6 @@ typedef void (*vfs_unmounted_notify_fn)(void *, struct mount *, EVENTHANDLER_DECLARE(vfs_mounted, vfs_mounted_notify_fn); EVENTHANDLER_DECLARE(vfs_unmounted, vfs_unmounted_notify_fn); -/* - * Process events - * process_fork and exit handlers are called without Giant. - * exec handlers are called with Giant, but that is by accident. - */ -struct proc; -struct image_params; - -typedef void (*exitlist_fn)(void *, struct proc *); -typedef void (*forklist_fn)(void *, struct proc *, struct proc *, int); -typedef void (*execlist_fn)(void *, struct proc *, struct image_params *); -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); - /* * application dump event */ diff --git a/sys/sys/proc.h b/sys/sys/proc.h index 36091db679d1..43c95d484695 100644 --- a/sys/sys/proc.h +++ b/sys/sys/proc.h @@ -1346,13 +1346,24 @@ void proc_id_set(int type, pid_t id); void proc_id_set_cond(int type, pid_t id); void proc_id_clear(int type, pid_t id); -EVENTHANDLER_LIST_DECLARE(process_ctor); -EVENTHANDLER_LIST_DECLARE(process_dtor); -EVENTHANDLER_LIST_DECLARE(process_init); -EVENTHANDLER_LIST_DECLARE(process_fini); -EVENTHANDLER_LIST_DECLARE(process_exit); -EVENTHANDLER_LIST_DECLARE(process_fork); -EVENTHANDLER_LIST_DECLARE(process_exec); +struct process_fork_arg { + struct proc *p1; + struct proc *p2; + int flags; +}; + +struct process_exec_arg { + struct proc *p; + struct image_params *imgp; +}; + +EVENTHANDLER_SLEEPABLE_DECLARE(process_ctor); +EVENTHANDLER_SLEEPABLE_DECLARE(process_dtor); +EVENTHANDLER_SLEEPABLE_DECLARE(process_init); +EVENTHANDLER_SLEEPABLE_DECLARE(process_fini); +EVENTHANDLER_SLEEPABLE_DECLARE(process_exit); +EVENTHANDLER_SLEEPABLE_DECLARE(process_fork); +EVENTHANDLER_SLEEPABLE_DECLARE(process_exec); EVENTHANDLER_SLEEPABLE_DECLARE(thread_ctor); EVENTHANDLER_SLEEPABLE_DECLARE(thread_dtor); -- 2.34.1