Deleted Added
sdiff udiff text old ( 124802 ) new ( 125454 )
full compact
svr4_misc.c (124802) svr4_misc.c (125454)
1/*
2 * Copyright (c) 1998 Mark Newton
3 * Copyright (c) 1994 Christos Zoulas
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:

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

28/*
29 * SVR4 compatibility module.
30 *
31 * SVR4 system calls that are implemented differently in BSD are
32 * handled here.
33 */
34
35#include <sys/cdefs.h>
1/*
2 * Copyright (c) 1998 Mark Newton
3 * Copyright (c) 1994 Christos Zoulas
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:

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

28/*
29 * SVR4 compatibility module.
30 *
31 * SVR4 system calls that are implemented differently in BSD are
32 * handled here.
33 */
34
35#include <sys/cdefs.h>
36__FBSDID("$FreeBSD: head/sys/compat/svr4/svr4_misc.c 124802 2004-01-21 17:10:47Z rwatson $");
36__FBSDID("$FreeBSD: head/sys/compat/svr4/svr4_misc.c 125454 2004-02-04 21:52:57Z jhb $");
37
38#include "opt_mac.h"
39
40#include <sys/param.h>
41#include <sys/systm.h>
42#include <sys/dirent.h>
43#include <sys/fcntl.h>
44#include <sys/filedesc.h>

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

815 struct proc *p = td->td_proc;
816 struct vmspace *vm = p->p_vmspace;
817 vm_offset_t new, old, base, ns;
818 int rv;
819
820 base = round_page((vm_offset_t) vm->vm_daddr);
821 ns = (vm_offset_t)uap->nsize;
822 new = round_page(ns);
37
38#include "opt_mac.h"
39
40#include <sys/param.h>
41#include <sys/systm.h>
42#include <sys/dirent.h>
43#include <sys/fcntl.h>
44#include <sys/filedesc.h>

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

815 struct proc *p = td->td_proc;
816 struct vmspace *vm = p->p_vmspace;
817 vm_offset_t new, old, base, ns;
818 int rv;
819
820 base = round_page((vm_offset_t) vm->vm_daddr);
821 ns = (vm_offset_t)uap->nsize;
822 new = round_page(ns);
823 /* For p_rlimit. */
824 mtx_assert(&Giant, MA_OWNED);
825 if (new > base) {
823 if (new > base) {
826 if ((new - base) > (unsigned) td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur) {
824 PROC_LOCK(p);
825 if ((new - base) > (unsigned)lim_cur(p, RLIMIT_DATA)) {
826 PROC_UNLOCK(p);
827 return ENOMEM;
827 return ENOMEM;
828 }
829 if (new >= VM_MAXUSER_ADDRESS) {
830 return (ENOMEM);
831 }
828 }
829 PROC_UNLOCK(p);
830 if (new >= VM_MAXUSER_ADDRESS)
831 return (ENOMEM);
832 } else if (new < base) {
833 /*
834 * This is simply an invalid value. If someone wants to
835 * do fancy address space manipulations, mmap and munmap
836 * can do most of what the user would want.
837 */
838 return EINVAL;
839 }
840
841 old = base + ctob(vm->vm_dsize);
842
843 if (new > old) {
844 vm_size_t diff;
845 diff = new - old;
832 } else if (new < base) {
833 /*
834 * This is simply an invalid value. If someone wants to
835 * do fancy address space manipulations, mmap and munmap
836 * can do most of what the user would want.
837 */
838 return EINVAL;
839 }
840
841 old = base + ctob(vm->vm_dsize);
842
843 if (new > old) {
844 vm_size_t diff;
845 diff = new - old;
846 if (vm->vm_map.size + diff > p->p_rlimit[RLIMIT_VMEM].rlim_cur)
846 PROC_LOCK(p);
847 if (vm->vm_map.size + diff > lim_cur(p, RLIMIT_VMEM)) {
848 PROC_UNLOCK(p);
847 return(ENOMEM);
849 return(ENOMEM);
850 }
851 PROC_UNLOCK(p);
848 rv = vm_map_find(&vm->vm_map, NULL, 0, &old, diff, FALSE,
849 VM_PROT_ALL, VM_PROT_ALL, 0);
850 if (rv != KERN_SUCCESS) {
851 return (ENOMEM);
852 }
853 vm->vm_dsize += btoc(diff);
854 } else if (new < old) {
855 rv = vm_map_remove(&vm->vm_map, new, old);

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

917
918
919int
920svr4_sys_ulimit(td, uap)
921 struct thread *td;
922 struct svr4_sys_ulimit_args *uap;
923{
924 int *retval = td->td_retval;
852 rv = vm_map_find(&vm->vm_map, NULL, 0, &old, diff, FALSE,
853 VM_PROT_ALL, VM_PROT_ALL, 0);
854 if (rv != KERN_SUCCESS) {
855 return (ENOMEM);
856 }
857 vm->vm_dsize += btoc(diff);
858 } else if (new < old) {
859 rv = vm_map_remove(&vm->vm_map, new, old);

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

921
922
923int
924svr4_sys_ulimit(td, uap)
925 struct thread *td;
926 struct svr4_sys_ulimit_args *uap;
927{
928 int *retval = td->td_retval;
929 int error;
925
926 switch (uap->cmd) {
927 case SVR4_GFILLIM:
930
931 switch (uap->cmd) {
932 case SVR4_GFILLIM:
928 /* For p_rlimit below. */
929 mtx_assert(&Giant, MA_OWNED);
930 *retval = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur / 512;
933 PROC_LOCK(td->td_proc);
934 *retval = lim_cur(td->td_proc, RLIMIT_FSIZE) / 512;
935 PROC_UNLOCK(td->td_proc);
931 if (*retval == -1)
932 *retval = 0x7fffffff;
933 return 0;
934
935 case SVR4_SFILLIM:
936 {
936 if (*retval == -1)
937 *retval = 0x7fffffff;
938 return 0;
939
940 case SVR4_SFILLIM:
941 {
937 int error;
938 struct __setrlimit_args srl;
939 struct rlimit krl;
942 struct rlimit krl;
940 caddr_t sg = stackgap_init();
941 struct rlimit *url = (struct rlimit *)
942 stackgap_alloc(&sg, sizeof *url);
943
944 krl.rlim_cur = uap->newlimit * 512;
943
944 krl.rlim_cur = uap->newlimit * 512;
945 mtx_assert(&Giant, MA_OWNED);
946 krl.rlim_max = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_max;
945 PROC_LOCK(td->td_proc);
946 krl.rlim_max = lim_max(td->td_proc, RLIMIT_FSIZE);
947 PROC_UNLOCK(td->td_proc);
947
948
948 error = copyout(&krl, url, sizeof(*url));
949 error = kern_setrlimit(td, RLIMIT_FSIZE, &krl);
949 if (error)
950 return error;
951
950 if (error)
951 return error;
952
952 srl.which = RLIMIT_FSIZE;
953 srl.rlp = url;
954
955 error = setrlimit(td, &srl);
956 if (error)
957 return error;
958
959 mtx_assert(&Giant, MA_OWNED);
960 *retval = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur;
953 PROC_LOCK(td->td_proc);
954 *retval = lim_cur(td->td_proc, RLIMIT_FSIZE);
955 PROC_UNLOCK(td->td_proc);
961 if (*retval == -1)
962 *retval = 0x7fffffff;
963 return 0;
964 }
965
966 case SVR4_GMEMLIM:
967 {
968 struct vmspace *vm = td->td_proc->p_vmspace;
969 register_t r;
970
956 if (*retval == -1)
957 *retval = 0x7fffffff;
958 return 0;
959 }
960
961 case SVR4_GMEMLIM:
962 {
963 struct vmspace *vm = td->td_proc->p_vmspace;
964 register_t r;
965
971 mtx_assert(&Giant, MA_OWNED);
972 r = td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur;
966 PROC_LOCK(td->td_proc);
967 r = lim_cur(td->td_proc, RLIMIT_DATA);
968 PROC_UNLOCK(td->td_proc);
973
974 if (r == -1)
975 r = 0x7fffffff;
969
970 if (r == -1)
971 r = 0x7fffffff;
972 mtx_lock(&Giant); /* XXX */
976 r += (long) vm->vm_daddr;
973 r += (long) vm->vm_daddr;
974 mtx_unlock(&Giant);
977 if (r < 0)
978 r = 0x7fffffff;
979 *retval = r;
980 return 0;
981 }
982
983 case SVR4_GDESLIM:
975 if (r < 0)
976 r = 0x7fffffff;
977 *retval = r;
978 return 0;
979 }
980
981 case SVR4_GDESLIM:
984 mtx_assert(&Giant, MA_OWNED);
985 *retval = td->td_proc->p_rlimit[RLIMIT_NOFILE].rlim_cur;
982 PROC_LOCK(td->td_proc);
983 *retval = lim_cur(td->td_proc, RLIMIT_NOFILE);
984 PROC_UNLOCK(td->td_proc);
986 if (*retval == -1)
987 *retval = 0x7fffffff;
988 return 0;
989
990 default:
991 return EINVAL;
992 }
993}

--- 757 unchanged lines hidden --- 		985 if (*retval == -1)
986 *retval = 0x7fffffff;
987 return 0;
988
989 default:
990 return EINVAL;
991 }
992}

--- 757 unchanged lines hidden ---