Deleted Added
sdiff udiff text old ( 80116 ) new ( 82749 )
full compact
kern_resource.c (80116) kern_resource.c (82749)
1/*-
2 * Copyright (c) 1982, 1986, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.

--- 22 unchanged lines hidden (view full) ---

31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 *
38 * @(#)kern_resource.c 8.5 (Berkeley) 1/21/94
1/*-
2 * Copyright (c) 1982, 1986, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.

--- 22 unchanged lines hidden (view full) ---

31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 *
38 * @(#)kern_resource.c 8.5 (Berkeley) 1/21/94
39 * $FreeBSD: head/sys/kern/kern_resource.c 80116 2001-07-22 00:21:19Z assar $
39 * $FreeBSD: head/sys/kern/kern_resource.c 82749 2001-09-01 19:04:37Z dillon $
40 */
41
42#include "opt_compat.h"
43#include "opt_rlimit.h"
44
45#include <sys/param.h>
46#include <sys/systm.h>
47#include <sys/sysproto.h>

--- 27 unchanged lines hidden (view full) ---

75 */
76
77#ifndef _SYS_SYSPROTO_H_
78struct getpriority_args {
79 int which;
80 int who;
81};
82#endif
40 */
41
42#include "opt_compat.h"
43#include "opt_rlimit.h"
44
45#include <sys/param.h>
46#include <sys/systm.h>
47#include <sys/sysproto.h>

--- 27 unchanged lines hidden (view full) ---

75 */
76
77#ifndef _SYS_SYSPROTO_H_
78struct getpriority_args {
79 int which;
80 int who;
81};
82#endif
83/*
84 * MPSAFE
85 */
83int
84getpriority(curp, uap)
85 struct proc *curp;
86 register struct getpriority_args *uap;
87{
88 register struct proc *p;
89 register int low = PRIO_MAX + 1;
86int
87getpriority(curp, uap)
88 struct proc *curp;
89 register struct getpriority_args *uap;
90{
91 register struct proc *p;
92 register int low = PRIO_MAX + 1;
93 int error = 0;
90
94
91 switch (uap->which) {
95 mtx_lock(&Giant);
92
96
97 switch (uap->which) {
93 case PRIO_PROCESS:
94 if (uap->who == 0)
95 low = curp->p_nice;
96 else {
97 p = pfind(uap->who);
98 if (p == NULL)
99 break;
100 if (p_cansee(curp, p) == 0)

--- 24 unchanged lines hidden (view full) ---

125 if (!p_cansee(curp, p) &&
126 p->p_ucred->cr_uid == uap->who &&
127 p->p_nice < low)
128 low = p->p_nice;
129 sx_sunlock(&allproc_lock);
130 break;
131
132 default:
98 case PRIO_PROCESS:
99 if (uap->who == 0)
100 low = curp->p_nice;
101 else {
102 p = pfind(uap->who);
103 if (p == NULL)
104 break;
105 if (p_cansee(curp, p) == 0)

--- 24 unchanged lines hidden (view full) ---

130 if (!p_cansee(curp, p) &&
131 p->p_ucred->cr_uid == uap->who &&
132 p->p_nice < low)
133 low = p->p_nice;
134 sx_sunlock(&allproc_lock);
135 break;
136
137 default:
133 return (EINVAL);
138 error = EINVAL;
139 break;
134 }
140 }
135 if (low == PRIO_MAX + 1)
136 return (ESRCH);
141 if (low == PRIO_MAX + 1 && error == 0)
142 error = ESRCH;
137 curp->p_retval[0] = low;
143 curp->p_retval[0] = low;
138 return (0);
144 mtx_unlock(&Giant);
145 return (error);
139}
140
141#ifndef _SYS_SYSPROTO_H_
142struct setpriority_args {
143 int which;
144 int who;
145 int prio;
146};
147#endif
146}
147
148#ifndef _SYS_SYSPROTO_H_
149struct setpriority_args {
150 int which;
151 int who;
152 int prio;
153};
154#endif
155/*
156 * MPSAFE
157 */
148/* ARGSUSED */
149int
150setpriority(curp, uap)
151 struct proc *curp;
152 register struct setpriority_args *uap;
153{
154 register struct proc *p;
155 int found = 0, error = 0;
156
158/* ARGSUSED */
159int
160setpriority(curp, uap)
161 struct proc *curp;
162 register struct setpriority_args *uap;
163{
164 register struct proc *p;
165 int found = 0, error = 0;
166
157 switch (uap->which) {
167 mtx_lock(&Giant);
158
168
169 switch (uap->which) {
159 case PRIO_PROCESS:
160 if (uap->who == 0)
161 error = donice(curp, curp, uap->prio);
162 else {
163 p = pfind(uap->who);
164 if (p == 0)
165 break;
166 if (p_cansee(curp, p) == 0)

--- 28 unchanged lines hidden (view full) ---

195 !p_cansee(curp, p)) {
196 error = donice(curp, p, uap->prio);
197 found++;
198 }
199 sx_sunlock(&allproc_lock);
200 break;
201
202 default:
170 case PRIO_PROCESS:
171 if (uap->who == 0)
172 error = donice(curp, curp, uap->prio);
173 else {
174 p = pfind(uap->who);
175 if (p == 0)
176 break;
177 if (p_cansee(curp, p) == 0)

--- 28 unchanged lines hidden (view full) ---

206 !p_cansee(curp, p)) {
207 error = donice(curp, p, uap->prio);
208 found++;
209 }
210 sx_sunlock(&allproc_lock);
211 break;
212
213 default:
203 return (EINVAL);
214 error = EINVAL;
215 break;
204 }
216 }
205 if (found == 0)
206 return (ESRCH);
217 if (found == 0 && error == 0)
218 error = ESRCH;
219 mtx_unlock(&Giant);
207 return (error);
208}
209
210static int
211donice(curp, chgp, n)
212 register struct proc *curp, *chgp;
213 register int n;
214{

--- 20 unchanged lines hidden (view full) ---

235 struct rtprio *rtp;
236};
237#endif
238
239/*
240 * Set realtime priority
241 */
242
220 return (error);
221}
222
223static int
224donice(curp, chgp, n)
225 register struct proc *curp, *chgp;
226 register int n;
227{

--- 20 unchanged lines hidden (view full) ---

248 struct rtprio *rtp;
249};
250#endif
251
252/*
253 * Set realtime priority
254 */
255
256/*
257 * MPSAFE
258 */
243/* ARGSUSED */
244int
245rtprio(curp, uap)
246 struct proc *curp;
247 register struct rtprio_args *uap;
248{
249 register struct proc *p;
250 struct rtprio rtp;
251 int error;
252
259/* ARGSUSED */
260int
261rtprio(curp, uap)
262 struct proc *curp;
263 register struct rtprio_args *uap;
264{
265 register struct proc *p;
266 struct rtprio rtp;
267 int error;
268
269 mtx_lock(&Giant);
270
253 if (uap->pid == 0) {
254 p = curp;
255 PROC_LOCK(p);
271 if (uap->pid == 0) {
272 p = curp;
273 PROC_LOCK(p);
256 } else
274 } else {
257 p = pfind(uap->pid);
275 p = pfind(uap->pid);
276 }
258
277
259 if (p == NULL)
260 return (ESRCH);
278 if (p == NULL) {
279 error = ESRCH;
280 goto done2;
281 }
261
262 switch (uap->function) {
263 case RTP_LOOKUP:
264 if ((error = p_cansee(curp, p)))
265 break;
266 pri_to_rtp(&p->p_pri, &rtp);
267 error = copyout(&rtp, uap->rtp, sizeof(struct rtprio));
268 break;

--- 26 unchanged lines hidden (view full) ---

295 }
296 error = rtp_to_pri(&rtp, &p->p_pri);
297 break;
298 default:
299 error = EINVAL;
300 break;
301 }
302 PROC_UNLOCK(p);
282
283 switch (uap->function) {
284 case RTP_LOOKUP:
285 if ((error = p_cansee(curp, p)))
286 break;
287 pri_to_rtp(&p->p_pri, &rtp);
288 error = copyout(&rtp, uap->rtp, sizeof(struct rtprio));
289 break;

--- 26 unchanged lines hidden (view full) ---

316 }
317 error = rtp_to_pri(&rtp, &p->p_pri);
318 break;
319 default:
320 error = EINVAL;
321 break;
322 }
323 PROC_UNLOCK(p);
324done2:
325 mtx_unlock(&Giant);
303 return (error);
304}
305
306int
307rtp_to_pri(struct rtprio *rtp, struct priority *pri)
308{
309
310 if (rtp->prio > RTP_PRIO_MAX)

--- 39 unchanged lines hidden (view full) ---

350
351#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
352#ifndef _SYS_SYSPROTO_H_
353struct osetrlimit_args {
354 u_int which;
355 struct orlimit *rlp;
356};
357#endif
326 return (error);
327}
328
329int
330rtp_to_pri(struct rtprio *rtp, struct priority *pri)
331{
332
333 if (rtp->prio > RTP_PRIO_MAX)

--- 39 unchanged lines hidden (view full) ---

373
374#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
375#ifndef _SYS_SYSPROTO_H_
376struct osetrlimit_args {
377 u_int which;
378 struct orlimit *rlp;
379};
380#endif
381/*
382 * MPSAFE
383 */
358/* ARGSUSED */
359int
360osetrlimit(p, uap)
361 struct proc *p;
362 register struct osetrlimit_args *uap;
363{
364 struct orlimit olim;
365 struct rlimit lim;
366 int error;
367
368 if ((error =
369 copyin((caddr_t)uap->rlp, (caddr_t)&olim, sizeof(struct orlimit))))
370 return (error);
371 lim.rlim_cur = olim.rlim_cur;
372 lim.rlim_max = olim.rlim_max;
384/* ARGSUSED */
385int
386osetrlimit(p, uap)
387 struct proc *p;
388 register struct osetrlimit_args *uap;
389{
390 struct orlimit olim;
391 struct rlimit lim;
392 int error;
393
394 if ((error =
395 copyin((caddr_t)uap->rlp, (caddr_t)&olim, sizeof(struct orlimit))))
396 return (error);
397 lim.rlim_cur = olim.rlim_cur;
398 lim.rlim_max = olim.rlim_max;
373 return (dosetrlimit(p, uap->which, &lim));
399 mtx_lock(&Giant);
400 error = dosetrlimit(p, uap->which, &lim);
401 mtx_unlock(&Giant);
402 return (error);
374}
375
376#ifndef _SYS_SYSPROTO_H_
377struct ogetrlimit_args {
378 u_int which;
379 struct orlimit *rlp;
380};
381#endif
403}
404
405#ifndef _SYS_SYSPROTO_H_
406struct ogetrlimit_args {
407 u_int which;
408 struct orlimit *rlp;
409};
410#endif
411/*
412 * MPSAFE
413 */
382/* ARGSUSED */
383int
384ogetrlimit(p, uap)
385 struct proc *p;
386 register struct ogetrlimit_args *uap;
387{
388 struct orlimit olim;
414/* ARGSUSED */
415int
416ogetrlimit(p, uap)
417 struct proc *p;
418 register struct ogetrlimit_args *uap;
419{
420 struct orlimit olim;
421 int error;
389
390 if (uap->which >= RLIM_NLIMITS)
391 return (EINVAL);
422
423 if (uap->which >= RLIM_NLIMITS)
424 return (EINVAL);
425 mtx_lock(&Giant);
392 olim.rlim_cur = p->p_rlimit[uap->which].rlim_cur;
393 if (olim.rlim_cur == -1)
394 olim.rlim_cur = 0x7fffffff;
395 olim.rlim_max = p->p_rlimit[uap->which].rlim_max;
396 if (olim.rlim_max == -1)
397 olim.rlim_max = 0x7fffffff;
426 olim.rlim_cur = p->p_rlimit[uap->which].rlim_cur;
427 if (olim.rlim_cur == -1)
428 olim.rlim_cur = 0x7fffffff;
429 olim.rlim_max = p->p_rlimit[uap->which].rlim_max;
430 if (olim.rlim_max == -1)
431 olim.rlim_max = 0x7fffffff;
398 return (copyout((caddr_t)&olim, (caddr_t)uap->rlp, sizeof(olim)));
432 error = copyout((caddr_t)&olim, (caddr_t)uap->rlp, sizeof(olim));
433 mtx_unlock(&Giant);
434 return (error);
399}
400#endif /* COMPAT_43 || COMPAT_SUNOS */
401
402#ifndef _SYS_SYSPROTO_H_
403struct __setrlimit_args {
404 u_int which;
405 struct rlimit *rlp;
406};
407#endif
435}
436#endif /* COMPAT_43 || COMPAT_SUNOS */
437
438#ifndef _SYS_SYSPROTO_H_
439struct __setrlimit_args {
440 u_int which;
441 struct rlimit *rlp;
442};
443#endif
444/*
445 * MPSAFE
446 */
408/* ARGSUSED */
409int
410setrlimit(p, uap)
411 struct proc *p;
412 register struct __setrlimit_args *uap;
413{
414 struct rlimit alim;
415 int error;
416
417 if ((error =
418 copyin((caddr_t)uap->rlp, (caddr_t)&alim, sizeof (struct rlimit))))
419 return (error);
447/* ARGSUSED */
448int
449setrlimit(p, uap)
450 struct proc *p;
451 register struct __setrlimit_args *uap;
452{
453 struct rlimit alim;
454 int error;
455
456 if ((error =
457 copyin((caddr_t)uap->rlp, (caddr_t)&alim, sizeof (struct rlimit))))
458 return (error);
420 return (dosetrlimit(p, uap->which, &alim));
459 mtx_lock(&Giant);
460 error = dosetrlimit(p, uap->which, &alim);
461 mtx_unlock(&Giant);
462 return (error);
421}
422
423int
424dosetrlimit(p, which, limp)
425 struct proc *p;
426 u_int which;
427 struct rlimit *limp;
428{

--- 97 unchanged lines hidden (view full) ---

526}
527
528#ifndef _SYS_SYSPROTO_H_
529struct __getrlimit_args {
530 u_int which;
531 struct rlimit *rlp;
532};
533#endif
463}
464
465int
466dosetrlimit(p, which, limp)
467 struct proc *p;
468 u_int which;
469 struct rlimit *limp;
470{

--- 97 unchanged lines hidden (view full) ---

568}
569
570#ifndef _SYS_SYSPROTO_H_
571struct __getrlimit_args {
572 u_int which;
573 struct rlimit *rlp;
574};
575#endif
576/*
577 * MPSAFE
578 */
534/* ARGSUSED */
535int
536getrlimit(p, uap)
537 struct proc *p;
538 register struct __getrlimit_args *uap;
539{
579/* ARGSUSED */
580int
581getrlimit(p, uap)
582 struct proc *p;
583 register struct __getrlimit_args *uap;
584{
585 int error;
540
541 if (uap->which >= RLIM_NLIMITS)
542 return (EINVAL);
586
587 if (uap->which >= RLIM_NLIMITS)
588 return (EINVAL);
543 return (copyout((caddr_t)&p->p_rlimit[uap->which], (caddr_t)uap->rlp,
544 sizeof (struct rlimit)));
589 mtx_lock(&Giant);
590 error = copyout((caddr_t)&p->p_rlimit[uap->which], (caddr_t)uap->rlp,
591 sizeof (struct rlimit));
592 mtx_unlock(&Giant);
593 return(error);
545}
546
547/*
548 * Transform the running time and tick information in proc p into user,
549 * system, and interrupt time usage.
550 */
551void
552calcru(p, up, sp, ip)

--- 87 unchanged lines hidden (view full) ---

640}
641
642#ifndef _SYS_SYSPROTO_H_
643struct getrusage_args {
644 int who;
645 struct rusage *rusage;
646};
647#endif
594}
595
596/*
597 * Transform the running time and tick information in proc p into user,
598 * system, and interrupt time usage.
599 */
600void
601calcru(p, up, sp, ip)

--- 87 unchanged lines hidden (view full) ---

689}
690
691#ifndef _SYS_SYSPROTO_H_
692struct getrusage_args {
693 int who;
694 struct rusage *rusage;
695};
696#endif
697/*
698 * MPSAFE
699 */
648/* ARGSUSED */
649int
650getrusage(p, uap)
651 register struct proc *p;
652 register struct getrusage_args *uap;
653{
654 register struct rusage *rup;
700/* ARGSUSED */
701int
702getrusage(p, uap)
703 register struct proc *p;
704 register struct getrusage_args *uap;
705{
706 register struct rusage *rup;
707 int error = 0;
655
708
656 switch (uap->who) {
709 mtx_lock(&Giant);
657
710
711 switch (uap->who) {
658 case RUSAGE_SELF:
659 rup = &p->p_stats->p_ru;
660 mtx_lock_spin(&sched_lock);
661 calcru(p, &rup->ru_utime, &rup->ru_stime, NULL);
662 mtx_unlock_spin(&sched_lock);
663 break;
664
665 case RUSAGE_CHILDREN:
666 rup = &p->p_stats->p_cru;
667 break;
668
669 default:
712 case RUSAGE_SELF:
713 rup = &p->p_stats->p_ru;
714 mtx_lock_spin(&sched_lock);
715 calcru(p, &rup->ru_utime, &rup->ru_stime, NULL);
716 mtx_unlock_spin(&sched_lock);
717 break;
718
719 case RUSAGE_CHILDREN:
720 rup = &p->p_stats->p_cru;
721 break;
722
723 default:
670 return (EINVAL);
724 rup = NULL;
725 error = EINVAL;
726 break;
671 }
727 }
672 return (copyout((caddr_t)rup, (caddr_t)uap->rusage,
673 sizeof (struct rusage)));
728 mtx_unlock(&Giant);
729 if (error == 0) {
730 error = copyout((caddr_t)rup, (caddr_t)uap->rusage,
731 sizeof (struct rusage));
732 }
733 return(error);
674}
675
676void
677ruadd(ru, ru2)
678 register struct rusage *ru, *ru2;
679{
680 register long *ip, *ip2;
681 register int i;

--- 227 unchanged lines hidden --- 		734}
735
736void
737ruadd(ru, ru2)
738 register struct rusage *ru, *ru2;
739{
740 register long *ip, *ip2;
741 register int i;

--- 227 unchanged lines hidden ---