home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / sys / vm / vm_unix.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-20  |  3.8 KB  |  133 lines
  1. /*
  2.  * Copyright (c) 1988 University of Utah.
  3.  * Copyright (c) 1991 The Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * This code is derived from software contributed to Berkeley by
  7.  * the Systems Programming Group of the University of Utah Computer
  8.  * Science Department.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  *    This product includes software developed by the University of
  21.  *    California, Berkeley and its contributors.
  22.  * 4. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  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.  * from: Utah $Hdr: vm_unix.c 1.1 89/11/07$
  39.  *
  40.  *    @(#)vm_unix.c    7.2 (Berkeley) 4/20/91
  41.  */
  42.  
  43. /*
  44.  * Traditional sbrk/grow interface to VM
  45.  */
  46. #include "param.h"
  47. #include "systm.h"
  48. #include "proc.h"
  49. #include "resourcevar.h"
  50.  
  51. #include "vm.h"
  52.  
  53. /* ARGSUSED */
  54. obreak(p, uap, retval)
  55.     struct proc *p;
  56.     struct args {
  57.         char    *nsiz;
  58.     } *uap;
  59.     int *retval;
  60. {
  61.     register struct vmspace *vm = p->p_vmspace;
  62.     vm_offset_t new, old;
  63.     int rv;
  64.     register int diff;
  65.  
  66.     old = (vm_offset_t)vm->vm_daddr;
  67.     new = round_page(uap->nsiz);
  68.     if ((int)(new - old) > p->p_rlimit[RLIMIT_DATA].rlim_cur)
  69.         return(ENOMEM);
  70.     old = round_page(old + ctob(vm->vm_dsize));
  71.     diff = new - old;
  72.     if (diff > 0) {
  73.         rv = vm_allocate(&vm->vm_map, &old, diff, FALSE);
  74.         if (rv != KERN_SUCCESS) {
  75.             uprintf("sbrk: grow failed, return = %d\n", rv);
  76.             return(ENOMEM);
  77.         }
  78.         vm->vm_dsize += btoc(diff);
  79.     } else if (diff < 0) {
  80.         diff = -diff;
  81.         rv = vm_deallocate(&vm->vm_map, new, diff);
  82.         if (rv != KERN_SUCCESS) {
  83.             uprintf("sbrk: shrink failed, return = %d\n", rv);
  84.             return(ENOMEM);
  85.         }
  86.         vm->vm_dsize -= btoc(diff);
  87.     }
  88.     return(0);
  89. }
  90.  
  91. /*
  92.  * Enlarge the "stack segment" to include the specified
  93.  * stack pointer for the process.
  94.  */
  95. grow(p, sp)
  96.     struct proc *p;
  97.     unsigned sp;
  98. {
  99.     register struct vmspace *vm = p->p_vmspace;
  100.     register int si;
  101.  
  102.     /*
  103.      * For user defined stacks (from sendsig).
  104.      */
  105.     if (sp < (unsigned)vm->vm_maxsaddr)
  106.         return (0);
  107.     /*
  108.      * For common case of already allocated (from trap).
  109.      */
  110.     if (sp >= USRSTACK - ctob(vm->vm_ssize))
  111.         return (1);
  112.     /*
  113.      * Really need to check vs limit and increment stack size if ok.
  114.      */
  115.     si = clrnd(btoc(USRSTACK-sp) - vm->vm_ssize);
  116.     if (vm->vm_ssize + si > btoc(p->p_rlimit[RLIMIT_STACK].rlim_cur))
  117.         return (0);
  118.     vm->vm_ssize += si;
  119.     return (1);
  120. }
  121.  
  122. /* ARGSUSED */
  123. ovadvise(p, uap, retval)
  124.     struct proc *p;
  125.     struct args {
  126.         int    anom;
  127.     } *uap;
  128.     int *retval;
  129. {
  130.  
  131.     return (EINVAL);
  132. }
  133.