summaryrefslogtreecommitdiffstats
path: root/sys/kern
diff options
context:
space:
mode:
Diffstat (limited to 'sys/kern')
-rw-r--r--sys/kern/init_sysent.c8
-rw-r--r--sys/kern/kern_mib.c12
-rw-r--r--sys/kern/kern_synch.c5
-rw-r--r--sys/kern/ksched.c52
-rw-r--r--sys/kern/p1003_1b.c239
-rw-r--r--sys/kern/posix4_mib.c83
-rw-r--r--sys/kern/syscalls.c8
-rw-r--r--sys/kern/syscalls.master13
-rw-r--r--sys/kern/vfs_aio.c4
9 files changed, 355 insertions, 69 deletions
diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c
index 7f62e27..7336ac8 100644
--- a/sys/kern/init_sysent.c
+++ b/sys/kern/init_sysent.c
@@ -346,4 +346,12 @@ struct sysent sysent[] = {
{ 1, (sy_call_t *)mlockall }, /* 324 = mlockall */
{ 0, (sy_call_t *)munlockall }, /* 325 = munlockall */
{ 2, (sy_call_t *)__getcwd }, /* 326 = __getcwd */
+ { 2, (sy_call_t *)sched_setparam }, /* 327 = sched_setparam */
+ { 2, (sy_call_t *)sched_getparam }, /* 328 = sched_getparam */
+ { 3, (sy_call_t *)sched_setscheduler }, /* 329 = sched_setscheduler */
+ { 1, (sy_call_t *)sched_getscheduler }, /* 330 = sched_getscheduler */
+ { 0, (sy_call_t *)sched_yield }, /* 331 = sched_yield */
+ { 1, (sy_call_t *)sched_get_priority_max }, /* 332 = sched_get_priority_max */
+ { 1, (sy_call_t *)sched_get_priority_min }, /* 333 = sched_get_priority_min */
+ { 2, (sy_call_t *)sched_rr_get_interval }, /* 334 = sched_rr_get_interval */
};
diff --git a/sys/kern/kern_mib.c b/sys/kern/kern_mib.c
index 9718f6b..5278b34 100644
--- a/sys/kern/kern_mib.c
+++ b/sys/kern/kern_mib.c
@@ -37,7 +37,7 @@
* SUCH DAMAGE.
*
* @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94
- * $Id: kern_mib.c,v 1.13 1997/12/25 13:14:21 gpalmer Exp $
+ * $Id: kern_mib.c,v 1.14 1998/03/04 10:25:50 dufault Exp $
*/
#include <sys/param.h>
@@ -52,8 +52,6 @@
#include <machine/smp.h>
#endif
-#include "opt_posix4.h"
-
SYSCTL_NODE(, 0, sysctl, CTLFLAG_RW, 0,
"Sysctl internal magic");
SYSCTL_NODE(, CTL_KERN, kern, CTLFLAG_RW, 0,
@@ -73,10 +71,8 @@ SYSCTL_NODE(, CTL_MACHDEP, machdep, CTLFLAG_RW, 0,
SYSCTL_NODE(, CTL_USER, user, CTLFLAG_RW, 0,
"user-level");
-#ifdef POSIX4
-SYSCTL_NODE(, CTL_POSIX4, posix4, CTLFLAG_RW, 0,
- "posix4, (see posix4.h)");
-#endif
+SYSCTL_NODE(, CTL_P1003_1B, p1003_1b, CTLFLAG_RW, 0,
+ "p1003_1b, (see p1003_1b.h)");
SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, CTLFLAG_RD, osrelease, 0, "");
@@ -96,7 +92,7 @@ SYSCTL_INT(_kern, KERN_MAXPROCPERUID, maxprocperuid,
SYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD, 0, ARG_MAX, "");
-SYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD, 0, _POSIX_VERSION, "");
+SYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD, 0, _KPOSIX_VERSION, "");
SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, CTLFLAG_RD, 0, NGROUPS_MAX, "");
diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c
index 46089c7..c0437d5 100644
--- a/sys/kern/kern_synch.c
+++ b/sys/kern/kern_synch.c
@@ -36,7 +36,7 @@
* SUCH DAMAGE.
*
* @(#)kern_synch.c 8.9 (Berkeley) 5/19/95
- * $Id: kern_synch.c,v 1.50 1998/03/11 20:50:42 dufault Exp $
+ * $Id: kern_synch.c,v 1.51 1998/03/28 10:33:06 bde Exp $
*/
#include "opt_ktrace.h"
@@ -105,6 +105,9 @@ static void maybe_resched(struct proc *chk)
struct proc *p = curproc; /* XXX */
/* If the current scheduler is the idle scheduler or
+ * the priority is of the new one is higher then reschedule.
+ */
+ /* If the current scheduler is the idle scheduler or
* the priority of the new one is higher then reschedule.
*/
if (p == 0 ||
diff --git a/sys/kern/ksched.c b/sys/kern/ksched.c
index 7ff85d6..90c029a 100644
--- a/sys/kern/ksched.c
+++ b/sys/kern/ksched.c
@@ -39,34 +39,38 @@
#include <sys/proc.h>
#include <sys/kernel.h>
#include <machine/cpu.h> /* For need_resched */
-#include <fcntl.h>
-#include <sys/posix4.h>
+#include <posix4/posix4.h>
/* ksched: Real-time extension to support POSIX priority scheduling.
*/
-static struct timespec rr_interval;
+struct ksched {
+ struct timespec rr_interval;
+};
-int ksched_attach(int p4_instance, int fac_code, void **p)
+int ksched_attach(struct ksched **p)
{
- rr_interval.tv_sec = 0;
- rr_interval.tv_nsec = 1000000000L / roundrobin_interval();
+ struct ksched *ksched= p31b_malloc(sizeof(*ksched));
- *p = 0;
+ ksched->rr_interval.tv_sec = 0;
+ ksched->rr_interval.tv_nsec = 1000000000L / roundrobin_interval();
+ *p = ksched;
return 0;
}
-int ksched_detach(void *p)
+int ksched_detach(struct ksched *p)
{
+ p31b_free(p);
+
return 0;
}
/*
* XXX About priorities
*
- * POSIX4 requires that numerically higher priorities be of
+ * POSIX 1003.1b 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
@@ -76,14 +80,14 @@ int ksched_detach(void *p)
*/
/* Macros to convert between the unix (lower numerically is higher priority)
- * and POSIX4 (higher numerically is higher priority)
+ * and POSIX 1003.1b (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)
+getscheduler(int *ret, struct ksched *ksched, struct proc *p)
{
int e = 0;
@@ -105,25 +109,25 @@ getscheduler(int *ret, void *hook, struct proc *p)
return e;
}
-int ksched_setparam(int *ret, void *hook,
+int ksched_setparam(int *ret, struct ksched *ksched,
struct proc *p, const struct sched_param *param)
{
int e, policy;
- e = getscheduler(&policy, hook, p);
+ e = getscheduler(&policy, ksched, p);
if (e == 0)
{
if (policy == SCHED_OTHER)
e = EINVAL;
else
- e = ksched_setscheduler(ret, hook, p, policy, param);
+ e = ksched_setscheduler(ret, ksched, p, policy, param);
}
return e;
}
-int ksched_getparam(int *ret, void *hook,
+int ksched_getparam(int *ret, struct ksched *ksched,
struct proc *p, struct sched_param *param)
{
if (RTP_PRIO_IS_REALTIME(p->p_rtprio.type))
@@ -136,10 +140,10 @@ int ksched_getparam(int *ret, void *hook,
* 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()".
+ * The permissions to modify process p were checked in "p31b_proc()".
*
*/
-int ksched_setscheduler(int *ret, void *hook,
+int ksched_setscheduler(int *ret, struct ksched *ksched,
struct proc *p, int policy, const struct sched_param *param)
{
int e = 0;
@@ -186,20 +190,20 @@ int ksched_setscheduler(int *ret, void *hook,
return e;
}
-int ksched_getscheduler(int *ret, void *hook, struct proc *p)
+int ksched_getscheduler(int *ret, struct ksched *ksched, struct proc *p)
{
- return getscheduler(ret, hook, p);
+ return getscheduler(ret, ksched, p);
}
/* ksched_yield: Yield the CPU.
*/
-int ksched_yield(int *ret, void *hook)
+int ksched_yield(int *ret, struct ksched *ksched)
{
need_resched();
return 0;
}
-int ksched_get_priority_max(int *ret, void *hook, int policy)
+int ksched_get_priority_max(int *ret, struct ksched *ksched, int policy)
{
int e = 0;
@@ -221,7 +225,7 @@ int ksched_get_priority_max(int *ret, void *hook, int policy)
return e;
}
-int ksched_get_priority_min(int *ret, void *hook, int policy)
+int ksched_get_priority_min(int *ret, struct ksched *ksched, int policy)
{
int e = 0;
@@ -243,10 +247,10 @@ int ksched_get_priority_min(int *ret, void *hook, int policy)
return e;
}
-int ksched_rr_get_interval(int *ret, void *hook,
+int ksched_rr_get_interval(int *ret, struct ksched *ksched,
struct proc *p, struct timespec *timespec)
{
- *timespec = rr_interval;
+ *timespec = ksched->rr_interval;
return 0;
}
diff --git a/sys/kern/p1003_1b.c b/sys/kern/p1003_1b.c
new file mode 100644
index 0000000..ccbee6b
--- /dev/null
+++ b/sys/kern/p1003_1b.c
@@ -0,0 +1,239 @@
+/*
+ * 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.
+ *
+ */
+
+/* p1003_1b: Real Time common code.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/sysent.h>
+#include <sys/proc.h>
+#include <sys/syslog.h>
+#include <sys/module.h>
+#include <sys/sysproto.h>
+#include <sys/sysctl.h>
+
+#include <posix4/posix4.h>
+
+MALLOC_DEFINE(M_P31B, "p1003.1b", "Posix 1003.1B");
+
+/* p31b_proc: Return a proc struct corresponding to a pid to operate on.
+ *
+ * Enforce permission policy.
+ *
+ * The policy is the same as for sending signals except there
+ * is no notion of process groups.
+ *
+ * pid == 0 means my process.
+ *
+ * This is disabled until I've got a permission gate in again:
+ * only root can do this.
+ */
+
+#if 0
+/*
+ * This is stolen from CANSIGNAL in kern_sig:
+ *
+ * Can process p, with pcred pc, do "write flavor" operations to process q?
+ */
+#define CAN_AFFECT(p, pc, q) \
+ ((pc)->pc_ucred->cr_uid == 0 || \
+ (pc)->p_ruid == (q)->p_cred->p_ruid || \
+ (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \
+ (pc)->p_ruid == (q)->p_ucred->cr_uid || \
+ (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid)
+#else
+#define CAN_AFFECT(p, pc, q) ((pc)->pc_ucred->cr_uid == 0)
+#endif
+
+/*
+ * p31b_proc: Look up a proc from a PID. If proc is 0 it is
+ * my own proc.
+ */
+int p31b_proc(struct proc *p, pid_t pid, struct proc **pp)
+{
+ int ret = 0;
+ struct proc *other_proc = 0;
+
+ if (pid == 0)
+ other_proc = p;
+ else
+ other_proc = pfind(pid);
+
+ if (other_proc)
+ {
+ /* Enforce permission policy.
+ */
+ if (CAN_AFFECT(p, p->p_cred, other_proc))
+ *pp = other_proc;
+ else
+ ret = EPERM;
+ }
+ else
+ ret = ESRCH;
+
+ return ret;
+}
+
+int
+syscall_not_present(struct proc *p, const char *s, struct nosys_args *uap)
+{
+ log(LOG_ERR, "cmd %s pid %d tried to use non-present %s\n",
+ p->p_comm, p->p_pid, s);
+ return nosys(p, uap);
+}
+
+#if !defined(_KPOSIX_PRIORITY_SCHEDULING)
+
+/* Not configured but loadable via an LKM:
+ */
+
+static int sched_attach(void)
+{
+ return 0;
+}
+
+SYSCALL_NOT_PRESENT_GEN(sched_setparam)
+SYSCALL_NOT_PRESENT_GEN(sched_getparam)
+SYSCALL_NOT_PRESENT_GEN(sched_setscheduler)
+SYSCALL_NOT_PRESENT_GEN(sched_getscheduler)
+SYSCALL_NOT_PRESENT_GEN(sched_yield)
+SYSCALL_NOT_PRESENT_GEN(sched_get_priority_max)
+SYSCALL_NOT_PRESENT_GEN(sched_get_priority_min)
+SYSCALL_NOT_PRESENT_GEN(sched_rr_get_interval)
+
+#else
+
+/* Configured in kernel version:
+ */
+static struct ksched *ksched;
+
+static int sched_attach(void)
+{
+ int ret = ksched_attach(&ksched);
+
+ if (ret == 0)
+ p31b_setcfg(CTL_P1003_1B_PRIORITY_SCHEDULING, 1);
+
+ return ret;
+}
+
+int sched_setparam(struct proc *p,
+ struct sched_setparam_args *uap)
+{
+ int e;
+
+ (void) (0
+ || (e = p31b_proc(p, uap->pid, &p))
+ || (e = ksched_setparam(&p->p_retval[0], ksched, p,
+ (const struct sched_param *) &uap->param))
+ );
+
+ return e;
+}
+
+int sched_getparam(struct proc *p,
+ struct sched_getparam_args *uap)
+{
+ int e;
+
+ (void) (0
+ || (e = p31b_proc(p, uap->pid, &p))
+ || (e = ksched_getparam(&p->p_retval[0], ksched, p, uap->param))
+ );
+
+ return e;
+}
+int sched_setscheduler(struct proc *p,
+ struct sched_setscheduler_args *uap)
+{
+ int e;
+ (void) (0
+ || (e = p31b_proc(p, uap->pid, &p))
+ || (e = ksched_setscheduler(&p->p_retval[0],
+ ksched, p, uap->policy, uap->param))
+ );
+
+ return e;
+}
+int sched_getscheduler(struct proc *p,
+ struct sched_getscheduler_args *uap)
+{
+ int e;
+ (void) (0
+ || (e = p31b_proc(p, uap->pid, &p))
+ || (e = ksched_getscheduler(&p->p_retval[0], ksched, p))
+ );
+
+ return e;
+}
+int sched_yield(struct proc *p,
+ struct sched_yield_args *uap)
+{
+ return ksched_yield(&p->p_retval[0], ksched);
+}
+int sched_get_priority_max(struct proc *p,
+ struct sched_get_priority_max_args *uap)
+{
+ return ksched_get_priority_max(&p->p_retval[0],
+ ksched, uap->policy);
+}
+int sched_get_priority_min(struct proc *p,
+ struct sched_get_priority_min_args *uap)
+{
+ return ksched_get_priority_min(&p->p_retval[0],
+ ksched, uap->policy);
+}
+int sched_rr_get_interval(struct proc *p,
+ struct sched_rr_get_interval_args *uap)
+{
+ int e;
+
+ (void) (0
+ || (e = p31b_proc(p, uap->pid, &p))
+ || (e = ksched_rr_get_interval(&p->p_retval[0], ksched,
+ p, uap->interval))
+ );
+
+ return e;
+}
+
+#endif
+
+static void p31binit(void *notused)
+{
+ (void) sched_attach();
+}
+
+SYSINIT(p31b, SI_SUB_P1003_1B, SI_ORDER_FIRST, p31binit, NULL);
diff --git a/sys/kern/posix4_mib.c b/sys/kern/posix4_mib.c
index 84532b8..523f76b 100644
--- a/sys/kern/posix4_mib.c
+++ b/sys/kern/posix4_mib.c
@@ -34,44 +34,61 @@
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/sysctl.h>
-#include <sys/unistd.h>
+#include <posix4/posix4.h>
-static int facility[CTL_POSIX4_N_CTLS];
+static int facility[CTL_P1003_1B_MAXID - 1];
+
+/* OID_AUTO isn't working with sysconf(3). I guess I'd have to
+ * modify it to do a lookup by name from the index.
+ * For now I've left it a top-level sysctl.
+ */
+
+#if 1
+
+#define P1B_SYSCTL(num, name) \
+SYSCTL_INT(_p1003_1b, num, \
+ name, CTLFLAG_RD, facility + num - 1, 0, "");
+
+#else
+
+#define P1B_SYSCTL(num, name) \
+SYSCTL_INT(_kern_p1003_1b, OID_AUTO, \
+ name, CTLFLAG_RD, facility + num - 1, 0, "");
+SYSCTL_NODE(_kern, OID_AUTO, p1003_1b, CTLFLAG_RW, 0, "P1003.1B");
+
+#endif
-#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);
+P1B_SYSCTL(CTL_P1003_1B_ASYNCHRONOUS_IO, asynchronous_io);
+P1B_SYSCTL(CTL_P1003_1B_MAPPED_FILES, mapped_files);
+P1B_SYSCTL(CTL_P1003_1B_MEMLOCK, memlock);
+P1B_SYSCTL(CTL_P1003_1B_MEMLOCK_RANGE, memlock_range);
+P1B_SYSCTL(CTL_P1003_1B_MEMORY_PROTECTION, memory_protection);
+P1B_SYSCTL(CTL_P1003_1B_MESSAGE_PASSING, message_passing);
+P1B_SYSCTL(CTL_P1003_1B_PRIORITIZED_IO, prioritized_io);
+P1B_SYSCTL(CTL_P1003_1B_PRIORITY_SCHEDULING, priority_scheduling);
+P1B_SYSCTL(CTL_P1003_1B_REALTIME_SIGNALS, realtime_signals);
+P1B_SYSCTL(CTL_P1003_1B_SEMAPHORES, semaphores);
+P1B_SYSCTL(CTL_P1003_1B_FSYNC, fsync);
+P1B_SYSCTL(CTL_P1003_1B_SHARED_MEMORY_OBJECTS, shared_memory_objects);
+P1B_SYSCTL(CTL_P1003_1B_SYNCHRONIZED_IO, synchronized_io);
+P1B_SYSCTL(CTL_P1003_1B_TIMERS, timers);
+P1B_SYSCTL(CTL_P1003_1B_AIO_LISTIO_MAX, aio_listio_max);
+P1B_SYSCTL(CTL_P1003_1B_AIO_MAX, aio_max);
+P1B_SYSCTL(CTL_P1003_1B_AIO_PRIO_DELTA_MAX, aio_prio_delta_max);
+P1B_SYSCTL(CTL_P1003_1B_DELAYTIMER_MAX, delaytimer_max);
+P1B_SYSCTL(CTL_P1003_1B_MQ_OPEN_MAX, mq_open_max);
+P1B_SYSCTL(CTL_P1003_1B_PAGESIZE, pagesize);
+P1B_SYSCTL(CTL_P1003_1B_RTSIG_MAX, rtsig_max);
+P1B_SYSCTL(CTL_P1003_1B_SEM_NSEMS_MAX, sem_nsems_max);
+P1B_SYSCTL(CTL_P1003_1B_SEM_VALUE_MAX, sem_value_max);
+P1B_SYSCTL(CTL_P1003_1B_SIGQUEUE_MAX, sigqueue_max);
+P1B_SYSCTL(CTL_P1003_1B_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.
+/* p31b_setcfg: Set the configuration
*/
-void posix4_facility(int num, int value)
+void p31b_setcfg(int num, int value)
{
- if (num >= 1 && num <= CTL_POSIX4_N_CTLS)
+ if (num >= 1 && num < CTL_P1003_1B_MAXID)
facility[num - 1] = value;
}
diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c
index ee2f340..5a64091 100644
--- a/sys/kern/syscalls.c
+++ b/sys/kern/syscalls.c
@@ -333,4 +333,12 @@ char *syscallnames[] = {
"mlockall", /* 324 = mlockall */
"munlockall", /* 325 = munlockall */
"__getcwd", /* 326 = __getcwd */
+ "sched_setparam", /* 327 = sched_setparam */
+ "sched_getparam", /* 328 = sched_getparam */
+ "sched_setscheduler", /* 329 = sched_setscheduler */
+ "sched_getscheduler", /* 330 = sched_getscheduler */
+ "sched_yield", /* 331 = sched_yield */
+ "sched_get_priority_max", /* 332 = sched_get_priority_max */
+ "sched_get_priority_min", /* 333 = sched_get_priority_min */
+ "sched_rr_get_interval", /* 334 = sched_rr_get_interval */
};
diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master
index a79702e..e233348 100644
--- a/sys/kern/syscalls.master
+++ b/sys/kern/syscalls.master
@@ -1,4 +1,4 @@
- $Id: syscalls.master,v 1.47 1998/01/30 11:33:01 phk Exp $
+ $Id: syscalls.master,v 1.48 1998/02/03 17:45:43 bde Exp $
; from: @(#)syscalls.master 8.2 (Berkeley) 1/13/94
;
; System call name/number master file.
@@ -461,3 +461,14 @@
324 STD BSD { int mlockall(int how); }
325 STD BSD { int munlockall(void); }
326 STD BSD { int __getcwd(u_char *buf, u_int buflen); }
+
+327 STD POSIX { int sched_setparam (pid_t pid, const struct sched_param *param); }
+328 STD POSIX { int sched_getparam (pid_t pid, struct sched_param *param); }
+
+329 STD POSIX { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
+330 STD POSIX { int sched_getscheduler (pid_t pid); }
+
+331 STD POSIX { int sched_yield (void); }
+332 STD POSIX { int sched_get_priority_max (int policy); }
+333 STD POSIX { int sched_get_priority_min (int policy); }
+334 STD POSIX { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
diff --git a/sys/kern/vfs_aio.c b/sys/kern/vfs_aio.c
index 33e524e..247eef0 100644
--- a/sys/kern/vfs_aio.c
+++ b/sys/kern/vfs_aio.c
@@ -13,11 +13,11 @@
* bad that happens because of using this software isn't the responsibility
* of the author. This software is distributed AS-IS.
*
- * $Id: vfs_aio.c,v 1.24 1998/02/25 06:30:15 bde Exp $
+ * $Id: vfs_aio.c,v 1.25 1998/03/28 10:33:09 bde Exp $
*/
/*
- * This file contains support for the POSIX.4 AIO/LIO facility.
+ * This file contains support for the POSIX 1003.1B AIO/LIO facility.
*/
#include <sys/param.h>
OpenPOWER on IntegriCloud