diff options
author | jb <jb@FreeBSD.org> | 2008-05-22 08:35:03 +0000 |
---|---|---|
committer | jb <jb@FreeBSD.org> | 2008-05-22 08:35:03 +0000 |
commit | 40f3835db091981f96c010c7c42334f1afd54502 (patch) | |
tree | 591384dc9e56aaa23c06b523fbc25cb19f432e18 /sys/cddl | |
parent | 6b3503f4ce2dbcd5ac88fc822164d8c9d9a61457 (diff) | |
download | FreeBSD-src-40f3835db091981f96c010c7c42334f1afd54502.zip FreeBSD-src-40f3835db091981f96c010c7c42334f1afd54502.tar.gz |
Additional compatibility headers.
Diffstat (limited to 'sys/cddl')
-rw-r--r-- | sys/cddl/compat/opensolaris/sys/cpuvar_defs.h | 59 | ||||
-rw-r--r-- | sys/cddl/compat/opensolaris/sys/cyclic_impl.h | 304 | ||||
-rw-r--r-- | sys/cddl/compat/opensolaris/sys/sema.h | 40 |
3 files changed, 403 insertions, 0 deletions
diff --git a/sys/cddl/compat/opensolaris/sys/cpuvar_defs.h b/sys/cddl/compat/opensolaris/sys/cpuvar_defs.h new file mode 100644 index 0000000..d99eaea --- /dev/null +++ b/sys/cddl/compat/opensolaris/sys/cpuvar_defs.h @@ -0,0 +1,59 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _COMPAT_OPENSOLARIS_SYS_CPUVAR_DEFS_H +#define _COMPAT_OPENSOLARIS_SYS_CPUVAR_DEFS_H + +/* + * DTrace flags. + */ +#define CPU_DTRACE_NOFAULT 0x0001 /* Don't fault */ +#define CPU_DTRACE_DROP 0x0002 /* Drop this ECB */ +#define CPU_DTRACE_BADADDR 0x0004 /* DTrace fault: bad address */ +#define CPU_DTRACE_BADALIGN 0x0008 /* DTrace fault: bad alignment */ +#define CPU_DTRACE_DIVZERO 0x0010 /* DTrace fault: divide by zero */ +#define CPU_DTRACE_ILLOP 0x0020 /* DTrace fault: illegal operation */ +#define CPU_DTRACE_NOSCRATCH 0x0040 /* DTrace fault: out of scratch */ +#define CPU_DTRACE_KPRIV 0x0080 /* DTrace fault: bad kernel access */ +#define CPU_DTRACE_UPRIV 0x0100 /* DTrace fault: bad user access */ +#define CPU_DTRACE_TUPOFLOW 0x0200 /* DTrace fault: tuple stack overflow */ +#if defined(__sparc) +#define CPU_DTRACE_FAKERESTORE 0x0400 /* pid provider hint to getreg */ +#endif +#define CPU_DTRACE_ENTRY 0x0800 /* pid provider hint to ustack() */ +#define CPU_DTRACE_BADSTACK 0x1000 /* DTrace fault: bad stack */ + +#define CPU_DTRACE_FAULT (CPU_DTRACE_BADADDR | CPU_DTRACE_BADALIGN | \ + CPU_DTRACE_DIVZERO | CPU_DTRACE_ILLOP | \ + CPU_DTRACE_NOSCRATCH | CPU_DTRACE_KPRIV | \ + CPU_DTRACE_UPRIV | CPU_DTRACE_TUPOFLOW | \ + CPU_DTRACE_BADSTACK) +#define CPU_DTRACE_ERROR (CPU_DTRACE_FAULT | CPU_DTRACE_DROP) + +#define PANICSTKSIZE 8192 +#define REGSIZE 256 + +#endif /* _COMPAT_OPENSOLARIS_SYS_CPUVAR_DEFS_H */ diff --git a/sys/cddl/compat/opensolaris/sys/cyclic_impl.h b/sys/cddl/compat/opensolaris/sys/cyclic_impl.h new file mode 100644 index 0000000..a195251 --- /dev/null +++ b/sys/cddl/compat/opensolaris/sys/cyclic_impl.h @@ -0,0 +1,304 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + * + * $FreeBSD$ + * + */ +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _COMPAT_OPENSOLARIS_SYS_CYCLIC_IMPL_H_ +#define _COMPAT_OPENSOLARIS_SYS_CYCLIC_IMPL_H_ + +#include <sys/cyclic.h> + +/* + * Cyclic Subsystem Backend-supplied Interfaces + * -------------------------------------------- + * + * 0 Background + * + * The design, implementation and interfaces of the cyclic subsystem are + * covered in detail in block comments in the implementation. This + * comment covers the interface from the cyclic subsystem into the cyclic + * backend. The backend is specified by a structure of function pointers + * defined below. + * + * 1 Overview + * + * cyb_configure() <-- Configures the backend on the specified CPU + * cyb_unconfigure() <-- Unconfigures the backend + * cyb_enable() <-- Enables the CY_HIGH_LEVEL interrupt source + * cyb_disable() <-- Disables the CY_HIGH_LEVEL interrupt source + * cyb_reprogram() <-- Reprograms the CY_HIGH_LEVEL interrupt source + * cyb_xcall() <-- Cross calls to the specified CPU + * + * 2 cyb_arg_t cyb_configure(cpu_t *) + * + * 2.1 Overview + * + * cyb_configure() should configure the specified CPU for cyclic operation. + * + * 2.2 Arguments and notes + * + * cyb_configure() should initialize any backend-specific per-CPU + * structures for the specified CPU. cyb_configure() will be called for + * each CPU (including the boot CPU) during boot. If the platform + * supports dynamic reconfiguration, cyb_configure() will be called for + * new CPUs as they are configured into the system. + * + * 2.3 Return value + * + * cyb_configure() is expected to return a cookie (a cyb_arg_t, which is + * of type void *) which will be used as the first argument for all future + * cyclic calls into the backend on the specified CPU. + * + * 2.4 Caller's context + * + * cpu_lock will be held. The caller's CPU is unspecified, and may or + * may not be the CPU specified to cyb_configure(). + * + * 3 void cyb_unconfigure(cyb_arg_t arg) + * + * 3.1 Overview + * + * cyb_unconfigure() should unconfigure the specified backend. + * + * 3.2 Arguments and notes + * + * The only argument to cyb_unconfigure() is a cookie as returned from + * cyb_configure(). + * + * cyb_unconfigure() should free any backend-specific per-CPU structures + * for the specified backend. cyb_unconfigure() will _only_ be called on + * platforms which support dynamic reconfiguration. If the platform does + * not support dynamic reconfiguration, cyb_unconfigure() may panic. + * + * After cyb_unconfigure() returns, the backend must not call cyclic_fire() + * on the corresponding CPU; doing so will result in a bad trap. + * + * 3.3 Return value + * + * None. + * + * 3.4 Caller's context + * + * cpu_lock will be held. The caller's CPU is unspecified, and may or + * may not be the CPU specified to cyb_unconfigure(). The specified + * CPU is guaranteed to exist at the time cyb_unconfigure() is called. + * The cyclic subsystem is guaranteed to be suspended when cyb_unconfigure() + * is called, and interrupts are guaranteed to be disabled. + * + * 4 void cyb_enable(cyb_arg_t arg) + * + * 4.1 Overview + * + * cyb_enable() should enable the CY_HIGH_LEVEL interrupt source on + * the specified backend. + * + * 4.2 Arguments and notes + * + * The only argument to cyb_enable() is a backend cookie as returned from + * cyb_configure(). + * + * cyb_enable() will only be called if a) the specified backend has never + * been enabled or b) the specified backend has been explicitly disabled with + * cyb_disable(). In either case, cyb_enable() will only be called if + * the cyclic subsystem wishes to add a cyclic to the CPU corresponding + * to the specified backend. cyb_enable() will be called before + * cyb_reprogram() for a given backend. + * + * cyclic_fire() should not be called on a CPU which has not had its backend + * explicitly cyb_enable()'d, but to do so does not constitute fatal error. + * + * 4.3 Return value + * + * None. + * + * 4.4 Caller's context + * + * cyb_enable() will only be called from CY_HIGH_LEVEL context on the CPU + * corresponding to the specified backend. + * + * 5 void cyb_disable(cyb_arg_t arg) + * + * 5.1 Overview + * + * cyb_disable() should disable the CY_HIGH_LEVEL interrupt source on + * the specified backend. + * + * 5.2 Arguments and notes + * + * The only argument to cyb_disable() is a backend cookie as returned from + * cyb_configure(). + * + * cyb_disable() will only be called on backends which have been previously + * been cyb_enable()'d. cyb_disable() will be called when all cyclics have + * been juggled away or removed from a cyb_enable()'d CPU. + * + * cyclic_fire() should not be called on a CPU which has had its backend + * explicitly cyb_disable()'d, but to do so does not constitute fatal + * error. cyb_disable() is thus not required to check for a pending + * CY_HIGH_LEVEL interrupt. + * + * 5.3 Return value + * + * None. + * + * 5.4 Caller's context + * + * cyb_disable() will only be called from CY_HIGH_LEVEL context on the CPU + * corresponding to the specified backend. + * + * 6 void cyb_reprogram(cyb_arg_t arg, hrtime_t time) + * + * 6.1 Overview + * + * cyb_reprogram() should reprogram the CY_HIGH_LEVEL interrupt source + * to fire at the absolute time specified. + * + * 6.2 Arguments and notes + * + * The first argument to cyb_reprogram() is a backend cookie as returned from + * cyb_configure(). + * + * The second argument is an absolute time at which the CY_HIGH_LEVEL + * interrupt should fire. The specified time _may_ be in the past (albeit + * the very recent past). If this is the case, the backend should generate + * a CY_HIGH_LEVEL interrupt as soon as possible. + * + * The platform should not assume that cyb_reprogram() will be called with + * monotonically increasing values. + * + * If the platform does not allow for interrupts at arbitrary times in the + * future, cyb_reprogram() may do nothing -- as long as cyclic_fire() is + * called periodically at CY_HIGH_LEVEL. While this is clearly suboptimal + * (cyclic granularity will be bounded by the length of the period between + * cyclic_fire()'s), it allows the cyclic subsystem to be implemented on + * inferior hardware. + * + * 6.3 Return value + * + * None. + * + * 6.4 Caller's context + * + * cyb_reprogram() will only be called from CY_HIGH_LEVEL context on the CPU + * corresponding to the specified backend. + * + * 10 cyb_xcall(cyb_arg_t arg, cpu_t *, void(*func)(void *), void *farg) + * + * 10.1 Overview + * + * cyb_xcall() should execute the specified function on the specified CPU. + * + * 10.2 Arguments and notes + * + * The first argument to cyb_restore_level() is a backend cookie as returned + * from cyb_configure(). The second argument is a CPU on which the third + * argument, a function pointer, should be executed. The fourth argument, + * a void *, should be passed as the argument to the specified function. + * + * cyb_xcall() must provide exactly-once semantics. If the specified + * function is called more than once, or not at all, the cyclic subsystem + * will become internally inconsistent. The specified function must be + * be executed on the specified CPU, but may be executed in any context + * (any interrupt context or kernel context). + * + * cyb_xcall() cannot block. Any resources which cyb_xcall() needs to + * acquire must thus be protected by synchronization primitives which + * never require the caller to block. + * + * 10.3 Return value + * + * None. + * + * 10.4 Caller's context + * + * cpu_lock will be held and kernel preemption may be disabled. The caller + * may be unable to block, giving rise to the constraint outlined in + * 10.2, above. + * + */ +typedef struct cyc_backend { + cyb_arg_t (*cyb_configure)(cpu_t *); + void (*cyb_unconfigure)(cyb_arg_t); + void (*cyb_enable)(cyb_arg_t); + void (*cyb_disable)(cyb_arg_t); + void (*cyb_reprogram)(cyb_arg_t, hrtime_t); + void (*cyb_xcall)(cyb_arg_t, cpu_t *, cyc_func_t, void *); + cyb_arg_t cyb_arg; +} cyc_backend_t; + +#define CYF_FREE 0x0001 + +typedef struct cyclic { + hrtime_t cy_expire; + hrtime_t cy_interval; + void (*cy_handler)(void *); + void *cy_arg; + uint16_t cy_flags; +} cyclic_t; + +typedef struct cyc_cpu { + cpu_t *cyp_cpu; + cyc_index_t *cyp_heap; + cyclic_t *cyp_cyclics; + cyc_index_t cyp_nelems; + cyc_index_t cyp_size; + cyc_backend_t *cyp_backend; + struct mtx cyp_mtx; +} cyc_cpu_t; + +typedef struct cyc_omni_cpu { + cyc_cpu_t *cyo_cpu; + cyc_index_t cyo_ndx; + void *cyo_arg; + struct cyc_omni_cpu *cyo_next; +} cyc_omni_cpu_t; + +typedef struct cyc_id { + cyc_cpu_t *cyi_cpu; + cyc_index_t cyi_ndx; + struct cyc_id *cyi_prev; + struct cyc_id *cyi_next; + cyc_omni_handler_t cyi_omni_hdlr; + cyc_omni_cpu_t *cyi_omni_list; +} cyc_id_t; + +typedef struct cyc_xcallarg { + cyc_cpu_t *cyx_cpu; + hrtime_t cyx_exp; +} cyc_xcallarg_t; + +#define CY_DEFAULT_PERCPU 1 +#define CY_PASSIVE_LEVEL -1 + +#define CY_WAIT 0 +#define CY_NOWAIT 1 + +#define CYC_HEAP_PARENT(ndx) (((ndx) - 1) >> 1) +#define CYC_HEAP_RIGHT(ndx) (((ndx) + 1) << 1) +#define CYC_HEAP_LEFT(ndx) ((((ndx) + 1) << 1) - 1) + +#endif diff --git a/sys/cddl/compat/opensolaris/sys/sema.h b/sys/cddl/compat/opensolaris/sys/sema.h new file mode 100644 index 0000000..08e4721 --- /dev/null +++ b/sys/cddl/compat/opensolaris/sys/sema.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2007 John Birrell <jb@freebsd.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + * + */ + +#ifndef _COMPAT_OPENSOLARIS_SYS_SEMA_H_ +#define _COMPAT_OPENSOLARIS_SYS_SEMA_H_ + +#include_next <sys/sema.h> + +typedef struct sema ksema_t; + +#define sema_p sema_post +#define sema_v sema_value + +#endif |