diff options
author | dufault <dufault@FreeBSD.org> | 1998-03-04 10:27:00 +0000 |
---|---|---|
committer | dufault <dufault@FreeBSD.org> | 1998-03-04 10:27:00 +0000 |
commit | e28788f2a420e093ade000eeb0ba96634af0e177 (patch) | |
tree | ed01e5e208cef9b87e2f87e523c53a779b5e241b /sys/posix4 | |
parent | 8893ec06df8a340a0fd561e62ae140190cf3c832 (diff) | |
download | FreeBSD-src-e28788f2a420e093ade000eeb0ba96634af0e177.zip FreeBSD-src-e28788f2a420e093ade000eeb0ba96634af0e177.tar.gz |
Reviewed by: msmith, bde long ago
POSIX.4 headers and sysctl variables. Nothing should change
unless POSIX4 is defined or _POSIX_VERSION is set to 199309.
Diffstat (limited to 'sys/posix4')
-rw-r--r-- | sys/posix4/aio.h | 107 | ||||
-rw-r--r-- | sys/posix4/ksched.c | 252 | ||||
-rw-r--r-- | sys/posix4/mqueue.h | 71 | ||||
-rw-r--r-- | sys/posix4/posix4.h | 300 | ||||
-rw-r--r-- | sys/posix4/posix4_mib.c | 77 | ||||
-rw-r--r-- | sys/posix4/sched.h | 74 | ||||
-rw-r--r-- | sys/posix4/semaphore.h | 61 |
7 files changed, 942 insertions, 0 deletions
diff --git a/sys/posix4/aio.h b/sys/posix4/aio.h new file mode 100644 index 0000000..6cd47bc --- /dev/null +++ b/sys/posix4/aio.h @@ -0,0 +1,107 @@ +/* XXX Conflicts with John's - not installed. + */ +/*- + * Copyright (c) 1996, 1997 + * HD Associates, Inc. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by HD Associates, Inc + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES 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 HD ASSOCIATES 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. + * + * $Id:$ + */ + +/* aio.h: P1003.1B-1993 Asynchronous I/O */ + +#ifndef _POSIX4_AIO_H_ +#define _POSIX4_AIO_H_ + +#ifdef POSIX4_INCLUDE_MAYBES +#include <sys/types.h> +#include <signal.h> +#include <time.h> +#include <fcntl.h> +#else +struct timespec; +#include <sys/types.h> +#ifdef KERNEL +#include <sys/signal.h> +#else +#include <signal.h> +#endif +#endif + +/* Return values: */ + +#define AIO_CANCELED 0x01 /* All operations cancelled */ +#define AIO_NOTCANCELLED 0x02 /* Some not cancelled */ +#define AIO_ALLDONE 0x04 /* None were cancelled */ + +/* lio_listio synchronization options */ + +#define LIO_WAIT 0x08 /* Suspend until complete */ +#define LIO_NOWAIT 0x10 /* Continue operation */ + +/* lio_listio element operations */ + +#define LIO_READ 0x20 +#define LIO_WRITE 0x40 +#define LIO_NOP 0x80 + +typedef struct aiocb * const aio_listio_ctl; +typedef const struct aiocb * const caio_listio_ctl; + +struct aiocb { + int aio_fildes; /* File descriptor */ + off_t aio_offset; /* File offset */ + volatile void * aio_buf; /* Location of buffer */ + size_t aio_nbytes; /* Length of transfer */ + int aio_reqprio; /* Request priority offset */ + struct sigevent aio_sigevent; /* Signal number and value */ + int aio_lio_opcode; /* Operation to be performed */ +}; + +#ifndef KERNEL +#include <sys/cdefs.h> + +int aio_read __P((struct aiocb *)); +int aio_write __P((struct aiocb *)); + +int lio_listio __P((int, aio_listio_ctl [_POSIX_AIO_LISTIO_MAX], + int, struct sigevent *)); + +int aio_error __P((const struct aiocb *)); +ssize_t aio_return __P((struct aiocb *)); +int aio_cancel __P((int, struct aiocb *)); + +int aio_suspend __P((caio_listio_ctl [_POSIX_AIO_LISTIO_MAX], + int, const struct timespec *)); + +int aio_fsync __P((int, struct aiocb *)); + +#endif /* KERNEL */ + +#endif /* _POSIX4_AIO_H_ */ diff --git a/sys/posix4/ksched.c b/sys/posix4/ksched.c new file mode 100644 index 0000000..7ff85d6 --- /dev/null +++ b/sys/posix4/ksched.c @@ -0,0 +1,252 @@ +/* + * Copyright (c) 1996, 1997 + * HD Associates, Inc. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by HD Associates, Inc + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES 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 HD ASSOCIATES 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. + * + */ + +/* ksched: Soft real time scheduling based on "rtprio". + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/proc.h> +#include <sys/kernel.h> +#include <machine/cpu.h> /* For need_resched */ +#include <fcntl.h> + +#include <sys/posix4.h> + +/* ksched: Real-time extension to support POSIX priority scheduling. + */ + +static struct timespec rr_interval; + +int ksched_attach(int p4_instance, int fac_code, void **p) +{ + rr_interval.tv_sec = 0; + rr_interval.tv_nsec = 1000000000L / roundrobin_interval(); + + *p = 0; + + return 0; +} + +int ksched_detach(void *p) +{ + return 0; +} + +/* + * XXX About priorities + * + * POSIX4 requires that numerically higher priorities be of + * higher priority. It also permits sched_setparam to be + * implementation defined for SCHED_OTHER. I don't like + * the notion of inverted priorites for normal processes when + * you can use "setpriority" for that. + * + * I'm rejecting sched_setparam for SCHED_OTHER with EINVAL. + */ + +/* Macros to convert between the unix (lower numerically is higher priority) + * and POSIX4 (higher numerically is higher priority) + */ + +#define p4prio_to_rtpprio(P) (RTP_PRIO_MAX - (P)) +#define rtpprio_to_p4prio(P) (RTP_PRIO_MAX - (P)) + +static inline int +getscheduler(int *ret, void *hook, struct proc *p) +{ + int e = 0; + + switch (p->p_rtprio.type) + { + case RTP_PRIO_FIFO: + *ret = SCHED_FIFO; + break; + + case RTP_PRIO_REALTIME: + *ret = SCHED_RR; + break; + + default: + *ret = SCHED_OTHER; + break; + } + + return e; +} + +int ksched_setparam(int *ret, void *hook, + struct proc *p, const struct sched_param *param) +{ + int e, policy; + + e = getscheduler(&policy, hook, p); + + if (e == 0) + { + if (policy == SCHED_OTHER) + e = EINVAL; + else + e = ksched_setscheduler(ret, hook, p, policy, param); + } + + return e; +} + +int ksched_getparam(int *ret, void *hook, + struct proc *p, struct sched_param *param) +{ + if (RTP_PRIO_IS_REALTIME(p->p_rtprio.type)) + param->sched_priority = rtpprio_to_p4prio(p->p_rtprio.prio); + + return 0; +} + +/* + * XXX The priority and scheduler modifications should + * be moved into published interfaces in kern/kern_sync. + * + * The permissions to modify process p were checked in "posix4proc()". + * + */ +int ksched_setscheduler(int *ret, void *hook, + struct proc *p, int policy, const struct sched_param *param) +{ + int e = 0; + struct rtprio rtp; + + switch(policy) + { + case SCHED_RR: + case SCHED_FIFO: + + if (param->sched_priority >= RTP_PRIO_MIN && + param->sched_priority <= RTP_PRIO_MAX) + { + rtp.type = (policy == SCHED_FIFO) + ? RTP_PRIO_FIFO : RTP_PRIO_REALTIME; + + rtp.prio = p4prio_to_rtpprio(RTP_PRIO_MAX); + p->p_rtprio = rtp; + (void)resetpriority(p); + } + else + e = EPERM; + + + break; + + case SCHED_OTHER: + { + rtp.type = RTP_PRIO_NORMAL; + rtp.prio = p4prio_to_rtpprio(RTP_PRIO_MIN); + p->p_rtprio = rtp; + + /* XXX Simply revert to whatever we had for last + * normal scheduler priorities. + * This puts a requirement + * on the scheduling code: You must leave the + * scheduling info alone. + */ + (void)resetpriority(p); + } + break; + } + + return e; +} + +int ksched_getscheduler(int *ret, void *hook, struct proc *p) +{ + return getscheduler(ret, hook, p); +} + +/* ksched_yield: Yield the CPU. + */ +int ksched_yield(int *ret, void *hook) +{ + need_resched(); + return 0; +} + +int ksched_get_priority_max(int *ret, void *hook, int policy) +{ + int e = 0; + + switch (policy) + { + case SCHED_FIFO: + case SCHED_RR: + *ret = RTP_PRIO_MAX; + break; + + case SCHED_OTHER: + *ret = PRIO_MAX; + break; + + default: + e = EINVAL; + } + + return e; +} + +int ksched_get_priority_min(int *ret, void *hook, int policy) +{ + int e = 0; + + switch (policy) + { + case SCHED_FIFO: + case SCHED_RR: + *ret = RTP_PRIO_MIN; + break; + + case SCHED_OTHER: + *ret = PRIO_MIN; + break; + + default: + e = EINVAL; + } + + return e; +} + +int ksched_rr_get_interval(int *ret, void *hook, + struct proc *p, struct timespec *timespec) +{ + *timespec = rr_interval; + + return 0; +} diff --git a/sys/posix4/mqueue.h b/sys/posix4/mqueue.h new file mode 100644 index 0000000..0872ddf --- /dev/null +++ b/sys/posix4/mqueue.h @@ -0,0 +1,71 @@ +#ifndef _MQUEUE_H_ +#define _MQUEUE_H_ + +/* mqueue.h: POSIX.4 Message Queues */ + +/*- + * Copyright (c) 1996, 1997 + * HD Associates, Inc. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by HD Associates, Inc + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES 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 HD ASSOCIATES 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. + * + */ + +#ifdef POSIX4_INCLUDE_MAYBES +#include <sys/types.h> +#include <fcntl.h> +#include <time.h> +#include <signal.h> +#else +struct sigevent; +#endif + +typedef int mqd_t; /* message queue descriptors */ + +struct mq_attr { + long mq_flags; /* message queue flags */ + long mq_maxmsg; /* maximum number of messages */ + long mq_msgsize; /* maximum message size */ + long mq_curmsgs; /* number of messages currently queued */ +}; + +#ifndef KERNEL +#include <sys/cdefs.h> + +mqd_t mq_open __P((const char *, int oflag, ...)); +int mq_close __P((mqd_t)); +int mq_unlink __P((const char *)); +int mq_send __P((mqd_t, const char *, size_t, unsigned int)); +ssize_t mq_receive __P((mqd_t, char *, size_t, unsigned int *)); +int mq_notify __P((mqd_t, const struct sigevent *)); +int mq_setattr __P((mqd_t, const struct mq_attr *, struct mq_attr *)); +int mq_getattr __P((mqd_t, struct mq_attr *)); + +#endif /* KERNEL */ + +#endif /* _MQUEUE_H_ */ diff --git a/sys/posix4/posix4.h b/sys/posix4/posix4.h new file mode 100644 index 0000000..5037b03 --- /dev/null +++ b/sys/posix4/posix4.h @@ -0,0 +1,300 @@ +#ifndef _POSIX4_POSIX4_H_ +#define _POSIX4_POSIX4_H_ +/*- + * Copyright (c) 1996, 1997, 1998 + * HD Associates, Inc. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by HD Associates, Inc + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES 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 HD ASSOCIATES 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. + * + */ + +#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 199309L +#include <sys/param.h> +#include <sys/ioccom.h> +#include <sched.h> + +/* + * This defines POSIX4_VISIBLE to indicate posix4 extensions should show up. + * You should test this when you add a posix4 extension to a header + * that exists in POSIX.1. Try "man 9 posix4". + */ + +#if !defined(_POSIX_C_SOURCE) || \ + defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L +#define POSIX4_VISIBLE +#endif + +/* + * + * March 1, 1998: Details from here on change and this header file + * is volatile. + * + * Locally I've got PRIORITY SCHEDULING + * set as a system call available only to root + * and I'm still using a pseudo device to gate everything else. + * + * This interface vectors us into the kernel through a + * POSIX4 pseudo device with some user privilege authorization along + * the way. + * + * XXX I'm going with option 3. + * + * This has drawbacks from the point of view of ktrace. There + * are (at least) three ways to do this: + * + * 1. As it is being done, which is bad for ktrace and is hokey + * but is easy to extend during development; + * 2. Add a system call for every POSIX4 entry point, which + * will result in many more system calls (on the order of 64) + * 3. Add a system call for each POSIX4 option, which is a bit more + * useful for ktrace and will add only about 14 new system calls. + * + */ + +#define POSIX4_FACILITIES 16 +#define POSIX4_ONE_ONLY + +/* + * All facility request structures have a posix4_dispatch header + * at the front. Return values are always an indication of + * success or failure and are automatically converted into an errno + * by the kernel. "Non-errno" return codes are handled via ret. + */ +struct posix4_dispatch { + int op; + int ret; +}; + +#if defined(_POSIX_PRIORITY_SCHEDULING) + +/* + * KSCHED_OP_RW is a vector of read/write flags for each entry indexed + * by the enum ksched_op. + * + * 1 means you need write access, 0 means read is sufficient. + */ + +enum ksched_op { + +#define KSCHED_OP_RW { 1, 0, 1, 0, 0, 0, 0, 0 } + + SCHED_SETPARAM, + SCHED_GETPARAM, + SCHED_SETSCHEDULER, + SCHED_GETSCHEDULER, + SCHED_YIELD, + SCHED_GET_PRIORITY_MAX, + SCHED_GET_PRIORITY_MIN, + SCHED_RR_GET_INTERVAL, + SCHED_OP_MAX +}; + +struct ksched +{ + struct posix4_dispatch dispatch; + pid_t pid; + int policy; + struct sched_param param; + struct timespec interval; +}; + +#endif /* _POSIX_PRIORITY_SCHEDULING */ + +#if defined(_POSIX_MEMLOCK) ^ defined(_POSIX_MEMLOCK_RANGE) +/* This implementation expects these two options to always be together. + * If one isn't handled it should be disabled at + * run time. + */ +#error _POSIX_MEMLOCK and _POSIX_MEMLOCK_RANGE should always be together +#endif + +#if defined(_POSIX_MEMLOCK) && defined(_POSIX_MEMLOCK_RANGE) + +enum kmemlock_op { + +#define KMEMLOCK_OP_RW { 1, 1, 1, 1 } + + MEMLOCK_MLOCKALL, + MEMLOCK_MUNLOCKALL, + MEMLOCK_MLOCK, + MEMLOCK_MUNLOCK, + MEMLOCK_OP_MAX +}; + +struct kmemlock +{ + struct posix4_dispatch dispatch; + int flags; + void *addr; + size_t len; +}; + +#endif /* _POSIX_MEMLOCK && _POSIX_MEMLOCK_RANGE */ + +#if defined(KERNEL) + +struct proc; + +void *posix4malloc __P((int *, size_t)); +void posix4free __P((int *, void *)); +int posix4proc __P((struct proc *, pid_t, struct proc **)); +int posix4ioctl __P((dev_t, int, caddr_t, int, struct proc *)); +void posix4attach __P((int)); +void posix4_facility __P((int, int)); + +struct lkm_table; +int posix4_init __P((struct lkm_table *, int , int )); + +#ifdef _POSIX_PRIORITY_SCHEDULING + +int ksched_attach(int, int, void **); +int ksched_detach(void *); + +int ksched_setparam(int *, void *, + struct proc *, const struct sched_param *); +int ksched_getparam(int *, void *, + struct proc *, struct sched_param *); + +int ksched_setscheduler(int *, void *, + struct proc *, int, const struct sched_param *); +int ksched_getscheduler(int *, void *, struct proc *); + +int ksched_yield(int *, void *); + +int ksched_get_priority_max(int *, void *, int); +int ksched_get_priority_min(int *, void *, int); + +int ksched_rr_get_interval(int *, void *, struct proc *, struct timespec *); + +#endif /* _POSIX_PRIORITY_SCHEDULING */ + +#if defined(_POSIX_MEMLOCK) && defined(_POSIX_MEMLOCK_RANGE) + +int kmemlock_attach(int, int, void **); +int kmemlock_detach(void *); +int kmlockall(int *, void *, int); +int kmunlockall(int *, void *); +int kmlock(int *, void *, const void *, size_t); +int kmunlock(int *, void *, const void *, size_t ); + +#endif /* _POSIX_MEMLOCK && _POSIX_MEMLOCK_RANGE */ + +#endif /* KERNEL */ + +/* A facility is an implementation of one of the optional portions of + * POSIX4 as selected by the feature test macros, such as the fixed + * priority scheduler or the realtime signals. + */ + +/* Each facility has a facility code, an opcode, and r-w attributes. + * To exercise the operation associated with an opcode you need the + * appropriate privileges on the POSIX4 device with the facility + * bit set in the minor number. This means that every facility has + * a protection bit: Probably more than we need, but it may have + * advantages. + * + */ + +#define posix4encode(FACILITY, RW) (FACILITY) +#define posix4decode(X, FACILITY_P) \ + do { \ + *(FACILITY_P) = ((X) & 0xff); \ + } while (0) + +/* + * The dispatch codes: + */ +#define IO_POSIX4_PRIORITY_SCHEDULING _IOWR('r', \ + CTL_POSIX4_PRIORITY_SCHEDULING, struct ksched) + +#define IO_POSIX4_MEMLOCK _IOWR('r', \ + CTL_POSIX4_MEMLOCK, struct ksched) + +/* + * CTL_POSIX4 definitions for syscfg + */ + +#define CTL_POSIX4_ASYNCHRONOUS_IO 1 /* boolean */ +#define CTL_POSIX4_MAPPED_FILES 2 /* boolean */ +#define CTL_POSIX4_MEMLOCK 3 /* boolean */ +#define CTL_POSIX4_MEMLOCK_RANGE 4 /* boolean */ +#define CTL_POSIX4_MEMORY_PROTECTION 5 /* boolean */ +#define CTL_POSIX4_MESSAGE_PASSING 6 /* boolean */ +#define CTL_POSIX4_PRIORITIZED_IO 7 /* boolean */ +#define CTL_POSIX4_PRIORITY_SCHEDULING 8 /* boolean */ +#define CTL_POSIX4_REALTIME_SIGNALS 9 /* boolean */ +#define CTL_POSIX4_SEMAPHORES 10 /* boolean */ +#define CTL_POSIX4_FSYNC 11 /* boolean */ +#define CTL_POSIX4_SHARED_MEMORY_OBJECTS 12 /* boolean */ +#define CTL_POSIX4_SYNCHRONIZED_IO 13 /* boolean */ +#define CTL_POSIX4_TIMERS 14 /* boolean */ +#define CTL_POSIX4_AIO_LISTIO_MAX 15 /* int */ +#define CTL_POSIX4_AIO_MAX 16 /* int */ +#define CTL_POSIX4_AIO_PRIO_DELTA_MAX 17 /* int */ +#define CTL_POSIX4_DELAYTIMER_MAX 18 /* int */ +#define CTL_POSIX4_MQ_OPEN_MAX 19 /* int */ +#define CTL_POSIX4_PAGESIZE 20 /* int */ +#define CTL_POSIX4_RTSIG_MAX 21 /* int */ +#define CTL_POSIX4_SEM_NSEMS_MAX 22 /* int */ +#define CTL_POSIX4_SEM_VALUE_MAX 23 /* int */ +#define CTL_POSIX4_SIGQUEUE_MAX 24 /* int */ +#define CTL_POSIX4_TIMER_MAX 25 /* int */ + +#define CTL_POSIX4_N_CTLS 25 + +#define CTL_POSIX4_NAMES { \ + { 0, 0 }, \ + { "asynchronous_io", CTLTYPE_INT }, \ + { "mapped_files", CTLTYPE_INT }, \ + { "memlock", CTLTYPE_INT }, \ + { "memlock_range", CTLTYPE_INT }, \ + { "memory_protection", CTLTYPE_INT }, \ + { "message_passing", CTLTYPE_INT }, \ + { "prioritized_io", CTLTYPE_INT }, \ + { "priority_scheduling", CTLTYPE_INT }, \ + { "realtime_signals", CTLTYPE_INT }, \ + { "semaphores", CTLTYPE_INT }, \ + { "fsync", CTLTYPE_INT }, \ + { "shared_memory_objects", CTLTYPE_INT }, \ + { "synchronized_io", CTLTYPE_INT }, \ + { "timers", CTLTYPE_INT }, \ + { "aio_listio_max", CTLTYPE_INT }, \ + { "aio_max", CTLTYPE_INT }, \ + { "aio_prio_delta_max", CTLTYPE_INT }, \ + { "delaytimer_max", CTLTYPE_INT }, \ + { "mq_open_max", CTLTYPE_INT }, \ + { "pagesize", CTLTYPE_INT }, \ + { "rtsig_max", CTLTYPE_INT }, \ + { "nsems_max", CTLTYPE_INT }, \ + { "sem_value_max", CTLTYPE_INT }, \ + { "sigqueue_max", CTLTYPE_INT }, \ + { "timer_max", CTLTYPE_INT }, \ +} + +#endif /* _POSIX_VERSION >= 199309L */ +#endif /* _POSIX4_POSIX4_H_ */ diff --git a/sys/posix4/posix4_mib.c b/sys/posix4/posix4_mib.c new file mode 100644 index 0000000..84532b8 --- /dev/null +++ b/sys/posix4/posix4_mib.c @@ -0,0 +1,77 @@ +/*- + * Copyright (c) 1998 + * HD Associates, Inc. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by HD Associates, Inc + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES 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 HD ASSOCIATES 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. + * + */ + +#include <sys/param.h> +#include <sys/kernel.h> +#include <sys/sysctl.h> +#include <sys/unistd.h> + +static int facility[CTL_POSIX4_N_CTLS]; + +#define P4_SYSCTL(num, name) \ + SYSCTL_INT(_posix4, num, name, CTLFLAG_RD, facility + num - 1, 0, ""); + +P4_SYSCTL(CTL_POSIX4_ASYNCHRONOUS_IO, asynchronous_io); +P4_SYSCTL(CTL_POSIX4_MAPPED_FILES, mapped_files); +P4_SYSCTL(CTL_POSIX4_MEMLOCK, memlock); +P4_SYSCTL(CTL_POSIX4_MEMLOCK_RANGE, memlock_range); +P4_SYSCTL(CTL_POSIX4_MEMORY_PROTECTION, memory_protection); +P4_SYSCTL(CTL_POSIX4_MESSAGE_PASSING, message_passing); +P4_SYSCTL(CTL_POSIX4_PRIORITIZED_IO, prioritized_io); +P4_SYSCTL(CTL_POSIX4_PRIORITY_SCHEDULING, priority_scheduling); +P4_SYSCTL(CTL_POSIX4_REALTIME_SIGNALS, realtime_signals); +P4_SYSCTL(CTL_POSIX4_SEMAPHORES, semaphores); +P4_SYSCTL(CTL_POSIX4_FSYNC, fsync); +P4_SYSCTL(CTL_POSIX4_SHARED_MEMORY_OBJECTS, shared_memory_objects); +P4_SYSCTL(CTL_POSIX4_SYNCHRONIZED_IO, synchronized_io); +P4_SYSCTL(CTL_POSIX4_TIMERS, timers); +P4_SYSCTL(CTL_POSIX4_AIO_LISTIO_MAX, aio_listio_max); +P4_SYSCTL(CTL_POSIX4_AIO_MAX, aio_max); +P4_SYSCTL(CTL_POSIX4_AIO_PRIO_DELTA_MAX, aio_prio_delta_max); +P4_SYSCTL(CTL_POSIX4_DELAYTIMER_MAX, delaytimer_max); +P4_SYSCTL(CTL_POSIX4_MQ_OPEN_MAX, mq_open_max); +P4_SYSCTL(CTL_POSIX4_PAGESIZE, pagesize); +P4_SYSCTL(CTL_POSIX4_RTSIG_MAX, rtsig_max); +P4_SYSCTL(CTL_POSIX4_SEM_NSEMS_MAX, sem_nsems_max); +P4_SYSCTL(CTL_POSIX4_SEM_VALUE_MAX, sem_value_max); +P4_SYSCTL(CTL_POSIX4_SIGQUEUE_MAX, sigqueue_max); +P4_SYSCTL(CTL_POSIX4_TIMER_MAX, timer_max); + +/* posix4_facility: Set a facility to a value. This is + * probably a temporary measure until the LKM code is combined with this. + */ +void posix4_facility(int num, int value) +{ + if (num >= 1 && num <= CTL_POSIX4_N_CTLS) + facility[num - 1] = value; +} diff --git a/sys/posix4/sched.h b/sys/posix4/sched.h new file mode 100644 index 0000000..50bc3c6 --- /dev/null +++ b/sys/posix4/sched.h @@ -0,0 +1,74 @@ +#ifndef _SCHED_H_ +#define _SCHED_H_ + +/* sched.h: POSIX.4 Process Scheduling header */ + +/*- + * Copyright (c) 1996, 1997 + * HD Associates, Inc. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by HD Associates, Inc + * and Jukka Antero Ukkonen. + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES 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 HD ASSOCIATES 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. + * + */ + +#include <unistd.h> +#include <sys/types.h> /* For pid_t */ + +#ifndef KERNEL +#include <time.h> /* Per P1003.4 */ +#endif + +/* Scheduling policies + */ +#define SCHED_FIFO 1 +#define SCHED_OTHER 2 +#define SCHED_RR 3 + +struct sched_param +{ + int sched_priority; +}; + +#ifndef KERNEL +#include <sys/cdefs.h> + +int sched_setparam __P((pid_t, const struct sched_param *)); +int sched_getparam __P((pid_t, struct sched_param *)); + +int sched_setscheduler __P((pid_t, int, const struct sched_param *)); +int sched_getscheduler __P((pid_t)); + +int sched_yield __P((void)); +int sched_get_priority_max __P((int)); +int sched_get_priority_min __P((int)); +int sched_rr_get_interval __P((pid_t, struct timespec *)); + +#endif /* KERNEL */ + +#endif /* _SCHED_H_ */ diff --git a/sys/posix4/semaphore.h b/sys/posix4/semaphore.h new file mode 100644 index 0000000..fbcab13 --- /dev/null +++ b/sys/posix4/semaphore.h @@ -0,0 +1,61 @@ +#ifndef _SEMAPHORE_H_ +#define _SEMAPHORE_H_ + +/* semaphore.h: POSIX.4 semaphores */ + +/*- + * Copyright (c) 1996, 1997 + * HD Associates, Inc. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by HD Associates, Inc + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES 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 HD ASSOCIATES 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. + * + */ + +#ifdef POSIX4_INCLUDE_MAYBES +#include <sys/types.h> +#include <fcntl.h> +#endif + +typedef int sem_t; + +#ifndef KERNEL +#include <sys/cdefs.h> + +int sem_init __P(sem_t *, int, unsigned int)); +int sem_destroy __P((sem_t *)); +sem_t sem_open __P((const char *, int, ...)); +int sem_close __P((sem_t *)); +int sem_unlink __P((const char *)); +int sem_wait((sem_t *)); +int sem_trywait((sem_t *)); +int sem_post((sem_t *)); +int sem_getvalue((sem_t *, int *)); + +#endif /* KERNEL */ + +#endif /* _SEMAPHORE_H_ */ |