kern_clock.c revision 1.140
1 /* $NetBSD: kern_clock.c,v 1.140 2020/04/02 16:29:30 maxv Exp $ */ 2 3 /*- 4 * Copyright (c) 2000, 2004, 2006, 2007, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center. 10 * This code is derived from software contributed to The NetBSD Foundation 11 * by Charles M. Hannum. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 /*- 36 * Copyright (c) 1982, 1986, 1991, 1993 37 * The Regents of the University of California. All rights reserved. 38 * (c) UNIX System Laboratories, Inc. 39 * All or some portions of this file are derived from material licensed 40 * to the University of California by American Telephone and Telegraph 41 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 42 * the permission of UNIX System Laboratories, Inc. 43 * 44 * Redistribution and use in source and binary forms, with or without 45 * modification, are permitted provided that the following conditions 46 * are met: 47 * 1. Redistributions of source code must retain the above copyright 48 * notice, this list of conditions and the following disclaimer. 49 * 2. Redistributions in binary form must reproduce the above copyright 50 * notice, this list of conditions and the following disclaimer in the 51 * documentation and/or other materials provided with the distribution. 52 * 3. Neither the name of the University nor the names of its contributors 53 * may be used to endorse or promote products derived from this software 54 * without specific prior written permission. 55 * 56 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 57 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 59 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 60 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 61 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 62 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 63 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 64 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 65 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 66 * SUCH DAMAGE. 67 * 68 * @(#)kern_clock.c 8.5 (Berkeley) 1/21/94 69 */ 70 71 #include <sys/cdefs.h> 72 __KERNEL_RCSID(0, "$NetBSD: kern_clock.c,v 1.140 2020/04/02 16:29:30 maxv Exp $"); 73 74 #ifdef _KERNEL_OPT 75 #include "opt_dtrace.h" 76 #include "opt_gprof.h" 77 #endif 78 79 #include <sys/param.h> 80 #include <sys/systm.h> 81 #include <sys/callout.h> 82 #include <sys/kernel.h> 83 #include <sys/proc.h> 84 #include <sys/resourcevar.h> 85 #include <sys/signalvar.h> 86 #include <sys/sysctl.h> 87 #include <sys/timex.h> 88 #include <sys/sched.h> 89 #include <sys/time.h> 90 #include <sys/timetc.h> 91 #include <sys/cpu.h> 92 #include <sys/atomic.h> 93 94 #ifdef GPROF 95 #include <sys/gmon.h> 96 #endif 97 98 #ifdef KDTRACE_HOOKS 99 #include <sys/dtrace_bsd.h> 100 #include <sys/cpu.h> 101 102 cyclic_clock_func_t cyclic_clock_func[MAXCPUS]; 103 #endif 104 105 static int sysctl_kern_clockrate(SYSCTLFN_PROTO); 106 107 /* 108 * Clock handling routines. 109 * 110 * This code is written to operate with two timers that run independently of 111 * each other. The main clock, running hz times per second, is used to keep 112 * track of real time. The second timer handles kernel and user profiling, 113 * and does resource use estimation. If the second timer is programmable, 114 * it is randomized to avoid aliasing between the two clocks. For example, 115 * the randomization prevents an adversary from always giving up the CPU 116 * just before its quantum expires. Otherwise, it would never accumulate 117 * CPU ticks. The mean frequency of the second timer is stathz. 118 * 119 * If no second timer exists, stathz will be zero; in this case we drive 120 * profiling and statistics off the main clock. This WILL NOT be accurate; 121 * do not do it unless absolutely necessary. 122 * 123 * The statistics clock may (or may not) be run at a higher rate while 124 * profiling. This profile clock runs at profhz. We require that profhz 125 * be an integral multiple of stathz. 126 * 127 * If the statistics clock is running fast, it must be divided by the ratio 128 * profhz/stathz for statistics. (For profiling, every tick counts.) 129 */ 130 131 int stathz; 132 int profhz; 133 int profsrc; 134 int schedhz; 135 int profprocs; 136 int hardclock_ticks; 137 static int hardscheddiv; /* hard => sched divider (used if schedhz == 0) */ 138 static int psdiv; /* prof => stat divider */ 139 int psratio; /* ratio: prof / stat */ 140 141 static u_int get_intr_timecount(struct timecounter *); 142 143 static struct timecounter intr_timecounter = { 144 .tc_get_timecount = get_intr_timecount, 145 .tc_poll_pps = NULL, 146 .tc_counter_mask = ~0u, 147 .tc_frequency = 0, 148 .tc_name = "clockinterrupt", 149 /* quality - minimum implementation level for a clock */ 150 .tc_quality = 0, 151 .tc_priv = NULL, 152 }; 153 154 static u_int 155 get_intr_timecount(struct timecounter *tc) 156 { 157 158 return (u_int)getticks(); 159 } 160 161 int 162 getticks(void) 163 { 164 return atomic_load_relaxed(&hardclock_ticks); 165 } 166 167 /* 168 * Initialize clock frequencies and start both clocks running. 169 */ 170 void 171 initclocks(void) 172 { 173 static struct sysctllog *clog; 174 int i; 175 176 /* 177 * Set divisors to 1 (normal case) and let the machine-specific 178 * code do its bit. 179 */ 180 psdiv = 1; 181 /* 182 * provide minimum default time counter 183 * will only run at interrupt resolution 184 */ 185 intr_timecounter.tc_frequency = hz; 186 tc_init(&intr_timecounter); 187 cpu_initclocks(); 188 189 /* 190 * Compute profhz and stathz, fix profhz if needed. 191 */ 192 i = stathz ? stathz : hz; 193 if (profhz == 0) 194 profhz = i; 195 psratio = profhz / i; 196 if (schedhz == 0) { 197 /* 16Hz is best */ 198 hardscheddiv = hz / 16; 199 if (hardscheddiv <= 0) 200 panic("hardscheddiv"); 201 } 202 203 sysctl_createv(&clog, 0, NULL, NULL, 204 CTLFLAG_PERMANENT, 205 CTLTYPE_STRUCT, "clockrate", 206 SYSCTL_DESCR("Kernel clock rates"), 207 sysctl_kern_clockrate, 0, NULL, 208 sizeof(struct clockinfo), 209 CTL_KERN, KERN_CLOCKRATE, CTL_EOL); 210 sysctl_createv(&clog, 0, NULL, NULL, 211 CTLFLAG_PERMANENT, 212 CTLTYPE_INT, "hardclock_ticks", 213 SYSCTL_DESCR("Number of hardclock ticks"), 214 NULL, 0, &hardclock_ticks, sizeof(hardclock_ticks), 215 CTL_KERN, KERN_HARDCLOCK_TICKS, CTL_EOL); 216 } 217 218 /* 219 * The real-time timer, interrupting hz times per second. 220 */ 221 void 222 hardclock(struct clockframe *frame) 223 { 224 struct lwp *l; 225 struct cpu_info *ci; 226 227 ci = curcpu(); 228 l = ci->ci_onproc; 229 230 timer_tick(l, CLKF_USERMODE(frame)); 231 232 /* 233 * If no separate statistics clock is available, run it from here. 234 */ 235 if (stathz == 0) 236 statclock(frame); 237 /* 238 * If no separate schedclock is provided, call it here 239 * at about 16 Hz. 240 */ 241 if (schedhz == 0) { 242 if ((int)(--ci->ci_schedstate.spc_schedticks) <= 0) { 243 schedclock(l); 244 ci->ci_schedstate.spc_schedticks = hardscheddiv; 245 } 246 } 247 if ((--ci->ci_schedstate.spc_ticks) <= 0) 248 sched_tick(ci); 249 250 if (CPU_IS_PRIMARY(ci)) { 251 atomic_store_relaxed(&hardclock_ticks, 252 atomic_load_relaxed(&hardclock_ticks) + 1); 253 tc_ticktock(); 254 } 255 256 /* 257 * Update real-time timeout queue. 258 */ 259 callout_hardclock(); 260 261 #ifdef KDTRACE_HOOKS 262 cyclic_clock_func_t func = cyclic_clock_func[cpu_index(ci)]; 263 if (func) { 264 (*func)((struct clockframe *)frame); 265 } 266 #endif 267 } 268 269 /* 270 * Start profiling on a process. 271 * 272 * Kernel profiling passes proc0 which never exits and hence 273 * keeps the profile clock running constantly. 274 */ 275 void 276 startprofclock(struct proc *p) 277 { 278 279 KASSERT(mutex_owned(&p->p_stmutex)); 280 281 if ((p->p_stflag & PST_PROFIL) == 0) { 282 p->p_stflag |= PST_PROFIL; 283 /* 284 * This is only necessary if using the clock as the 285 * profiling source. 286 */ 287 if (++profprocs == 1 && stathz != 0) 288 psdiv = psratio; 289 } 290 } 291 292 /* 293 * Stop profiling on a process. 294 */ 295 void 296 stopprofclock(struct proc *p) 297 { 298 299 KASSERT(mutex_owned(&p->p_stmutex)); 300 301 if (p->p_stflag & PST_PROFIL) { 302 p->p_stflag &= ~PST_PROFIL; 303 /* 304 * This is only necessary if using the clock as the 305 * profiling source. 306 */ 307 if (--profprocs == 0 && stathz != 0) 308 psdiv = 1; 309 } 310 } 311 312 void 313 schedclock(struct lwp *l) 314 { 315 if ((l->l_flag & LW_IDLE) != 0) 316 return; 317 318 sched_schedclock(l); 319 } 320 321 /* 322 * Statistics clock. Grab profile sample, and if divider reaches 0, 323 * do process and kernel statistics. 324 */ 325 void 326 statclock(struct clockframe *frame) 327 { 328 #ifdef GPROF 329 struct gmonparam *g; 330 intptr_t i; 331 #endif 332 struct cpu_info *ci = curcpu(); 333 struct schedstate_percpu *spc = &ci->ci_schedstate; 334 struct proc *p; 335 struct lwp *l; 336 337 /* 338 * Notice changes in divisor frequency, and adjust clock 339 * frequency accordingly. 340 */ 341 if (spc->spc_psdiv != psdiv) { 342 spc->spc_psdiv = psdiv; 343 spc->spc_pscnt = psdiv; 344 if (psdiv == 1) { 345 setstatclockrate(stathz); 346 } else { 347 setstatclockrate(profhz); 348 } 349 } 350 l = ci->ci_onproc; 351 if ((l->l_flag & LW_IDLE) != 0) { 352 /* 353 * don't account idle lwps as swapper. 354 */ 355 p = NULL; 356 } else { 357 p = l->l_proc; 358 mutex_spin_enter(&p->p_stmutex); 359 } 360 361 if (CLKF_USERMODE(frame)) { 362 KASSERT(p != NULL); 363 if ((p->p_stflag & PST_PROFIL) && profsrc == PROFSRC_CLOCK) 364 addupc_intr(l, CLKF_PC(frame)); 365 if (--spc->spc_pscnt > 0) { 366 mutex_spin_exit(&p->p_stmutex); 367 return; 368 } 369 370 /* 371 * Came from user mode; CPU was in user state. 372 * If this process is being profiled record the tick. 373 */ 374 p->p_uticks++; 375 if (p->p_nice > NZERO) 376 spc->spc_cp_time[CP_NICE]++; 377 else 378 spc->spc_cp_time[CP_USER]++; 379 } else { 380 #ifdef GPROF 381 /* 382 * Kernel statistics are just like addupc_intr, only easier. 383 */ 384 g = &_gmonparam; 385 if (profsrc == PROFSRC_CLOCK && g->state == GMON_PROF_ON) { 386 i = CLKF_PC(frame) - g->lowpc; 387 if (i < g->textsize) { 388 i /= HISTFRACTION * sizeof(*g->kcount); 389 g->kcount[i]++; 390 } 391 } 392 #endif 393 #ifdef LWP_PC 394 if (p != NULL && profsrc == PROFSRC_CLOCK && 395 (p->p_stflag & PST_PROFIL)) { 396 addupc_intr(l, LWP_PC(l)); 397 } 398 #endif 399 if (--spc->spc_pscnt > 0) { 400 if (p != NULL) 401 mutex_spin_exit(&p->p_stmutex); 402 return; 403 } 404 /* 405 * Came from kernel mode, so we were: 406 * - handling an interrupt, 407 * - doing syscall or trap work on behalf of the current 408 * user process, or 409 * - spinning in the idle loop. 410 * Whichever it is, charge the time as appropriate. 411 * Note that we charge interrupts to the current process, 412 * regardless of whether they are ``for'' that process, 413 * so that we know how much of its real time was spent 414 * in ``non-process'' (i.e., interrupt) work. 415 */ 416 if (CLKF_INTR(frame) || (curlwp->l_pflag & LP_INTR) != 0) { 417 if (p != NULL) { 418 p->p_iticks++; 419 } 420 spc->spc_cp_time[CP_INTR]++; 421 } else if (p != NULL) { 422 p->p_sticks++; 423 spc->spc_cp_time[CP_SYS]++; 424 } else { 425 spc->spc_cp_time[CP_IDLE]++; 426 } 427 } 428 spc->spc_pscnt = psdiv; 429 430 if (p != NULL) { 431 atomic_inc_uint(&l->l_cpticks); 432 mutex_spin_exit(&p->p_stmutex); 433 } 434 } 435 436 /* 437 * sysctl helper routine for kern.clockrate. Assembles a struct on 438 * the fly to be returned to the caller. 439 */ 440 static int 441 sysctl_kern_clockrate(SYSCTLFN_ARGS) 442 { 443 struct clockinfo clkinfo; 444 struct sysctlnode node; 445 446 clkinfo.tick = tick; 447 clkinfo.tickadj = tickadj; 448 clkinfo.hz = hz; 449 clkinfo.profhz = profhz; 450 clkinfo.stathz = stathz ? stathz : hz; 451 452 node = *rnode; 453 node.sysctl_data = &clkinfo; 454 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 455 } 456
Indexes created Fri Sep 26 20:09:58 GMT 2025