sysmon_taskq.c revision 1.15
1 /* $NetBSD: sysmon_taskq.c,v 1.15 2015/04/23 23:22:03 pgoyette Exp $ */ 2 3 /* 4 * Copyright (c) 2001, 2003 Wasabi Systems, Inc. 5 * All rights reserved. 6 * 7 * Written by Jason R. Thorpe for Wasabi Systems, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed for the NetBSD Project by 20 * Wasabi Systems, Inc. 21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse 22 * or promote products derived from this software without specific prior 23 * written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 /* 39 * General purpose task queue for sysmon back-ends. This can be 40 * used to run callbacks that require thread context. 41 */ 42 43 #include <sys/cdefs.h> 44 __KERNEL_RCSID(0, "$NetBSD: sysmon_taskq.c,v 1.15 2015/04/23 23:22:03 pgoyette Exp $"); 45 46 #include <sys/param.h> 47 #include <sys/malloc.h> 48 #include <sys/queue.h> 49 #include <sys/proc.h> 50 #include <sys/kthread.h> 51 #include <sys/systm.h> 52 #include <sys/module.h> 53 54 #include <dev/sysmon/sysmon_taskq.h> 55 56 struct sysmon_task { 57 TAILQ_ENTRY(sysmon_task) st_list; 58 void (*st_func)(void *); 59 void *st_arg; 60 u_int st_pri; 61 }; 62 63 static TAILQ_HEAD(, sysmon_task) sysmon_task_queue = 64 TAILQ_HEAD_INITIALIZER(sysmon_task_queue); 65 66 static kmutex_t sysmon_task_queue_mtx; 67 static kmutex_t sysmon_task_queue_init_mtx; 68 static kcondvar_t sysmon_task_queue_cv; 69 70 static int sysmon_task_queue_initialized; 71 static int sysmon_task_queue_cleanup_sem; 72 static struct lwp *sysmon_task_queue_lwp; 73 static void sysmon_task_queue_thread(void *); 74 75 MODULE(MODULE_CLASS_MISC, sysmon_taskq, NULL); 76 77 /* 78 * XXX Normally, all initialization would be handled as part of 79 * the module(9) framework. However, there are a number of 80 * users of the sysmon_taskq facility that are not modular, 81 * and these can directly call sysmon_task_queue_init() 82 * directly. To accomodate these non-standard users, we 83 * make sure that sysmon_task_queue_init() handles multiple 84 * invocations. And we also ensure that, if any non-module 85 * user exists, we don't allow the module to be unloaded. 86 * (We can't use module_hold() for this, since the module(9) 87 * framework itself isn't necessarily initialized yet.) 88 */ 89 90 /* 91 * sysmon_task_queue_preinit: 92 * 93 * Early one-time initialization of task-queue 94 */ 95 void 96 sysmon_task_queue_preinit(void) 97 { 98 99 mutex_init(&sysmon_task_queue_mtx, MUTEX_DEFAULT, IPL_VM); 100 mutex_init(&sysmon_task_queue_init_mtx, MUTEX_DEFAULT, IPL_NONE); 101 cv_init(&sysmon_task_queue_cv, "smtaskq"); 102 sysmon_task_queue_initialized = 0; 103 } 104 105 /* 106 * sysmon_task_queue_init: 107 * 108 * Initialize the sysmon task queue. 109 */ 110 void 111 sysmon_task_queue_init(void) 112 { 113 int error; 114 115 mutex_enter(&sysmon_task_queue_init_mtx); 116 if (sysmon_task_queue_initialized++) { 117 mutex_exit(&sysmon_task_queue_init_mtx); 118 return; 119 } 120 121 mutex_exit(&sysmon_task_queue_init_mtx); 122 123 error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, 124 sysmon_task_queue_thread, NULL, &sysmon_task_queue_lwp, "sysmon"); 125 if (error) { 126 printf("Unable to create sysmon task queue thread, " 127 "error = %d\n", error); 128 panic("sysmon_task_queue_init"); 129 } 130 } 131 132 /* 133 * sysmon_task_queue_fini: 134 * 135 * Tear town the sysmon task queue. 136 */ 137 void 138 sysmon_task_queue_fini(void) 139 { 140 141 if (sysmon_task_queue_initialized > 1) 142 return EBUSY; 143 144 mutex_enter(&sysmon_task_queue_mtx); 145 146 sysmon_task_queue_cleanup_sem = 1; 147 cv_signal(&sysmon_task_queue_cv); 148 149 while (sysmon_task_queue_cleanup_sem != 0) 150 cv_wait(&sysmon_task_queue_cv, 151 &sysmon_task_queue_mtx); 152 153 mutex_exit(&sysmon_task_queue_mtx); 154 } 155 156 /* 157 * sysmon_task_queue_thread: 158 * 159 * The sysmon task queue execution thread. We execute callbacks that 160 * have been queued for us. 161 */ 162 static void 163 sysmon_task_queue_thread(void *arg) 164 { 165 struct sysmon_task *st; 166 167 /* 168 * Run through all the tasks before we check for the exit 169 * condition; it's probably more important to actually run 170 * all the tasks before we exit. 171 */ 172 mutex_enter(&sysmon_task_queue_mtx); 173 for (;;) { 174 st = TAILQ_FIRST(&sysmon_task_queue); 175 if (st != NULL) { 176 TAILQ_REMOVE(&sysmon_task_queue, st, st_list); 177 mutex_exit(&sysmon_task_queue_mtx); 178 (*st->st_func)(st->st_arg); 179 free(st, M_TEMP); 180 mutex_enter(&sysmon_task_queue_mtx); 181 } else { 182 /* Check for the exit condition. */ 183 if (sysmon_task_queue_cleanup_sem != 0) 184 break; 185 cv_wait(&sysmon_task_queue_cv, &sysmon_task_queue_mtx); 186 } 187 } 188 /* Time to die. */ 189 sysmon_task_queue_cleanup_sem = 0; 190 cv_broadcast(&sysmon_task_queue_cv); 191 mutex_exit(&sysmon_task_queue_mtx); 192 kthread_exit(0); 193 } 194 195 /* 196 * sysmon_task_queue_sched: 197 * 198 * Schedule a task for deferred execution. 199 */ 200 int 201 sysmon_task_queue_sched(u_int pri, void (*func)(void *), void *arg) 202 { 203 struct sysmon_task *st, *lst; 204 205 if (sysmon_task_queue_lwp == NULL) 206 aprint_debug("WARNING: Callback scheduled before sysmon " 207 "task queue thread present\n"); 208 209 if (func == NULL) 210 return EINVAL; 211 212 st = malloc(sizeof(*st), M_TEMP, M_NOWAIT); 213 if (st == NULL) 214 return ENOMEM; 215 216 st->st_func = func; 217 st->st_arg = arg; 218 st->st_pri = pri; 219 220 mutex_enter(&sysmon_task_queue_mtx); 221 TAILQ_FOREACH(lst, &sysmon_task_queue, st_list) { 222 if (st->st_pri > lst->st_pri) { 223 TAILQ_INSERT_BEFORE(lst, st, st_list); 224 break; 225 } 226 } 227 228 if (lst == NULL) 229 TAILQ_INSERT_TAIL(&sysmon_task_queue, st, st_list); 230 231 cv_broadcast(&sysmon_task_queue_cv); 232 mutex_exit(&sysmon_task_queue_mtx); 233 234 return 0; 235 } 236 237 static 238 int 239 sysmon_taskq_modcmd(modcmd_t cmd, void *arg) 240 { 241 int ret; 242 243 switch (cmd) { 244 case MODULE_CMD_INIT: 245 #ifdef _MODULE 246 sysmon_task_queue_preinit(); 247 #endif 248 sysmon_task_queue_init(); 249 ret = 0; 250 break; 251 252 case MODULE_CMD_FINI: 253 sysmon_task_queue_fini(); 254 ret = 0; 255 break; 256 257 case MODULE_CMD_STAT: 258 default: 259 ret = ENOTTY; 260 } 261 262 return ret; 263 } 264
Indexes created Sun Sep 21 20:09:37 GMT 2025