Return to xpr.c CVS log

Up to [Apple Darwin 0.x] / kernel / kern

Annotation of kernel/kern/xpr.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
        !             7:  * Reserved.  This file contains Original Code and/or Modifications of
        !             8:  * Original Code as defined in and that are subject to the Apple Public
        !             9:  * Source License Version 1.1 (the "License").  You may not use this file
        !            10:  * except in compliance with the License.  Please obtain a copy of the
        !            11:  * License at http://www.apple.com/publicsource and read it before using
        !            12:  * this file.
        !            13:  * 
        !            14:  * The Original Code and all software distributed under the License are
        !            15:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            16:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            17:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            18:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            19:  * License for the specific language governing rights and limitations
        !            20:  * under the License.
        !            21:  * 
        !            22:  * @APPLE_LICENSE_HEADER_END@
        !            23:  */
        !            24: 
        !            25: /* 
        !            26:  * Mach Operating System
        !            27:  * Copyright (c) 1989 Carnegie-Mellon University
        !            28:  * Copyright (c) 1988 Carnegie-Mellon University
        !            29:  * Copyright (c) 1987 Carnegie-Mellon University
        !            30:  * All rights reserved.  The CMU software License Agreement specifies
        !            31:  * the terms and conditions for use and redistribution.
        !            32:  */
        !            33: /*
        !            34:  * xpr silent tracing circular buffer.
        !            35:  */
        !            36: 
        !            37: #if    NeXT
        !            38: #define NO_IPLMEAS     1
        !            39: #endif NeXT
        !            40: 
        !            41: #import <kern/xpr.h>
        !            42: #import <kern/lock.h>
        !            43: #import <bsd/machine/cpu.h>
        !            44: #import <machine/param.h>              /* for splhigh */
        !            45: #import <vm/vm_kern.h>
        !            46: #import <machine/spl.h>
        !            47: 
        !            48: decl_simple_lock_data(,xprlock)
        !            49: 
        !            50: #if    NeXT
        !            51: /* always allocate xpr buffers so xprs can be enabled anytime */
        !            52: int nxprbufs = 512;    /* Number of contiguous xprbufs allocated */
        !            53: #else  NeXT
        !            54: int nxprbufs = 0;      /* Number of contiguous xprbufs allocated */
        !            55: #endif NeXT
        !            56: unsigned int xprflags = 0;     /* Bit mask of xpr flags enabled */
        !            57: unsigned int xprwrap = TRUE;   /* xpr's wrap in buf or just stop at end */
        !            58: struct xprbuf *xprbase;        /* Pointer to circular buffer nxprbufs*sizeof(xprbuf)*/
        !            59: struct xprbuf *xprptr; /* Currently allocated xprbuf */
        !            60: struct xprbuf *xprlast;        /* Pointer to end of circular buffer */
        !            61: unsigned xprlocked = 0;        /* when TRUE, disables logging */
        !            62: 
        !            63: /*VARARGS1*/
        !            64: xpr(msg, arg1, arg2, arg3, arg4, arg5, arg6)
        !            65:        char *msg;
        !            66: {
        !            67:        register s;
        !            68:        register struct xprbuf *x;
        !            69: 
        !            70: #ifdef lint
        !            71:        arg6++;
        !            72: #endif lint
        !            73: 
        !            74:        /* If we aren't initialized, ignore trace request */
        !            75:        if (!nxprbufs || xprptr == 0 || xprlocked)
        !            76:                return;
        !            77:        /* Guard against all interrupts and allocate next buffer */
        !            78:        s = splhigh();
        !            79:        simple_lock(&xprlock);
        !            80:        x = xprptr++;
        !            81:        if (xprptr >= xprlast) {
        !            82:                /* wrap around */
        !            83:                xprptr = xprwrap ? xprbase : xprlast - 1;
        !            84:        }
        !            85:        x->timestamp = XPR_TIMESTAMP;
        !            86:        simple_unlock(&xprlock);
        !            87:        splx(s);
        !            88:        x->msg = msg;
        !            89:        x->arg1 = arg1;
        !            90:        x->arg2 = arg2;
        !            91:        x->arg3 = arg3;
        !            92:        x->arg4 = arg4;
        !            93:        x->arg5 = arg5;
        !            94:        x->cpuinfo = cpu_number();
        !            95: }
        !            96: 
        !            97: xprbootstrap()
        !            98: {
        !            99:        simple_lock_init(&xprlock);
        !           100:        if (nxprbufs == 0 && xprflags == 0)
        !           101:                return; /* assume XPR support not desired */
        !           102:        else if (nxprbufs == 0)
        !           103:                nxprbufs=512;   /* if flags are set must do something */
        !           104:        xprbase = (struct xprbuf *)kmem_alloc(kernel_map, 
        !           105:                        (vm_size_t)(nxprbufs * sizeof(struct xprbuf)));
        !           106:        xprlast = &xprbase[nxprbufs];
        !           107:        xprptr = xprbase;
        !           108: }
        !           109: 
        !           110: int            xprinitial = 0;
        !           111: 
        !           112: xprinit()
        !           113: {
        !           114:        xprflags |= xprinitial;
        !           115: }
        !           116: 
        !           117: /*
        !           118:  *     Save 'number' of xpr buffers to the area provided by buffer.
        !           119:  */
        !           120: 
        !           121: xpr_save(buffer,number)
        !           122: struct xprbuf *buffer;
        !           123: int number;
        !           124: {
        !           125:     int i,s;
        !           126:     struct xprbuf *x;
        !           127:     s = splhigh();
        !           128:     simple_lock(&xprlock);
        !           129:     if (number > nxprbufs) number = nxprbufs;
        !           130:     x = xprptr;
        !           131:     
        !           132:     for (i = number - 1; i >= 0 ; i-- ) {
        !           133:        if (--x < xprbase) {
        !           134:            /* wrap around */
        !           135:            x = xprlast - 1;
        !           136:        }
        !           137:        bcopy(x,&buffer[i],sizeof(struct xprbuf));
        !           138:     }
        !           139:     simple_unlock(&xprlock);
        !           140:     splx(s);
        !           141: }

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