Allow kernel to be compile without _KPOSIX_PRIORITY_SCHEDULING.
[dragonfly.git] / sys / kern / kern_p1003_1b.c
index bbb5b39..bf4acbe 100644 (file)
@@ -46,6 +46,9 @@
 #include <sys/module.h>
 #include <sys/sysproto.h>
 #include <sys/sysctl.h>
+#include <sys/unistd.h>
+
+#include <sys/mplock2.h>
 
 MALLOC_DEFINE(M_P31B, "p1003.1b", "Posix 1003.1B");
 
@@ -137,7 +140,7 @@ static int sched_attach(void)
 }
 
 #define SYSCALL_NOT_PRESENT_GEN(SC) \
-int SC (struct SC##_args *uap) \
+int sys_##SC (struct SC##_args *uap) \
 { \
        return syscall_not_present(#SC); \
 }
@@ -167,24 +170,32 @@ static int sched_attach(void)
        return ret;
 }
 
+/*
+ * MPALMOSTSAFE
+ */
 int
 sys_sched_setparam(struct sched_setparam_args *uap)
 {
        struct proc *p = curproc;
        struct lwp *lp;
        int e;
-
        struct sched_param sched_param;
+
        copyin(uap->param, &sched_param, sizeof(sched_param));
 
+       get_mplock();
        if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
                lp = FIRST_LWP_IN_PROC(p); /* XXX lwp */
-               e = ksched_setparam(&uap->sysmsg_result, ksched, lp,
-                   (const struct sched_param *)&sched_param);
+               e = ksched_setparam(&uap->sysmsg_reg, ksched, lp,
+                                   (const struct sched_param *)&sched_param);
        }
+       rel_mplock();
        return e;
 }
 
+/*
+ * MPALMOSTSAFE
+ */
 int
 sys_sched_getparam(struct sched_getparam_args *uap)
 {
@@ -194,41 +205,51 @@ sys_sched_getparam(struct sched_getparam_args *uap)
        struct sched_param sched_param;
        int e;
  
+       get_mplock();
        if (uap->pid != 0 && uap->pid != p->p_pid) {
                e = p31b_proc(p, uap->pid, &targetp);
                if (e)
-                       return e;
+                       goto done;
        } else {
                targetp = p;
        }
  
        lp = FIRST_LWP_IN_PROC(targetp); /* XXX lwp */
-       e = ksched_getparam(&uap->sysmsg_result, ksched, lp, &sched_param);
-
-       if (!e)
+       e = ksched_getparam(&uap->sysmsg_reg, ksched, lp, &sched_param);
+done:
+       rel_mplock();
+       if (e == 0)
                copyout(&sched_param, uap->param, sizeof(sched_param));
-
        return e;
 }
 
+/*
+ * MPALMOSTSAFE
+ */
 int
 sys_sched_setscheduler(struct sched_setscheduler_args *uap)
 {
        struct proc *p = curproc;
        struct lwp *lp;
        int e;
-
        struct sched_param sched_param;
+
        copyin(uap->param, &sched_param, sizeof(sched_param));
 
+       get_mplock();
        if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
                lp = FIRST_LWP_IN_PROC(p); /* XXX lwp */
-               e = ksched_setscheduler(&uap->sysmsg_result, ksched, lp,
-                   uap->policy, (const struct sched_param *)&sched_param);
+               e = ksched_setscheduler(&uap->sysmsg_reg, ksched, lp,
+                                       uap->policy,
+                                   (const struct sched_param *)&sched_param);
        }
+       rel_mplock();
        return e;
 }
 
+/*
+ * MPALMOSTSAFE
+ */
 int
 sys_sched_getscheduler(struct sched_getscheduler_args *uap)
 {
@@ -237,58 +258,79 @@ sys_sched_getscheduler(struct sched_getscheduler_args *uap)
        struct lwp *lp;
        int e;
  
+       get_mplock();
        if (uap->pid != 0 && uap->pid != p->p_pid) {
                e = p31b_proc(p, uap->pid, &targetp);
                if (e)
-                       return e;
+                       goto done;
        } else {
                targetp = p;
        }
  
        lp = FIRST_LWP_IN_PROC(targetp); /* XXX lwp */
-       e = ksched_getscheduler(&uap->sysmsg_result, ksched, lp);
-
+       e = ksched_getscheduler(&uap->sysmsg_reg, ksched, lp);
+done:
+       rel_mplock();
        return e;
 }
 
+/*
+ * MPSAFE
+ */
 int
 sys_sched_yield(struct sched_yield_args *uap)
 {
-       return ksched_yield(&uap->sysmsg_result, ksched);
+       return ksched_yield(&uap->sysmsg_reg, ksched);
 }
 
+/*
+ * MPSAFE
+ */
 int
 sys_sched_get_priority_max(struct sched_get_priority_max_args *uap)
 {
-       return ksched_get_priority_max(&uap->sysmsg_result, ksched, uap->policy);
+       return ksched_get_priority_max(&uap->sysmsg_reg, ksched, uap->policy);
 }
 
+/*
+ * MPSAFE
+ */
 int
 sys_sched_get_priority_min(struct sched_get_priority_min_args *uap)
 {
-       return ksched_get_priority_min(&uap->sysmsg_result, ksched, uap->policy);
+       return ksched_get_priority_min(&uap->sysmsg_reg, ksched, uap->policy);
 }
 
+/*
+ * MPALMOSTSAFE
+ */
 int
 sys_sched_rr_get_interval(struct sched_rr_get_interval_args *uap)
 {
        int e;
        struct proc *p = curproc;
        struct lwp *lp = curthread->td_lwp;
+       struct timespec ts;
 
+       get_mplock();
        if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
-           e = ksched_rr_get_interval(&uap->sysmsg_result, ksched,
-                   lp, uap->interval);
+               e = ksched_rr_get_interval(&uap->sysmsg_reg, ksched, lp, &ts);
+               if (e == 0)
+                       e = copyout(&ts, uap->interval, sizeof(ts));
        }
+       rel_mplock();
        return e;
 }
 
 #endif
 
-static void p31binit(void *notused)
+static void
+p31binit(void *notused)
 {
        (void) sched_attach();
        p31b_setcfg(CTL_P1003_1B_PAGESIZE, PAGE_SIZE);
+       p31b_setcfg(CTL_P1003_1B_ASYNCHRONOUS_IO, -1);
+       p31b_setcfg(CTL_P1003_1B_MESSAGE_PASSING, _POSIX_MESSAGE_PASSING);
 }
 
 SYSINIT(p31b, SI_SUB_P1003_1B, SI_ORDER_FIRST, p31binit, NULL);