Merge from vendor branch FILE:
[dragonfly.git] / sys / emulation / posix4 / p1003_1b.c
1 /*
2  * Copyright (c) 1996, 1997, 1998
3  *      HD Associates, Inc.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by HD Associates, Inc
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY HD ASSOCIATES AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL HD ASSOCIATES OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * $FreeBSD: src/sys/posix4/p1003_1b.c,v 1.5.2.2 2003/03/25 06:13:35 rwatson Exp $
33  * $DragonFly: src/sys/emulation/posix4/Attic/p1003_1b.c,v 1.7 2003/11/27 19:11:17 dillon Exp $
34  */
35
36 /* p1003_1b: Real Time common code.
37  */
38
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/kernel.h>
42 #include <sys/sysent.h>
43 #include <sys/proc.h>
44 #include <sys/syslog.h>
45 #include <sys/module.h>
46 #include <sys/sysproto.h>
47 #include <sys/sysctl.h>
48
49 #include "posix4.h"
50
51 MALLOC_DEFINE(M_P31B, "p1003.1b", "Posix 1003.1B");
52
53 /* p31b_proc: Return a proc struct corresponding to a pid to operate on.
54  *
55  * Enforce permission policy.
56  *
57  * The policy is the same as for sending signals except there
58  * is no notion of process groups.
59  *
60  * pid == 0 means my process.
61  *
62  * This is disabled until I've got a permission gate in again:
63  * only root can do this.
64  */
65
66 #if 0
67 /*
68  * This is stolen from CANSIGNAL in kern_sig:
69  *
70  * Can process p, with pcred pc, do "write flavor" operations to process q?
71  */
72 #define CAN_AFFECT(p, cr, q) \
73         ((cr)->cr_uid == 0 || \
74             (cr)->cr_ruid == (q)->p_ucred->cr_ruid || \
75             (cr)->cr_uid == (q)->p_ucred->cr_ruid || \
76             (cr)->cr_ruid == (q)->p_ucred->cr_uid || \
77             (cr)->cr_uid == (q)->p_ucred->cr_uid)
78 #else
79 #define CAN_AFFECT(p, cr, q) ((cr)->cr_uid == 0)
80 #endif
81
82 /*
83  * p31b_proc: Look up a proc from a PID.  If proc is 0 it is
84  * my own proc.
85  */
86 int p31b_proc(struct proc *p, pid_t pid, struct proc **pp)
87 {
88         int ret = 0;
89         struct proc *other_proc = 0;
90
91         if (pid == 0)
92                 other_proc = p;
93         else
94                 other_proc = pfind(pid);
95
96         if (other_proc)
97         {
98                 /* Enforce permission policy.
99                  */
100                 if (CAN_AFFECT(p, p->p_ucred, other_proc))
101                         *pp = other_proc;
102                 else
103                         ret = EPERM;
104         }
105         else
106                 ret = ESRCH;
107
108         return ret;
109 }
110
111
112 #if !defined(_KPOSIX_PRIORITY_SCHEDULING)
113
114 int syscall_not_present(const char *s);
115
116 /* The system calls return ENOSYS if an entry is called that is
117  * not run-time supported.  I am also logging since some programs
118  * start to use this when they shouldn't.  That will be removed if annoying.
119  */
120 int syscall_not_present(const char *s)
121 {
122         struct proc *p = curproc;
123         log(LOG_ERR, "cmd %s pid %d tried to use non-present %s\n",
124                         p->p_comm, p->p_pid, s);
125
126         /* a " return nosys(p, uap); " here causes a core dump.
127          */
128
129         return ENOSYS;
130 }
131
132 /* Not configured but loadable via a module:
133  */
134
135 static int sched_attach(void)
136 {
137         return 0;
138 }
139
140 #define SYSCALL_NOT_PRESENT_GEN(SC) \
141 int SC (struct SC##_args *uap) \
142 { \
143         return syscall_not_present(#SC); \
144 }
145
146 SYSCALL_NOT_PRESENT_GEN(sched_setparam)
147 SYSCALL_NOT_PRESENT_GEN(sched_getparam)
148 SYSCALL_NOT_PRESENT_GEN(sched_setscheduler)
149 SYSCALL_NOT_PRESENT_GEN(sched_getscheduler)
150 SYSCALL_NOT_PRESENT_GEN(sched_yield)
151 SYSCALL_NOT_PRESENT_GEN(sched_get_priority_max)
152 SYSCALL_NOT_PRESENT_GEN(sched_get_priority_min)
153 SYSCALL_NOT_PRESENT_GEN(sched_rr_get_interval)
154
155 #else
156
157 /* Configured in kernel version:
158  */
159 static struct ksched *ksched;
160
161 static int sched_attach(void)
162 {
163         int ret = ksched_attach(&ksched);
164
165         if (ret == 0)
166                 p31b_setcfg(CTL_P1003_1B_PRIORITY_SCHEDULING, 1);
167
168         return ret;
169 }
170
171 int
172 sched_setparam(struct sched_setparam_args *uap)
173 {
174         struct proc *p = curproc;
175         int e;
176
177         struct sched_param sched_param;
178         copyin(uap->param, &sched_param, sizeof(sched_param));
179
180         if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
181                 e = ksched_setparam(&uap->sysmsg_result, ksched, p,
182                     (const struct sched_param *)&sched_param);
183         }
184         return e;
185 }
186
187 int
188 sched_getparam(struct sched_getparam_args *uap)
189 {
190         struct proc *p = curproc;
191         struct proc *targetp;
192         struct sched_param sched_param;
193         int e;
194  
195         if (uap->pid != 0 && uap->pid != p->p_pid) {
196                 e = p31b_proc(p, uap->pid, &targetp);
197                 if (e)
198                         return e;
199         } else {
200                 targetp = p;
201         }
202  
203         e = ksched_getparam(&uap->sysmsg_result, ksched, targetp, &sched_param);
204
205         if (!e)
206                 copyout(&sched_param, uap->param, sizeof(sched_param));
207
208         return e;
209 }
210
211 int
212 sched_setscheduler(struct sched_setscheduler_args *uap)
213 {
214         struct proc *p = curproc;
215         int e;
216
217         struct sched_param sched_param;
218         copyin(uap->param, &sched_param, sizeof(sched_param));
219
220         if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
221                 e = ksched_setscheduler(&uap->sysmsg_result, ksched, p,
222                     uap->policy, (const struct sched_param *)&sched_param);
223         }
224         return e;
225 }
226
227 int
228 sched_getscheduler(struct sched_getscheduler_args *uap)
229 {
230         struct proc *p = curproc;
231         struct proc *targetp;
232         int e;
233  
234         if (uap->pid != 0 && uap->pid != p->p_pid) {
235                 e = p31b_proc(p, uap->pid, &targetp);
236                 if (e)
237                         return e;
238         } else {
239                 targetp = p;
240         }
241  
242         e = ksched_getscheduler(&uap->sysmsg_result, ksched, targetp);
243
244         return e;
245 }
246
247 int
248 sched_yield(struct sched_yield_args *uap)
249 {
250         return ksched_yield(&uap->sysmsg_result, ksched);
251 }
252
253 int
254 sched_get_priority_max(struct sched_get_priority_max_args *uap)
255 {
256         return ksched_get_priority_max(&uap->sysmsg_result, ksched, uap->policy);
257 }
258
259 int
260 sched_get_priority_min(struct sched_get_priority_min_args *uap)
261 {
262         return ksched_get_priority_min(&uap->sysmsg_result, ksched, uap->policy);
263 }
264
265 int
266 sched_rr_get_interval(struct sched_rr_get_interval_args *uap)
267 {
268         int e;
269         struct proc *p = curproc;
270
271         if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
272             e = ksched_rr_get_interval(&uap->sysmsg_result, ksched,
273                     p, uap->interval);
274         }
275         return e;
276 }
277
278 #endif
279
280 static void p31binit(void *notused)
281 {
282         (void) sched_attach();
283         p31b_setcfg(CTL_P1003_1B_PAGESIZE, PAGE_SIZE);
284 }
285
286 SYSINIT(p31b, SI_SUB_P1003_1B, SI_ORDER_FIRST, p31binit, NULL);