new pathname for hpux

[unix-history] / usr / src / sys / kern / sysv_shm.c

diff --git a/usr/src/sys/kern/sysv_shm.c b/usr/src/sys/kern/sysv_shm.c
index bf6b92f..d33fcec 100644 (file)
--- a/usr/src/sys/kern/sysv_shm.c
+++ b/usr/src/sys/kern/sysv_shm.c
@@ -11,42 +11,65 @@
  *
  * from: Utah $Hdr: uipc_shm.c 1.9 89/08/14$
  *
  *
  * from: Utah $Hdr: uipc_shm.c 1.9 89/08/14$
  *

- *     @(#)sysv_shm.c  7.4 (Berkeley) %G%
+ *     @(#)sysv_shm.c  7.11 (Berkeley) %G%

  */
 
 /*
  * System V shared memory routines.
  */
 
 /*
  * System V shared memory routines.

+ * TEMPORARY, until mmap is in place;
+ * needed now for HP-UX compatibility and X server (yech!).

  */
 
 #ifdef SYSVSHM
 
  */
 
 #ifdef SYSVSHM
 

-#include "machine/pte.h"
-

 #include "param.h"
 #include "systm.h"
 #include "user.h"
 #include "kernel.h"
 #include "proc.h"
 #include "param.h"
 #include "systm.h"
 #include "user.h"
 #include "kernel.h"
 #include "proc.h"

-#include "vm.h"

 #include "shm.h"
 #include "shm.h"

-#include "mapmem.h"

 #include "malloc.h"
 #include "malloc.h"

+#include "mman.h"
+#include "../vm/vm_param.h"
+#include "../vm/vm_map.h"
+#include "../vm/vm_kern.h"
+#include "../vm/vm_inherit.h"
+#include "../vm/vm_pager.h"

 
 #ifdef HPUXCOMPAT
 
 #ifdef HPUXCOMPAT

-#include "../hpux/hpux.h"
+#include "hp300/hpux/hpux.h"

 #endif
 
 int    shmat(), shmctl(), shmdt(), shmget();
 int    (*shmcalls[])() = { shmat, shmctl, shmdt, shmget };
 int    shmtot = 0;
 
 #endif
 
 int    shmat(), shmctl(), shmdt(), shmget();
 int    (*shmcalls[])() = { shmat, shmctl, shmdt, shmget };
 int    shmtot = 0;
 

-int    shmfork(), shmexit();
-struct mapmemops shmops = { shmfork, (int (*)())0, shmexit, shmexit };
+/*
+ * Per process internal structure for managing segments.
+ * Each process using shm will have an array of ``shmseg'' of these.
+ */
+struct shmdesc {
+       vm_offset_t     shmd_uva;
+       int             shmd_id;
+};
+
+/*
+ * Per segment internal structure (shm_handle).
+ */
+struct shmhandle {
+       vm_offset_t     shmh_kva;
+       caddr_t         shmh_id;
+};
+
+vm_map_t shm_map;      /* address space for shared memory segments */

 
 shminit()
 {
        register int i;
 
 shminit()
 {
        register int i;

+       vm_offset_t whocares1, whocares2;

 
 

+       shm_map = kmem_suballoc(kernel_map, &whocares1, &whocares2,
+                               shminfo.shmall * NBPG, FALSE);

        if (shminfo.shmmni > SHMMMNI)
                shminfo.shmmni = SHMMMNI;
        for (i = 0; i < shminfo.shmmni; i++) {
        if (shminfo.shmmni > SHMMMNI)
                shminfo.shmmni = SHMMMNI;
        for (i = 0; i < shminfo.shmmni; i++) {


@@ -55,34 +78,39 @@ shminit()
        }
 }
 
        }
 }
 

-/* entry point for all SHM calls */
-shmsys()
+/*
+ * Entry point for all SHM calls
+ */
+shmsys(p, uap, retval)
+       struct proc *p;
+       struct args {
+               u_int which;
+       } *uap;
+       int *retval;

 {
 {

-       struct a {
-               int which;
-       } *uap = (struct a *)u.u_ap;

 
 

-       if (uap->which >= sizeof(shmcalls)/sizeof(shmcalls[0])) {
-               u.u_error = EINVAL;
-               return;
-       }
-       (*shmcalls[uap->which])(u.u_ap+1);
+       if (uap->which >= sizeof(shmcalls)/sizeof(shmcalls[0]))
+               return (EINVAL);
+       return ((*shmcalls[uap->which])(p, &uap[1], retval));

 }
 
 }
 

-/* get a shared memory segment */
-shmget(ap)
-       int *ap;
-{
-       register struct a {
+/*
+ * Get a shared memory segment
+ */
+shmget(p, uap, retval)
+       struct proc *p;
+       register struct args {

                key_t key;
                int size;
                int shmflg;
                key_t key;
                int size;
                int shmflg;

-       } *uap = (struct a *)ap;
-       struct proc *p = u.u_procp;
+       } *uap;
+       int *retval;
+{

        register struct shmid_ds *shp;
        register struct shmid_ds *shp;

+       register struct ucred *cred = u.u_cred;

        register int i;
        register int i;

-       int rval = 0, size;
-       caddr_t kva;
+       int error, size, rval = 0;
+       register struct shmhandle *shmh;

 
        /* look up the specified shm_id */
        if (uap->key != IPC_PRIVATE) {
 
        /* look up the specified shm_id */
        if (uap->key != IPC_PRIVATE) {


@@ -97,28 +125,20 @@ shmget(ap)
 
        /* create a new shared segment if necessary */
        if (i == shminfo.shmmni) {
 
        /* create a new shared segment if necessary */
        if (i == shminfo.shmmni) {

-               if ((uap->shmflg & IPC_CREAT) == 0) {
-                       u.u_error = ENOENT;
-                       return;
-               }
-               if (uap->size < shminfo.shmmin || uap->size > shminfo.shmmax) {
-                       u.u_error = EINVAL;
-                       return;
-               }
+               if ((uap->shmflg & IPC_CREAT) == 0)
+                       return (ENOENT);
+               if (uap->size < shminfo.shmmin || uap->size > shminfo.shmmax)
+                       return (EINVAL);

                for (i = 0; i < shminfo.shmmni; i++)
                        if ((shmsegs[i].shm_perm.mode & SHM_ALLOC) == 0) {
                                rval = i;
                                break;
                        }
                for (i = 0; i < shminfo.shmmni; i++)
                        if ((shmsegs[i].shm_perm.mode & SHM_ALLOC) == 0) {
                                rval = i;
                                break;
                        }

-               if (i == shminfo.shmmni) {
-                       u.u_error = ENOSPC;
-                       return;
-               }
+               if (i == shminfo.shmmni)
+                       return (ENOSPC);

                size = clrnd(btoc(uap->size));
                size = clrnd(btoc(uap->size));

-               if (shmtot + size > shminfo.shmall) {
-                       u.u_error = ENOMEM;
-                       return;
-               }
+               if (shmtot + size > shminfo.shmall)
+                       return (ENOMEM);

                shp = &shmsegs[rval];
                /*
                 * We need to do a couple of things to ensure consistency
                shp = &shmsegs[rval];
                /*
                 * We need to do a couple of things to ensure consistency


@@ -130,20 +150,22 @@ shmget(ap)
                 */
                shp->shm_perm.mode = SHM_ALLOC | SHM_DEST;
                shp->shm_perm.key = uap->key;
                 */
                shp->shm_perm.mode = SHM_ALLOC | SHM_DEST;
                shp->shm_perm.key = uap->key;

-               kva = (caddr_t) malloc((u_long)ctob(size), M_SHM, M_WAITOK);
-               if (kva == NULL) {
+               shmh = (struct shmhandle *)
+                       malloc(sizeof(struct shmhandle), M_SHM, M_WAITOK);
+               shmh->shmh_kva = 0;
+               shmh->shmh_id = (caddr_t)(0xc0000000|rval);     /* XXX */
+               error = vm_mmap(shm_map, &shmh->shmh_kva, ctob(size),
+                               VM_PROT_ALL, MAP_ANON, shmh->shmh_id, 0);
+               if (error) {
+                       free((caddr_t)shmh, M_SHM);

                        shp->shm_perm.mode = 0;
                        shp->shm_perm.mode = 0;

-                       u.u_error = ENOMEM;
-                       return;
+                       return(ENOMEM);

                }
                }

-               if (!claligned(kva))
-                       panic("shmget: non-aligned memory");
-               bzero(kva, (u_int)ctob(size));
+               shp->shm_handle = (void *) shmh;

                shmtot += size;
                shmtot += size;

-               shp->shm_perm.cuid = shp->shm_perm.uid = u.u_uid;
-               shp->shm_perm.cgid = shp->shm_perm.gid = u.u_gid;
+               shp->shm_perm.cuid = shp->shm_perm.uid = cred->cr_uid;
+               shp->shm_perm.cgid = shp->shm_perm.gid = cred->cr_gid;

                shp->shm_perm.mode = SHM_ALLOC | (uap->shmflg&0777);
                shp->shm_perm.mode = SHM_ALLOC | (uap->shmflg&0777);

-               shp->shm_handle = (void *) kvtopte(kva);

                shp->shm_segsz = uap->size;
                shp->shm_cpid = p->p_pid;
                shp->shm_lpid = shp->shm_nattch = 0;
                shp->shm_segsz = uap->size;
                shp->shm_cpid = p->p_pid;
                shp->shm_lpid = shp->shm_nattch = 0;


@@ -152,69 +174,63 @@ shmget(ap)
        } else {
                shp = &shmsegs[rval];
                /* XXX: probably not the right thing to do */
        } else {
                shp = &shmsegs[rval];
                /* XXX: probably not the right thing to do */

-               if (shp->shm_perm.mode & SHM_DEST) {
-                       u.u_error = EBUSY;
-                       return;
-               }
-               if (!ipcaccess(&shp->shm_perm, uap->shmflg&0777))
-                       return;
-               if (uap->size && uap->size > shp->shm_segsz) {
-                       u.u_error = EINVAL;
-                       return;
-               }
-               if ((uap->shmflg&IPC_CREAT) && (uap->shmflg&IPC_EXCL)) {
-                       u.u_error = EEXIST;
-                       return;
-               }
+               if (shp->shm_perm.mode & SHM_DEST)
+                       return (EBUSY);
+               if (error = ipcaccess(&shp->shm_perm, uap->shmflg&0777, cred))
+                       return (error);
+               if (uap->size && uap->size > shp->shm_segsz)
+                       return (EINVAL);
+               if ((uap->shmflg&IPC_CREAT) && (uap->shmflg&IPC_EXCL))
+                       return (EEXIST);

        }
        }

-       u.u_r.r_val1 = shp->shm_perm.seq * SHMMMNI + rval;
+       *retval = shp->shm_perm.seq * SHMMMNI + rval;
+       return (0);

 }
 
 }
 

-/* shared memory control */
-shmctl(ap)
-       int *ap;
-{
-       register struct a {
+/*
+ * Shared memory control
+ */
+/* ARGSUSED */
+shmctl(p, uap, retval)
+       struct proc *p;
+       register struct args {

                int shmid;
                int cmd;
                caddr_t buf;
                int shmid;
                int cmd;
                caddr_t buf;

-       } *uap = (struct a *)ap;
-       struct proc *p = u.u_procp;
+       } *uap;
+       int *retval;
+{

        register struct shmid_ds *shp;
        register struct shmid_ds *shp;

+       register struct ucred *cred = u.u_cred;

        struct shmid_ds sbuf;
        struct shmid_ds sbuf;

+       int error;

 
 

-       if (!shmvalid(uap->shmid))
-               return;
+       if (error = shmvalid(uap->shmid))
+               return (error);

        shp = &shmsegs[uap->shmid % SHMMMNI];
        switch (uap->cmd) {
        case IPC_STAT:
        shp = &shmsegs[uap->shmid % SHMMMNI];
        switch (uap->cmd) {
        case IPC_STAT:

-               if (ipcaccess(&shp->shm_perm, IPC_R))
-                       u.u_error =
-                               copyout((caddr_t)shp, uap->buf, sizeof(*shp));
-               break;
+               if (error = ipcaccess(&shp->shm_perm, IPC_R, cred))
+                       return (error);
+               return (copyout((caddr_t)shp, uap->buf, sizeof(*shp)));

 
        case IPC_SET:
 
        case IPC_SET:

-               if (u.u_uid && u.u_uid != shp->shm_perm.uid &&
-                   u.u_uid != shp->shm_perm.cuid) {
-                       u.u_error = EPERM;
-                       break;
-               }
-               u.u_error = copyin(uap->buf, (caddr_t)&sbuf, sizeof sbuf);
-               if (!u.u_error) {
-                       shp->shm_perm.uid = sbuf.shm_perm.uid;
-                       shp->shm_perm.gid = sbuf.shm_perm.gid;
-                       shp->shm_perm.mode = (shp->shm_perm.mode & ~0777)
-                               | (sbuf.shm_perm.mode & 0777);
-                       shp->shm_ctime = time.tv_sec;
-               }
+               if (cred->cr_uid && cred->cr_uid != shp->shm_perm.uid &&
+                   cred->cr_uid != shp->shm_perm.cuid)
+                       return (EPERM);
+               if (error = copyin(uap->buf, (caddr_t)&sbuf, sizeof sbuf))
+                       return (error);
+               shp->shm_perm.uid = sbuf.shm_perm.uid;
+               shp->shm_perm.gid = sbuf.shm_perm.gid;
+               shp->shm_perm.mode = (shp->shm_perm.mode & ~0777)
+                       | (sbuf.shm_perm.mode & 0777);
+               shp->shm_ctime = time.tv_sec;

                break;
 
        case IPC_RMID:
                break;
 
        case IPC_RMID:

-               if (u.u_uid && u.u_uid != shp->shm_perm.uid &&
-                   u.u_uid != shp->shm_perm.cuid) {
-                       u.u_error = EPERM;
-                       break;
-               }
+               if (cred->cr_uid && cred->cr_uid != shp->shm_perm.uid &&
+                   cred->cr_uid != shp->shm_perm.cuid)
+                       return (EPERM);

                /* set ctime? */
                shp->shm_perm.key = IPC_PRIVATE;
                shp->shm_perm.mode |= SHM_DEST;
                /* set ctime? */
                shp->shm_perm.key = IPC_PRIVATE;
                shp->shm_perm.mode |= SHM_DEST;


@@ -227,140 +243,159 @@ shmctl(ap)
        case SHM_UNLOCK:
                /* don't really do anything, but make them think we did */
                if ((p->p_flag & SHPUX) == 0)
        case SHM_UNLOCK:
                /* don't really do anything, but make them think we did */
                if ((p->p_flag & SHPUX) == 0)

-                       u.u_error = EINVAL;
-               else if (u.u_uid && u.u_uid != shp->shm_perm.uid &&
-                        u.u_uid != shp->shm_perm.cuid)
-                       u.u_error = EPERM;
+                       return (EINVAL);
+               if (cred->cr_uid && cred->cr_uid != shp->shm_perm.uid &&
+                   cred->cr_uid != shp->shm_perm.cuid)
+                       return (EPERM);

                break;
 #endif
 
        default:
                break;
 #endif
 
        default:

-               u.u_error = EINVAL;
-               break;
+               return (EINVAL);

        }
        }

+       return (0);

 }
 
 }
 

-shmat(ap)
-       int *ap;
-{
-       struct a {
+/*
+ * Attach to shared memory segment.
+ */
+shmat(p, uap, retval)
+       struct proc *p;
+       register struct args {

                int     shmid;
                caddr_t shmaddr;
                int     shmflg;
                int     shmid;
                caddr_t shmaddr;
                int     shmflg;

-       } *uap = (struct a *)ap;
-       struct proc *p = u.u_procp;
+       } *uap;
+       int *retval;
+{

        register struct shmid_ds *shp;
        register int size;
        register struct shmid_ds *shp;
        register int size;

-       struct mapmem *mp;

        caddr_t uva;
        caddr_t uva;

-       int error, prot, shmmapin();
+       int error;
+       int flags;
+       vm_prot_t prot;
+       struct shmdesc *shmd;

 
 

-       if (!shmvalid(uap->shmid))
-               return;
+       /*
+        * Allocate descriptors now (before validity check)
+        * in case malloc() blocks.
+        */
+       shmd = (struct shmdesc *)p->p_shm;
+       size = shminfo.shmseg * sizeof(struct shmdesc);
+       if (shmd == NULL) {
+               shmd = (struct shmdesc *)malloc(size, M_SHM, M_WAITOK);
+               bzero((caddr_t)shmd, size);
+               p->p_shm = (caddr_t)shmd;
+       }
+       if (error = shmvalid(uap->shmid))
+               return (error);

        shp = &shmsegs[uap->shmid % SHMMMNI];
        if (shp->shm_handle == NULL)
                panic("shmat NULL handle");
        shp = &shmsegs[uap->shmid % SHMMMNI];
        if (shp->shm_handle == NULL)
                panic("shmat NULL handle");

-       if (!ipcaccess(&shp->shm_perm,
-                     (uap->shmflg&SHM_RDONLY) ? IPC_R : IPC_R|IPC_W))
-               return;
+       if (error = ipcaccess(&shp->shm_perm,
+                       (uap->shmflg&SHM_RDONLY) ? IPC_R : IPC_R|IPC_W, u.u_cred))
+               return (error);

        uva = uap->shmaddr;
        if (uva && ((int)uva & (SHMLBA-1))) {
                if (uap->shmflg & SHM_RND)
                        uva = (caddr_t) ((int)uva & ~(SHMLBA-1));
        uva = uap->shmaddr;
        if (uva && ((int)uva & (SHMLBA-1))) {
                if (uap->shmflg & SHM_RND)
                        uva = (caddr_t) ((int)uva & ~(SHMLBA-1));

-               else {
-                       u.u_error = EINVAL;
-                       return;
-               }
+               else
+                       return (EINVAL);

        }
        /*
         * Make sure user doesn't use more than their fair share
         */
        }
        /*
         * Make sure user doesn't use more than their fair share
         */

-       size = 0;
-       for (mp = u.u_mmap; mp; mp = mp->mm_next)
-               if (mp->mm_ops == &shmops)
-                       size++;
-       if (size >= shminfo.shmseg) {
-               u.u_error = EMFILE;
-               return;
+       for (size = 0; size < shminfo.shmseg; size++) {
+               if (shmd->shmd_uva == 0)
+                       break;
+               shmd++;

        }
        }

-       /*
-        * Allocate a mapped memory region descriptor and
-        * attempt to expand the user page table to allow for region
-        */
-       prot = (uap->shmflg & SHM_RDONLY) ? MM_RO : MM_RW;
-#if defined(hp300)
-       prot |= MM_CI;
-#endif
+       if (size >= shminfo.shmseg)
+               return (EMFILE);

        size = ctob(clrnd(btoc(shp->shm_segsz)));
        size = ctob(clrnd(btoc(shp->shm_segsz)));

-       error = mmalloc(p, uap->shmid, &uva, (segsz_t)size, prot, &shmops, &mp);
-       if (error) {
-               u.u_error = error;
-               return;
-       }
-       if (u.u_error = mmmapin(p, mp, shmmapin)) {
-               if (error = mmfree(p, mp))
-                       u.u_error = error;
-               return;
-       }
+       prot = VM_PROT_READ;
+       if ((uap->shmflg & SHM_RDONLY) == 0)
+               prot |= VM_PROT_WRITE;
+       flags = MAP_ANON|MAP_SHARED;
+       if (uva)
+               flags |= MAP_FIXED;
+       else
+               uva = (caddr_t)0x1000000;       /* XXX */
+       error = vm_mmap(p->p_map, &uva, (vm_size_t)size, prot, flags,
+                       ((struct shmhandle *)shp->shm_handle)->shmh_id, 0);
+       if (error)
+               return(error);
+       shmd->shmd_uva = (vm_offset_t)uva;
+       shmd->shmd_id = uap->shmid;

        /*
         * Fill in the remaining fields
         */
        shp->shm_lpid = p->p_pid;
        shp->shm_atime = time.tv_sec;
        shp->shm_nattch++;
        /*
         * Fill in the remaining fields
         */
        shp->shm_lpid = p->p_pid;
        shp->shm_atime = time.tv_sec;
        shp->shm_nattch++;

-       u.u_r.r_val1 = (int) uva;
+       *retval = (int) uva;
+       return (0);

 }
 
 }
 

-shmdt(ap)
-       int *ap;
-{
-       register struct a {
+/*
+ * Detach from shared memory segment.
+ */
+/* ARGSUSED */
+shmdt(p, uap, retval)
+       struct proc *p;
+       struct args {

                caddr_t shmaddr;
                caddr_t shmaddr;

-       } *uap = (struct a *)ap;
-       struct proc *p = u.u_procp;
-       register struct mapmem *mp;
+       } *uap;
+       int *retval;
+{
+       register struct shmdesc *shmd;
+       register int i;

 
 

-       for (mp = u.u_mmap; mp; mp = mp->mm_next)
-               if (mp->mm_ops == &shmops && mp->mm_uva == uap->shmaddr)
+       shmd = (struct shmdesc *)p->p_shm;
+       for (i = 0; i < shminfo.shmseg; i++, shmd++)
+               if (shmd->shmd_uva &&
+                   shmd->shmd_uva == (vm_offset_t)uap->shmaddr)

                        break;
                        break;

-       if (mp == MMNIL) {
-               u.u_error = EINVAL;
-               return;
-       }
-       shmsegs[mp->mm_id % SHMMMNI].shm_lpid = p->p_pid;
-       u.u_error = shmufree(p, mp);
+       if (i == shminfo.shmseg)
+               return(EINVAL);
+       shmufree(p, shmd);
+       shmsegs[shmd->shmd_id % SHMMMNI].shm_lpid = p->p_pid;

 }
 
 }
 

-shmmapin(mp, off)
-       struct mapmem *mp;
+shmfork(rip, rpp, isvfork)
+       struct proc *rip, *rpp;
+       int isvfork;

 {
 {

-       register struct shmid_ds *shp;
-
-       shp = &shmsegs[mp->mm_id % SHMMMNI];
-       if (off >= ctob(clrnd(btoc(shp->shm_segsz))))
-               return(-1);
-       return(((struct pte *)shp->shm_handle)[btop(off)].pg_pfnum);
-}
+       register struct shmdesc *shmd;
+       register int size;

 
 

-/*
- * Increment attach count on fork
- */
-shmfork(mp, ischild)
-       register struct mapmem *mp;
-{
-       if (!ischild)
-               shmsegs[mp->mm_id % SHMMMNI].shm_nattch++;
+       /*
+        * Copy parents descriptive information
+        */
+       size = shminfo.shmseg * sizeof(struct shmdesc);
+       shmd = (struct shmdesc *)malloc(size, M_SHM, M_WAITOK);
+       bcopy((caddr_t)rip->p_shm, (caddr_t)shmd, size);
+       rpp->p_shm = (caddr_t)shmd;
+       /*
+        * Increment reference counts
+        */
+       for (size = 0; size < shminfo.shmseg; size++, shmd++)
+               if (shmd->shmd_uva)
+                       shmsegs[shmd->shmd_id % SHMMMNI].shm_nattch++;

 }
 
 }
 

-/*
- * Detach from shared memory segment on exit (or exec)
- */
-shmexit(mp)
-       register struct mapmem *mp;
+shmexit(p)
+       struct proc *p;

 {
 {

-       struct proc *p = u.u_procp;             /* XXX */
+       register struct shmdesc *shmd;
+       register int i;

 
 

-       u.u_error = shmufree(p, mp);
+       shmd = (struct shmdesc *)p->p_shm;
+       for (i = 0; i < shminfo.shmseg; i++, shmd++)
+               if (shmd->shmd_uva)
+                       shmufree(p, shmd);
+       free((caddr_t)p->p_shm, M_SHM);
+       p->p_shm = NULL;

 }
 
 shmvalid(id)
 }
 
 shmvalid(id)


@@ -369,32 +404,31 @@ shmvalid(id)
        register struct shmid_ds *shp;
 
        if (id < 0 || (id % SHMMMNI) >= shminfo.shmmni)
        register struct shmid_ds *shp;
 
        if (id < 0 || (id % SHMMMNI) >= shminfo.shmmni)

-               return(0);
+               return(EINVAL);

        shp = &shmsegs[id % SHMMMNI];
        if (shp->shm_perm.seq == (id / SHMMMNI) &&
            (shp->shm_perm.mode & (SHM_ALLOC|SHM_DEST)) == SHM_ALLOC)
        shp = &shmsegs[id % SHMMMNI];
        if (shp->shm_perm.seq == (id / SHMMMNI) &&
            (shp->shm_perm.mode & (SHM_ALLOC|SHM_DEST)) == SHM_ALLOC)

-               return(1);
-       u.u_error = EINVAL;
-       return(0);
+               return(0);
+       return(EINVAL);

 }
 
 /*
  * Free user resources associated with a shared memory segment
  */
 }
 
 /*
  * Free user resources associated with a shared memory segment
  */

-shmufree(p, mp)
+shmufree(p, shmd)

        struct proc *p;
        struct proc *p;

-       struct mapmem *mp;
+       struct shmdesc *shmd;

 {
        register struct shmid_ds *shp;
 {
        register struct shmid_ds *shp;

-       int error;

 
 

-       shp = &shmsegs[mp->mm_id % SHMMMNI];
-       mmmapout(p, mp);
-       error = mmfree(p, mp);
+       shp = &shmsegs[shmd->shmd_id % SHMMMNI];
+       (void) vm_deallocate(p->p_map, shmd->shmd_uva,
+                            ctob(clrnd(btoc(shp->shm_segsz))));
+       shmd->shmd_id = 0;
+       shmd->shmd_uva = 0;

        shp->shm_dtime = time.tv_sec;
        if (--shp->shm_nattch <= 0 && (shp->shm_perm.mode & SHM_DEST))
                shmfree(shp);
        shp->shm_dtime = time.tv_sec;
        if (--shp->shm_nattch <= 0 && (shp->shm_perm.mode & SHM_DEST))
                shmfree(shp);

-       return (error);

 }
 
 /*
 }
 
 /*


@@ -407,8 +441,14 @@ shmfree(shp)
 
        if (shp->shm_handle == NULL)
                panic("shmfree");
 
        if (shp->shm_handle == NULL)
                panic("shmfree");

-       kva = (caddr_t) ptetokv(shp->shm_handle);
-       free(kva, M_SHM);
+       /*
+        * Lose our lingering object reference by deallocating space
+        * in kernel.  Pager will also be deallocated as a side-effect.
+        */
+       vm_deallocate(shm_map,
+                     ((struct shmhandle *)shp->shm_handle)->shmh_kva,
+                     clrnd(btoc(shp->shm_segsz)));
+       free((caddr_t)shp->shm_handle, M_SHM);

        shp->shm_handle = NULL;
        shmtot -= clrnd(btoc(shp->shm_segsz));
        shp->shm_perm.mode = 0;
        shp->shm_handle = NULL;
        shmtot -= clrnd(btoc(shp->shm_segsz));
        shp->shm_perm.mode = 0;


@@ -427,12 +467,14 @@ shmfree(shp)
  * XXX This routine would be common to all sysV style IPC
  *     (if the others were implemented).
  */
  * XXX This routine would be common to all sysV style IPC
  *     (if the others were implemented).
  */

-ipcaccess(ipc, mode)
+ipcaccess(ipc, mode, cred)

        register struct ipc_perm *ipc;
        register struct ipc_perm *ipc;

+       int mode;
+       register struct ucred *cred;

 {
        register int m;
 
 {
        register int m;
 

-       if (u.u_uid == 0)
+       if (cred->cr_uid == 0)

                return(0);
        /*
         * Access check is based on only one of owner, group, public.
                return(0);
        /*
         * Access check is based on only one of owner, group, public.


@@ -441,16 +483,14 @@ ipcaccess(ipc, mode)
         */
        mode &= 0700;
        m = ipc->mode;
         */
        mode &= 0700;
        m = ipc->mode;

-       if (u.u_uid != ipc->uid && u.u_uid != ipc->cuid) {
+       if (cred->cr_uid != ipc->uid && cred->cr_uid != ipc->cuid) {

                m <<= 3;
                m <<= 3;

-               if (!groupmember(ipc->gid, u.u_cred) &&
-                   !groupmember(ipc->cgid, u.u_cred))
+               if (!groupmember(ipc->gid, cred) &&
+                   !groupmember(ipc->cgid, cred))

                        m <<= 3;
        }
        if ((mode&m) == mode)
                        m <<= 3;
        }
        if ((mode&m) == mode)

-               return (1);
-       u.u_error = EACCES;
-       return (0);
+               return (0);
+       return (EACCES);

 }
 }

-

 #endif /* SYSVSHM */
 #endif /* SYSVSHM */