Return to hardclock.c CVS log

Up to [Apple XNU] / XNU / osfmk / i386

Annotation of XNU/osfmk/i386/hardclock.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * The contents of this file constitute Original Code as defined in and
        !             7:  * are subject to the Apple Public Source License Version 1.1 (the
        !             8:  * "License").  You may not use this file except in compliance with the
        !             9:  * License.  Please obtain a copy of the License at
        !            10:  * http://www.apple.com/publicsource and read it before using this file.
        !            11:  * 
        !            12:  * This Original Code and all software distributed under the License are
        !            13:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            14:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            15:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            16:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            17:  * License for the specific language governing rights and limitations
        !            18:  * under the License.
        !            19:  * 
        !            20:  * @APPLE_LICENSE_HEADER_END@
        !            21:  */
        !            22: /*
        !            23:  * @OSF_COPYRIGHT@
        !            24:  */
        !            25: /* 
        !            26:  * Mach Operating System
        !            27:  * Copyright (c) 1991,1990 Carnegie Mellon University
        !            28:  * All Rights Reserved.
        !            29:  * 
        !            30:  * Permission to use, copy, modify and distribute this software and its
        !            31:  * documentation is hereby granted, provided that both the copyright
        !            32:  * notice and this permission notice appear in all copies of the
        !            33:  * software, derivative works or modified versions, and any portions
        !            34:  * thereof, and that both notices appear in supporting documentation.
        !            35:  * 
        !            36:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
        !            37:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
        !            38:  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
        !            39:  * 
        !            40:  * Carnegie Mellon requests users of this software to return to
        !            41:  * 
        !            42:  *  Software Distribution Coordinator  or  [email protected]
        !            43:  *  School of Computer Science
        !            44:  *  Carnegie Mellon University
        !            45:  *  Pittsburgh PA 15213-3890
        !            46:  * 
        !            47:  * any improvements or extensions that they make and grant Carnegie Mellon
        !            48:  * the rights to redistribute these changes.
        !            49:  */
        !            50: /*
        !            51:  */
        !            52: 
        !            53: /*
        !            54:  * Clock interrupt.
        !            55:  */
        !            56: #include <cpus.h>
        !            57: #include <time_stamp.h>
        !            58: #include <mach_kdb.h>
        !            59: #include <kern/cpu_number.h>
        !            60: #include <kern/cpu_data.h>
        !            61: #include <kern/kern_types.h>
        !            62: #include <platforms.h>
        !            63: #include <mp_v1_1.h>
        !            64: #include <mach_kprof.h>
        !            65: #include <mach_mp_debug.h>
        !            66: #include <mach/std_types.h>
        !            67: 
        !            68: #include <mach/clock_types.h>
        !            69: #include <mach/boolean.h>
        !            70: #include <i386/thread.h>
        !            71: #include <i386/eflags.h>
        !            72: #include <kern/assert.h>
        !            73: #include <kern/misc_protos.h>
        !            74: #include <i386/misc_protos.h>
        !            75: #include <kern/time_out.h>
        !            76: 
        !            77: #include <i386/ipl.h>
        !            78: 
        !            79: #include <i386/hardclock_entries.h>
        !            80: #include <i386/rtclock_entries.h>
        !            81: 
        !            82: #if    MACH_MP_DEBUG
        !            83: #include <i386/mach_param.h>   /* for HZ */
        !            84: #endif /* MACH_MP_DEBUG */
        !            85: 
        !            86: extern char    return_to_iret[];
        !            87: 
        !            88: #if    TIME_STAMP && NCPUS > 1
        !            89: extern unsigned time_stamp;
        !            90: unsigned old_time_stamp, time_stamp_cum, nstamps;
        !            91: 
        !            92: /*
        !            93:  *     If H/W provides a counter, record number of ticks and cumulated
        !            94:  *     time stamps to know timestamps rate.
        !            95:  *     This should go away when ALARMCLOCKS installed
        !            96:  */
        !            97: #define time_stamp_stat()                                      \
        !            98:        if (my_cpu == 0)                                        \
        !            99:        if (!old_time_stamp) {                                  \
        !           100:                old_time_stamp = time_stamp;                    \
        !           101:                nstamps = 0;                                    \
        !           102:        } else {                                                \
        !           103:                nstamps++;                                      \
        !           104:                time_stamp_cum = (time_stamp - old_time_stamp); \
        !           105:        }
        !           106: #else  /* TIME_STAMP && AT386 && NCPUS > 1 */
        !           107: #define time_stamp_stat()
        !           108: #endif /* TIME_STAMP && AT386 && NCPUS > 1 */
        !           109: 
        !           110: #if    MACH_KPROF
        !           111: int    masked_pc[NCPUS];
        !           112: int    missed_clock[NCPUS];
        !           113: int    detect_lost_tick = 0;
        !           114: #endif /* MACH_KPROF */
        !           115: 
        !           116: #if    MACH_MP_DEBUG
        !           117: int    masked_state_cnt[NCPUS];
        !           118: int    masked_state_max = 10*HZ;
        !           119: #endif /* MACH_MP_DEBUG */
        !           120: 
        !           121: /*
        !           122:  * In the interest of a fast clock interrupt service path,
        !           123:  * this routine should be folded into assembly language with
        !           124:  * a direct interrupt vector on the i386. The "pit" interrupt
        !           125:  * should always call the rtclock_intr() routine on the master
        !           126:  * processor. The return value of the rtclock_intr() routine
        !           127:  * indicates whether HZ rate clock processing should be
        !           128:  * performed. (On the Sequent, all slave processors will
        !           129:  * run at HZ rate). For now, we'll leave this routine in C
        !           130:  * (with TIME_STAMP, MACH_MP_DEBUG and MACH_KPROF code this
        !           131:  * routine is way too large for assembler anyway).
        !           132:  */
        !           133: 
        !           134: #ifdef PARANOID_KDB
        !           135: int paranoid_debugger = TRUE;
        !           136: int paranoid_count = 1000;
        !           137: int paranoid_current = 0;
        !           138: int paranoid_cpu = 0;
        !           139: #endif /* PARANOID_KDB */
        !           140: 
        !           141: void
        !           142: hardclock(struct i386_interrupt_state  *regs) /* saved registers */
        !           143: {
        !           144:        int mycpu;
        !           145:        register unsigned pc;
        !           146:        register boolean_t usermode;
        !           147: 
        !           148:        mp_disable_preemption();
        !           149:        mycpu = cpu_number();
        !           150: 
        !           151: #ifdef PARANOID_KDB
        !           152:        if (paranoid_cpu == mycpu &&
        !           153:            paranoid_current++ >= paranoid_count) {
        !           154:                paranoid_current = 0;
        !           155:                if (paranoid_debugger)
        !           156:                    Debugger("hardclock");
        !           157:        }
        !           158: #endif /* PARANOID_KDB */
        !           159: 
        !           160: #if 0
        !           161: #if    MACH_MP_DEBUG
        !           162:        /*
        !           163:         * Increments counter of clock ticks handled under a masked state.
        !           164:         * Debugger() is called if masked state is kept during 1 sec.
        !           165:         * The counter is reset by splx() when ipl mask is set back to SPL0,
        !           166:         * and by spl0().
        !           167:         */
        !           168:        if (SPL_CMP_GT((old_ipl & 0xFF), SPL0)) {
        !           169:                if (masked_state_cnt[mycpu]++ >= masked_state_max) {
        !           170:                        int max_save = masked_state_max;
        !           171: 
        !           172:                        masked_state_cnt[mycpu] = 0;
        !           173:                        masked_state_max = 0x7fffffff;
        !           174: 
        !           175:                        if (ret_addr == return_to_iret) {
        !           176:                                usermode = (regs->efl & EFL_VM) ||
        !           177:                                                ((regs->cs & 0x03) != 0);
        !           178:                                pc = (unsigned)regs->eip;
        !           179:                        } else {
        !           180:                                usermode = FALSE;
        !           181:                                pc = (unsigned)
        !           182:                                ((struct i386_interrupt_state *)&old_ipl)->eip;
        !           183:                        }
        !           184:                        printf("looping at high IPL, usermode=%d pc=0x%x\n",
        !           185:                                        usermode, pc);
        !           186:                        Debugger("");
        !           187: 
        !           188:                        masked_state_cnt[mycpu] = 0;
        !           189:                        masked_state_max = max_save;
        !           190:                }
        !           191:        } else
        !           192:                masked_state_cnt[mycpu] = 0;
        !           193: #endif /* MACH_MP_DEBUG */
        !           194: #endif
        !           195: 
        !           196: #if    MACH_KPROF
        !           197:        /*
        !           198:         * If we were masked against the clock skip call
        !           199:         * to rtclock_intr(). When MACH_KPROF is set, the
        !           200:         * clock frequency of the master-cpu is confined
        !           201:         * to the HZ rate.
        !           202:         */
        !           203:        if (SPL_CMP_LT(old_ipl & 0xFF, SPL7))
        !           204: #endif /* MACH_KPROF */
        !           205:        /*
        !           206:         * The master processor executes the rtclock_intr() routine
        !           207:         * on every clock tick. The rtclock_intr() routine returns
        !           208:         * a zero value on a HZ tick boundary.
        !           209:         */
        !           210:        if (mycpu == master_cpu) {
        !           211:                if (rtclock_intr() != 0) {
        !           212:                        mp_enable_preemption();
        !           213:                        return;
        !           214:                }
        !           215:        }
        !           216: 
        !           217:        /*
        !           218:         * The following code is executed at HZ rate by all processors
        !           219:         * in the system. This implies that the clock rate on slave
        !           220:         * processors must be HZ rate.
        !           221:         */
        !           222: 
        !           223:        time_stamp_stat();
        !           224: 
        !           225: #if 0
        !           226:        if (ret_addr == return_to_iret) {
        !           227:                /*
        !           228:                 * A kernel-loaded task executing within itself will look like
        !           229:                 * "kernel mode", here.  This is correct with syscalls
        !           230:                 * implemented using migrating threads, because it means that  
        !           231:                 * the time spent in the server by a client thread will be
        !           232:                 * treated as "system" time for the client thread (and nothing
        !           233:                 * for the server).  This conforms to the CPU reporting for an
        !           234:                 * integrated kernel.
        !           235:                 */
        !           236: #endif
        !           237:                usermode = (regs->efl & EFL_VM) || ((regs->cs & 0x03) != 0);
        !           238:                pc = (unsigned)regs->eip;
        !           239: #if 0
        !           240:        } else {
        !           241:                usermode = FALSE;
        !           242:                pc = (unsigned)((struct i386_interrupt_state *)&old_ipl)->eip;
        !           243:        }
        !           244: #endif
        !           245: 
        !           246: #if    MACH_KPROF
        !           247:        /*
        !           248:         * If we were masked against the clock, just memorize pc
        !           249:         * and the fact that the clock interrupt is delayed
        !           250:         */
        !           251:        if (SPL_CMP_GE((old_ipl & 0xFF), SPL7)) {
        !           252:                assert(!usermode);
        !           253:                if (missed_clock[mycpu]++ && detect_lost_tick > 1)
        !           254:                        Debugger("Mach_KPROF");
        !           255:                masked_pc[mycpu] = pc;
        !           256:        } else
        !           257: #endif /* MACH_KPROF */
        !           258: 
        !           259:        hertz_tick(usermode, pc);
        !           260: 
        !           261: #if    NCPUS >1 
        !           262:        /*
        !           263:         * Instead of having the master processor interrupt
        !           264:         * all active processors, each processor in turn interrupts
        !           265:         * the next active one. This avoids all slave processors
        !           266:         * accessing the same R/W data simultaneously.
        !           267:         */
        !           268:        slave_clock();
        !           269: #endif /* NCPUS >1 && AT386 */
        !           270: 
        !           271:        mp_enable_preemption();
        !           272: }
        !           273: 
        !           274: #if    MACH_KPROF
        !           275: void
        !           276: delayed_clock(void)
        !           277: {
        !           278:        int     i;
        !           279:        int     my_cpu;
        !           280: 
        !           281:        mp_disable_preemption();
        !           282:        my_cpu = cpu_number();
        !           283: 
        !           284:        if (missed_clock[my_cpu] > 1 && detect_lost_tick)
        !           285:                printf("hardclock: missed %d clock interrupt(s) at %x\n",
        !           286:                       missed_clock[my_cpu]-1, masked_pc[my_cpu]);
        !           287:        if (my_cpu == master_cpu) {
        !           288:                i = rtclock_intr();
        !           289:                assert(i == 0);
        !           290:        }
        !           291:        hertz_tick(0, masked_pc[my_cpu]);
        !           292:        missed_clock[my_cpu] = 0;
        !           293: 
        !           294:        mp_enable_preemption();
        !           295: }
        !           296: #endif /* MACH_KPROF */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.