root/kern/sysv_shm.c

DEFINITIONS

1. shm_find_segment_by_key
2. shm_find_segment_by_shmid
3. shm_deallocate_segment
4. shm_delete_mapping
5. sys_shmdt
6. sys_shmat
7. sys_shmctl
8. shmctl1
9. shmget_existing
10. shmget_allocate_segment
11. sys_shmget
12. shmfork
13. shmexit
14. shminit
15. sysctl_sysvshm

    1 /*      $OpenBSD: sysv_shm.c,v 1.47 2007/05/29 10:44:28 sturm Exp $     */
    2 /*      $NetBSD: sysv_shm.c,v 1.50 1998/10/21 22:24:29 tron Exp $       */
    4 /*
    5  * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
    6  *
    7  * Permission to use, copy, modify, and distribute this software for any
    8  * purpose with or without fee is hereby granted, provided that the above
    9  * copyright notice and this permission notice appear in all copies.
   10  *
   11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   18  *
   19  * Sponsored in part by the Defense Advanced Research Projects
   20  * Agency (DARPA) and Air Force Research Laboratory, Air Force
   21  * Materiel Command, USAF, under agreement number F39502-99-1-0512.
   22  */
   23 /*
   24  * Copyright (c) 1994 Adam Glass and Charles M. Hannum.  All rights reserved.
   25  *
   26  * Redistribution and use in source and binary forms, with or without
   27  * modification, are permitted provided that the following conditions
   28  * are met:
   29  * 1. Redistributions of source code must retain the above copyright
   30  *    notice, this list of conditions and the following disclaimer.
   31  * 2. Redistributions in binary form must reproduce the above copyright
   32  *    notice, this list of conditions and the following disclaimer in the
   33  *    documentation and/or other materials provided with the distribution.
   34  * 3. All advertising materials mentioning features or use of this software
   35  *    must display the following acknowledgement:
   36  *      This product includes software developed by Adam Glass and Charles M.
   37  *      Hannum.
   38  * 4. The names of the authors may not be used to endorse or promote products
   39  *    derived from this software without specific prior written permission.
   40  *
   41  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
   42  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   43  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   44  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   45  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   47  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   48  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   49  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   50  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   51  */
   53 #include <sys/param.h>
   54 #include <sys/kernel.h>
   55 #include <sys/shm.h>
   56 #include <sys/proc.h>
   57 #include <sys/uio.h>
   58 #include <sys/time.h>
   59 #include <sys/malloc.h>
   60 #include <sys/mman.h>
   61 #include <sys/pool.h>
   62 #include <sys/systm.h>
   63 #include <sys/sysctl.h>
   64 #include <sys/stat.h>
   66 #include <sys/mount.h>
   67 #include <sys/syscallargs.h>
   69 #include <uvm/uvm_extern.h>
   71 extern struct shminfo shminfo;
   72 struct shmid_ds **shmsegs;      /* linear mapping of shmid -> shmseg */
   73 struct pool shm_pool;
   74 unsigned short *shmseqs;        /* array of shm sequence numbers */
   76 struct shmid_ds *shm_find_segment_by_shmid(int);
   78 /*
   79  * Provides the following externally accessible functions:
   80  *
   81  * shminit(void);                                initialization
   82  * shmexit(struct vmspace *)                     cleanup
   83  * shmfork(struct vmspace *, struct vmspace *)   fork handling
   84  * shmsys(arg1, arg2, arg3, arg4);         shm{at,ctl,dt,get}(arg2, arg3, arg4)
   85  *
   86  * Structures:
   87  * shmsegs (an array of 'struct shmid_ds *')
   88  * per proc 'struct shmmap_head' with an array of 'struct shmmap_state'
   89  */
   91 #define SHMSEG_REMOVED          0x0200          /* can't overlap ACCESSPERMS */
   92 #define SHMSEG_RMLINGER         0x0400
   94 int shm_last_free, shm_nused, shm_committed;
   96 struct shm_handle {
   97         struct uvm_object *shm_object;
   98 };
  100 struct shmmap_state {
vaddr_t va;
  102         int shmid;
  103 };
  105 struct shmmap_head {
  106         int shmseg;
  107         struct shmmap_state state[1];
  108 };
  110 int shm_find_segment_by_key(key_t);
  111 void shm_deallocate_segment(struct shmid_ds *);
  112 int shm_delete_mapping(struct vmspace *, struct shmmap_state *);
  113 int shmget_existing(struct proc *, struct sys_shmget_args *,
  114                          int, int, register_t *);
  115 int shmget_allocate_segment(struct proc *, struct sys_shmget_args *,
  116                                  int, register_t *);
  118 int
shm_find_segment_by_key(key_t key)
  120 {
  121         struct shmid_ds *shmseg;
  122         int i;
  124         for (i = 0; i < shminfo.shmmni; i++) {
shmseg = shmsegs[i];
  126                 if (shmseg != NULL && shmseg->shm_perm.key == key)
  127                         return (i);
  128         }
  129         return (-1);
  130 }
  132 struct shmid_ds *
shm_find_segment_by_shmid(int shmid)
  134 {
  135         int segnum;
  136         struct shmid_ds *shmseg;
segnum = IPCID_TO_IX(shmid);
  139         if (segnum < 0 || segnum >= shminfo.shmmni ||
  140             (shmseg = shmsegs[segnum]) == NULL ||
shmseg->shm_perm.seq != IPCID_TO_SEQ(shmid))
  142                 return (NULL);
  143         if ((shmseg->shm_perm.mode & (SHMSEG_REMOVED|SHMSEG_RMLINGER)) == SHMSEG_REMOVED)
  144                 return (NULL);
  145         return (shmseg);
  146 }
  148 void
shm_deallocate_segment(struct shmid_ds *shmseg)
  150 {
  151         struct shm_handle *shm_handle;
size_t size;
shm_handle = shmseg->shm_internal;
size = round_page(shmseg->shm_segsz);
uao_detach(shm_handle->shm_object);
pool_put(&shm_pool, shmseg);
shm_committed -= btoc(size);
shm_nused--;
  160 }
  162 int
shm_delete_mapping(struct vmspace *vm, struct shmmap_state *shmmap_s)
  164 {
  165         struct shmid_ds *shmseg;
  166         int segnum;
size_t size;
segnum = IPCID_TO_IX(shmmap_s->shmid);
  170         if (segnum < 0 || segnum >= shminfo.shmmni ||
  171             (shmseg = shmsegs[segnum]) == NULL)
  172                 return (EINVAL);
size = round_page(shmseg->shm_segsz);
uvm_deallocate(&vm->vm_map, shmmap_s->va, size);
shmmap_s->shmid = -1;
shmseg->shm_dtime = time_second;
  177         if ((--shmseg->shm_nattch <= 0) &&
  178             (shmseg->shm_perm.mode & SHMSEG_REMOVED)) {
shm_deallocate_segment(shmseg);
shm_last_free = segnum;
shmsegs[shm_last_free] = NULL;
  182         }
  183         return (0);
  184 }
  186 int
sys_shmdt(struct proc *p, void *v, register_t *retval)
  188 {
  189         struct sys_shmdt_args /* {
  190                 syscallarg(const void *) shmaddr;
  191         } */ *uap = v;
  192         struct shmmap_head *shmmap_h;
  193         struct shmmap_state *shmmap_s;
  194         int i;
shmmap_h = (struct shmmap_head *)p->p_vmspace->vm_shm;
  197         if (shmmap_h == NULL)
  198                 return (EINVAL);
  200         for (i = 0, shmmap_s = shmmap_h->state; i < shmmap_h->shmseg;
i++, shmmap_s++)
  202                 if (shmmap_s->shmid != -1 &&
shmmap_s->va == (vaddr_t)SCARG(uap, shmaddr))
  204                         break;
  205         if (i == shmmap_h->shmseg)
  206                 return (EINVAL);
  207         return (shm_delete_mapping(p->p_vmspace, shmmap_s));
  208 }
  210 int
sys_shmat(struct proc *p, void *v, register_t *retval)
  212 {
  213         struct sys_shmat_args /* {
  214                 syscallarg(int) shmid;
  215                 syscallarg(const void *) shmaddr;
  216                 syscallarg(int) shmflg;
  217         } */ *uap = v;
  218         int error, i, flags;
  219         struct ucred *cred = p->p_ucred;
  220         struct shmid_ds *shmseg;
  221         struct shmmap_head *shmmap_h;
  222         struct shmmap_state *shmmap_s;
  223         struct shm_handle *shm_handle;
vaddr_t attach_va;
vm_prot_t prot;
vsize_t size;
shmmap_h = (struct shmmap_head *)p->p_vmspace->vm_shm;
  229         if (shmmap_h == NULL) {
size = sizeof(int) +
shminfo.shmseg * sizeof(struct shmmap_state);
shmmap_h = malloc(size, M_SHM, M_WAITOK);
shmmap_h->shmseg = shminfo.shmseg;
  234                 for (i = 0, shmmap_s = shmmap_h->state; i < shmmap_h->shmseg;
i++, shmmap_s++)
shmmap_s->shmid = -1;
p->p_vmspace->vm_shm = (caddr_t)shmmap_h;
  238         }
shmseg = shm_find_segment_by_shmid(SCARG(uap, shmid));
  240         if (shmseg == NULL)
  241                 return (EINVAL);
error = ipcperm(cred, &shmseg->shm_perm,
  243                     (SCARG(uap, shmflg) & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W);
  244         if (error)
  245                 return (error);
  246         for (i = 0, shmmap_s = shmmap_h->state; i < shmmap_h->shmseg; i++) {
  247                 if (shmmap_s->shmid == -1)
  248                         break;
shmmap_s++;
  250         }
  251         if (i >= shmmap_h->shmseg)
  252                 return (EMFILE);
size = round_page(shmseg->shm_segsz);
prot = VM_PROT_READ;
  255         if ((SCARG(uap, shmflg) & SHM_RDONLY) == 0)
prot |= VM_PROT_WRITE;
flags = MAP_ANON | MAP_SHARED;
  258         if (SCARG(uap, shmaddr)) {
flags |= MAP_FIXED;
  260                 if (SCARG(uap, shmflg) & SHM_RND) 
attach_va =
  262                             (vaddr_t)SCARG(uap, shmaddr) & ~(SHMLBA-1);
  263                 else if (((vaddr_t)SCARG(uap, shmaddr) & (SHMLBA-1)) == 0)
attach_va = (vaddr_t)SCARG(uap, shmaddr);
  265                 else
  266                         return (EINVAL);
  267         } else {
  268                 /* This is just a hint to uvm_map() about where to put it. */
attach_va = uvm_map_hint(p, prot);
  270         }
shm_handle = shmseg->shm_internal;
uao_reference(shm_handle->shm_object);
error = uvm_map(&p->p_vmspace->vm_map, &attach_va, size,
shm_handle->shm_object, 0, 0, UVM_MAPFLAG(prot, prot,
UVM_INH_SHARE, UVM_ADV_RANDOM, 0));
  276         if (error) {
uao_detach(shm_handle->shm_object);
  278                 return (error);
  279         }
shmmap_s->va = attach_va;
shmmap_s->shmid = SCARG(uap, shmid);
shmseg->shm_lpid = p->p_pid;
shmseg->shm_atime = time_second;
shmseg->shm_nattch++;
  286         *retval = attach_va;
  287         return (0);
  288 }
  290 int
sys_shmctl(struct proc *p, void *v, register_t *retval)
  292 {
  293         struct sys_shmctl_args /* {
  294                 syscallarg(int) shmid;
  295                 syscallarg(int) cmd;
  296                 syscallarg(struct shmid_ds *) buf;
  297         } */ *uap = v;
  299         return (shmctl1(p, SCARG(uap, shmid), SCARG(uap, cmd),
  300             (caddr_t)SCARG(uap, buf), copyin, copyout));
  301 }
  303 int
shmctl1(struct proc *p, int shmid, int cmd, caddr_t buf,
  305     int (*ds_copyin)(const void *, void *, size_t),
  306     int (*ds_copyout)(const void *, void *, size_t))
  307 {
  308         struct ucred *cred = p->p_ucred;
  309         struct shmid_ds inbuf, *shmseg;
  310         int error;
shmseg = shm_find_segment_by_shmid(shmid);
  313         if (shmseg == NULL)
  314                 return (EINVAL);
  315         switch (cmd) {
  316         case IPC_STAT:
  317                 if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_R)) != 0)
  318                         return (error);
error = ds_copyout(shmseg, buf, sizeof(inbuf));
  320                 if (error)
  321                         return (error);
  322                 break;
  323         case IPC_SET:
  324                 if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_M)) != 0)
  325                         return (error);
error = ds_copyin(buf, &inbuf, sizeof(inbuf));
  327                 if (error)
  328                         return (error);
shmseg->shm_perm.uid = inbuf.shm_perm.uid;
shmseg->shm_perm.gid = inbuf.shm_perm.gid;
shmseg->shm_perm.mode =
  332                     (shmseg->shm_perm.mode & ~ACCESSPERMS) |
  333                     (inbuf.shm_perm.mode & ACCESSPERMS);
shmseg->shm_ctime = time_second;
  335                 break;
  336         case IPC_RMID:
  337                 if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_M)) != 0)
  338                         return (error);
shmseg->shm_perm.key = IPC_PRIVATE;
shmseg->shm_perm.mode |= SHMSEG_REMOVED;
  341                 if (shmseg->shm_nattch <= 0) {
shm_deallocate_segment(shmseg);
shm_last_free = IPCID_TO_IX(shmid);
shmsegs[shm_last_free] = NULL;
  345                 }
  346                 break;
  347         case SHM_LOCK:
  348         case SHM_UNLOCK:
  349         default:
  350                 return (EINVAL);
  351         }
  352         return (0);
  353 }
  355 int
shmget_existing(struct proc *p,
  357         struct sys_shmget_args /* {
  358                 syscallarg(key_t) key;
  359                 syscallarg(size_t) size;
  360                 syscallarg(int) shmflg;
  361         } */ *uap,
  362         int mode, int segnum, register_t *retval)
  363 {
  364         struct shmid_ds *shmseg;
  365         struct ucred *cred = p->p_ucred;
  366         int error;
shmseg = shmsegs[segnum];       /* We assume the segnum is valid */
  369         if ((error = ipcperm(cred, &shmseg->shm_perm, mode)) != 0)
  370                 return (error);
  371         if (SCARG(uap, size) && SCARG(uap, size) > shmseg->shm_segsz)
  372                 return (EINVAL);
  373         if ((SCARG(uap, shmflg) & (IPC_CREAT | IPC_EXCL)) ==
  374             (IPC_CREAT | IPC_EXCL))
  375                 return (EEXIST);
  376         *retval = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm);
  377         return (0);
  378 }
  380 int
shmget_allocate_segment(struct proc *p,
  382         struct sys_shmget_args /* {
  383                 syscallarg(key_t) key;
  384                 syscallarg(size_t) size;
  385                 syscallarg(int) shmflg;
  386         } */ *uap,
  387         int mode, register_t *retval)
  388 {
size_t size;
key_t key;
  391         int segnum;
  392         struct ucred *cred = p->p_ucred;
  393         struct shmid_ds *shmseg;
  394         struct shm_handle *shm_handle;
  395         int error = 0;
  397         if (SCARG(uap, size) < shminfo.shmmin ||
SCARG(uap, size) > shminfo.shmmax)
  399                 return (EINVAL);
  400         if (shm_nused >= shminfo.shmmni) /* any shmids left? */
  401                 return (ENOSPC);
size = round_page(SCARG(uap, size));
  403         if (shm_committed + btoc(size) > shminfo.shmall)
  404                 return (ENOMEM);
shm_nused++;
shm_committed += btoc(size);
  408         /*
  409          * If a key has been specified and we had to wait for memory
  410          * to be freed up we need to verify that no one has allocated
  411          * the key we want in the meantime.  Yes, this is ugly.
  412          */
key = SCARG(uap, key);
shmseg = pool_get(&shm_pool, key == IPC_PRIVATE ? PR_WAITOK : 0);
  415         if (shmseg == NULL) {
shmseg = pool_get(&shm_pool, PR_WAITOK);
  417                 if (shm_find_segment_by_key(key) != -1) {
pool_put(&shm_pool, shmseg);
shm_nused--;
shm_committed -= btoc(size);
  421                         return (EAGAIN);
  422                 }
  423         }
  425         /* XXX - hash shmids instead */
  426         if (shm_last_free < 0) {
  427                 for (segnum = 0; segnum < shminfo.shmmni && shmsegs[segnum];
segnum++)
  429                         ;
  430                 if (segnum == shminfo.shmmni)
panic("shmseg free count inconsistent");
  432         } else {
segnum = shm_last_free;
  434                 if (++shm_last_free >= shminfo.shmmni || shmsegs[shm_last_free])
shm_last_free = -1;
  436         }
shmsegs[segnum] = shmseg;
shm_handle = (struct shm_handle *)((caddr_t)shmseg + sizeof(*shmseg));
shm_handle->shm_object = uao_create(size, 0);
shmseg->shm_perm.cuid = shmseg->shm_perm.uid = cred->cr_uid;
shmseg->shm_perm.cgid = shmseg->shm_perm.gid = cred->cr_gid;
shmseg->shm_perm.mode = (mode & (ACCESSPERMS|SHMSEG_RMLINGER));
shmseg->shm_perm.seq = shmseqs[segnum] = (shmseqs[segnum] + 1) & 0x7fff;
shmseg->shm_perm.key = key;
shmseg->shm_segsz = SCARG(uap, size);
shmseg->shm_cpid = p->p_pid;
shmseg->shm_lpid = shmseg->shm_nattch = 0;
shmseg->shm_atime = shmseg->shm_dtime = 0;
shmseg->shm_ctime = time_second;
shmseg->shm_internal = shm_handle;
  454         *retval = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm);
  455         return (error);
  456 }
  458 int
sys_shmget(struct proc *p, void *v, register_t *retval)
  460 {
  461         struct sys_shmget_args /* {
  462                 syscallarg(key_t) key;
  463                 syscallarg(size_t) size;
  464                 syscallarg(int) shmflg;
  465         } */ *uap = v;
  466         int segnum, mode, error;
mode = SCARG(uap, shmflg) & ACCESSPERMS;
  469         if (SCARG(uap, shmflg) & _SHM_RMLINGER)
mode |= SHMSEG_RMLINGER;
  472         if (SCARG(uap, key) != IPC_PRIVATE) {
again:
segnum = shm_find_segment_by_key(SCARG(uap, key));
  475                 if (segnum >= 0)
  476                         return (shmget_existing(p, uap, mode, segnum, retval));
  477                 if ((SCARG(uap, shmflg) & IPC_CREAT) == 0) 
  478                         return (ENOENT);
  479         }
error = shmget_allocate_segment(p, uap, mode, retval);
  481         if (error == EAGAIN)
  482                 goto again;
  483         return (error);
  484 }
  486 void
shmfork(struct vmspace *vm1, struct vmspace *vm2)
  488 {
  489         struct shmmap_head *shmmap_h;
  490         struct shmmap_state *shmmap_s;
  491         struct shmid_ds *shmseg;
size_t size;
  493         int i;
  495         if (vm1->vm_shm == NULL) {
vm2->vm_shm = NULL;
  497                 return;
  498         }
shmmap_h = (struct shmmap_head *)vm1->vm_shm;
size = sizeof(int) + shmmap_h->shmseg * sizeof(struct shmmap_state);
vm2->vm_shm = malloc(size, M_SHM, M_WAITOK);
bcopy(vm1->vm_shm, vm2->vm_shm, size);
  504         for (i = 0, shmmap_s = shmmap_h->state; i < shmmap_h->shmseg;
i++, shmmap_s++) {
  506                 if (shmmap_s->shmid != -1 &&
  507                     (shmseg = shmsegs[IPCID_TO_IX(shmmap_s->shmid)]) != NULL)
shmseg->shm_nattch++;
  509         }
  510 }
  512 void
shmexit(struct vmspace *vm)
  514 {
  515         struct shmmap_head *shmmap_h;
  516         struct shmmap_state *shmmap_s;
  517         int i;
shmmap_h = (struct shmmap_head *)vm->vm_shm;
  520         if (shmmap_h == NULL)
  521                 return;
  522         for (i = 0, shmmap_s = shmmap_h->state; i < shmmap_h->shmseg;
i++, shmmap_s++)
  524                 if (shmmap_s->shmid != -1)
shm_delete_mapping(vm, shmmap_s);
free(vm->vm_shm, M_SHM);
vm->vm_shm = NULL;
  528 }
  530 void
shminit(void)
  532 {
pool_init(&shm_pool, sizeof(struct shmid_ds) +
  535             sizeof(struct shm_handle), 0, 0, 0, "shmpl",
  536             &pool_allocator_nointr);
shmsegs = malloc(shminfo.shmmni * sizeof(struct shmid_ds *),
M_SHM, M_WAITOK);
bzero(shmsegs, shminfo.shmmni * sizeof(struct shmid_ds *));
shmseqs = malloc(shminfo.shmmni * sizeof(unsigned short),
M_SHM, M_WAITOK);
bzero(shmseqs, shminfo.shmmni * sizeof(unsigned short));
shminfo.shmmax *= PAGE_SIZE;    /* actually in pages */
shm_last_free = 0;
shm_nused = 0;
shm_committed = 0;
  548 }
  550 /*
  551  * Userland access to struct shminfo.
  552  */
  553 int
sysctl_sysvshm(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  555         void *newp, size_t newlen)
  556 {
  557         int error, val;
  558         struct shmid_ds **newsegs;
  559         unsigned short *newseqs;
  561         if (namelen != 2) {
  562                 switch (name[0]) {
  563                 case KERN_SHMINFO_SHMMAX:
  564                 case KERN_SHMINFO_SHMMIN:
  565                 case KERN_SHMINFO_SHMMNI:
  566                 case KERN_SHMINFO_SHMSEG:
  567                 case KERN_SHMINFO_SHMALL:
  568                         break;
  569                 default:
  570                         return (ENOTDIR);       /* overloaded */
  571                 }
  572         }
  574         switch (name[0]) {
  575         case KERN_SHMINFO_SHMMAX:
  576                 if ((error = sysctl_int(oldp, oldlenp, newp, newlen,
  577                     &shminfo.shmmax)) || newp == NULL)
  578                         return (error);
  580                 /* If new shmmax > shmall, crank shmall */
  581                 if (btoc(round_page(shminfo.shmmax)) > shminfo.shmall)
shminfo.shmall = btoc(round_page(shminfo.shmmax));
  583                 return (0);
  584         case KERN_SHMINFO_SHMMIN:
val = shminfo.shmmin;
  586                 if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
val == shminfo.shmmin)
  588                         return (error);
  589                 if (val <= 0)
  590                         return (EINVAL);        /* shmmin must be >= 1 */
shminfo.shmmin = val;
  592                 return (0);
  593         case KERN_SHMINFO_SHMMNI:
val = shminfo.shmmni;
  595                 if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
val == shminfo.shmmni)
  597                         return (error);
  599                 if (val < shminfo.shmmni || val > 0xffff)
  600                         return (EINVAL);
  602                 /* Expand shmsegs and shmseqs arrays */
newsegs = malloc(val * sizeof(struct shmid_ds *),
M_SHM, M_WAITOK);
bcopy(shmsegs, newsegs,
shminfo.shmmni * sizeof(struct shmid_ds *));
bzero(newsegs + shminfo.shmmni,
  608                     (val - shminfo.shmmni) * sizeof(struct shmid_ds *));
free(shmsegs, M_SHM);
shmsegs = newsegs;
newseqs = malloc(val * sizeof(unsigned short), M_SHM, M_WAITOK);
bcopy(shmseqs, newseqs,
shminfo.shmmni * sizeof(unsigned short));
bzero(newseqs + shminfo.shmmni,
  615                     (val - shminfo.shmmni) * sizeof(unsigned short));
free(shmseqs, M_SHM);
shmseqs = newseqs;
shminfo.shmmni = val;
  619                 return (0);
  620         case KERN_SHMINFO_SHMSEG:
val = shminfo.shmseg;
  622                 if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
val == shminfo.shmseg)
  624                         return (error);
  625                 if (val <= 0)
  626                         return (EINVAL);        /* shmseg must be >= 1 */
shminfo.shmseg = val;
  628                 return (0);
  629         case KERN_SHMINFO_SHMALL:
val = shminfo.shmall;
  631                 if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
val == shminfo.shmall)
  633                         return (error);
  634                 if (val < shminfo.shmall)
  635                         return (EINVAL);        /* can't decrease shmall */
shminfo.shmall = val;
  637                 return (0);
  638         default:
  639                 return (EOPNOTSUPP);
  640         }
  641         /* NOTREACHED */
  642 }