int linux_shmat(struct thread *td, struct linux_shmat_args *args) { struct shmat_args /* { int shmid; void *shmaddr; int shmflg; } */ bsd_args; int error; #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) l_uintptr_t addr; #endif bsd_args.shmid = args->shmid; bsd_args.shmaddr = PTRIN(args->shmaddr); bsd_args.shmflg = args->shmflg; if ((error = sys_shmat(td, &bsd_args))) return (error); #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) addr = td->td_retval[0]; if ((error = copyout(&addr, PTRIN(args->raddr), sizeof(addr)))) return (error); td->td_retval[0] = 0; #endif return (0); }
asmlinkage int sunos_shmsys(int op, unsigned long arg1, unsigned long arg2, unsigned long arg3) { unsigned long raddr; int rval; switch(op) { case 0: /* sys_shmat(): attach a shared memory area */ rval = sys_shmat((int)arg1,(char *)arg2,(int)arg3,&raddr); if(rval != 0) return rval; return (int) raddr; case 1: /* sys_shmctl(): modify shared memory area attr. */ return sys_shmctl((int)arg1,(int)arg2,(struct shmid_ds *)arg3); case 2: /* sys_shmdt(): detach a shared memory area */ return sys_shmdt((char *)arg1); case 3: /* sys_shmget(): get a shared memory area */ return sys_shmget((key_t)arg1,(int)arg2,(int)arg3); default: return -EINVAL; } }
/* * sys_ipc() is the de-multiplexer for the SysV IPC calls.. * * This is really horribly ugly. */ asmlinkage int sys_ipc (uint call, int first, int second, int third, void *ptr) { struct ipc_kludge tmp; int ret; switch (call) { case SEMOP: return sys_semop (first, (struct sembuf *)ptr, second); case SEMGET: return sys_semget (first, second, third); case SEMCTL: { union semun fourth; if (!ptr) return -EINVAL; if (get_user(fourth.__pad, (void **) ptr)) return -EFAULT; return sys_semctl (first, second, third, fourth); } case MSGSND: return sys_msgsnd (first, (struct msgbuf *) ptr, second, third); break; case MSGRCV: if (!ptr) return -EINVAL; if (copy_from_user (&tmp, (struct ipc_kludge *) ptr, sizeof (struct ipc_kludge))) return -EFAULT; return sys_msgrcv (first, tmp.msgp, second, tmp.msgtyp, third); case MSGGET: return sys_msgget ((key_t) first, second); case MSGCTL: return sys_msgctl (first, second, (struct msqid_ds *) ptr); case SHMAT: { ulong raddr; ret = sys_shmat (first, (char *) ptr, second, &raddr); if (ret) return ret; return put_user (raddr, (ulong *) third); break; } case SHMDT: return sys_shmdt ((char *)ptr); case SHMGET: return sys_shmget (first, second, third); case SHMCTL: return sys_shmctl (first, second, (struct shmid_ds *) ptr); default: return -EINVAL; } return -EINVAL; }
asmlinkage long osf_shmat(int shmid, void *shmaddr, int shmflg) { unsigned long raddr; int err; err = sys_shmat(shmid, shmaddr, shmflg, &raddr); if (err) return err; /* * This works because all user-level addresses are * non-negative longs! */ return raddr; }
int netbsd32_shmat(struct lwp *l, const struct netbsd32_shmat_args *uap, register_t *retval) { /* { syscallarg(int) shmid; syscallarg(const netbsd32_voidp) shmaddr; syscallarg(int) shmflg; } */ struct sys_shmat_args ua; NETBSD32TO64_UAP(shmid); NETBSD32TOP_UAP(shmaddr, void); NETBSD32TO64_UAP(shmflg); return sys_shmat(l, &ua, retval); }
asmlinkage unsigned long ia64_shmat (int shmid, void *shmaddr, int shmflg, long arg3, long arg4, long arg5, long arg6, long arg7, long stack) { extern int sys_shmat (int shmid, char *shmaddr, int shmflg, ulong *raddr); struct pt_regs *regs = (struct pt_regs *) &stack; unsigned long raddr; int retval; retval = sys_shmat(shmid, shmaddr, shmflg, &raddr); if (retval < 0) return retval; regs->r8 = 0; /* ensure negative addresses are not mistaken as an error code */ return raddr; }
int ultrix_sys_shmsys(struct lwp *l, const struct ultrix_sys_shmsys_args *uap, register_t *retval) { #ifdef SYSVSHM /* Ultrix SVSHM weirndess: */ struct sys_shmat_args shmat_args; struct compat_14_sys_shmctl_args shmctl_args; struct sys_shmdt_args shmdt_args; struct sys_shmget_args shmget_args; switch (SCARG(uap, shmop)) { case 0: /* Ultrix shmat() */ SCARG(&shmat_args, shmid) = SCARG(uap, a2); SCARG(&shmat_args, shmaddr) = (void *)SCARG(uap, a3); SCARG(&shmat_args, shmflg) = SCARG(uap, a4); return sys_shmat(l, &shmat_args, retval); case 1: /* Ultrix shmctl() */ SCARG(&shmctl_args, shmid) = SCARG(uap, a2); SCARG(&shmctl_args, cmd) = SCARG(uap, a3); SCARG(&shmctl_args, buf) = (struct shmid_ds14 *)SCARG(uap, a4); return compat_14_sys_shmctl(l, &shmctl_args, retval); case 2: /* Ultrix shmdt() */ SCARG(&shmat_args, shmaddr) = (void *)SCARG(uap, a2); return sys_shmdt(l, &shmdt_args, retval); case 3: /* Ultrix shmget() */ SCARG(&shmget_args, key) = SCARG(uap, a2); SCARG(&shmget_args, size) = SCARG(uap, a3); SCARG(&shmget_args, shmflg) = SCARG(uap, a4) & (IPC_CREAT|IPC_EXCL|IPC_NOWAIT); return sys_shmget(l, &shmget_args, retval); default: return EINVAL; } #else return EOPNOTSUPP; #endif /* SYSVSHM */ }
static unsigned long restore_mapping(const VmaEntry *vma_entry) { int prot = vma_entry->prot; int flags = vma_entry->flags | MAP_FIXED; unsigned long addr; if (vma_entry_is(vma_entry, VMA_AREA_SYSVIPC)) return sys_shmat(vma_entry->fd, decode_pointer(vma_entry->start), (vma_entry->prot & PROT_WRITE) ? 0 : SHM_RDONLY); /* * Restore or shared mappings are tricky, since * we open anonymous mapping via map_files/ * MAP_ANONYMOUS should be eliminated so fd would * be taken into account by a kernel. */ if (vma_entry_is(vma_entry, VMA_ANON_SHARED) && (vma_entry->fd != -1UL)) flags &= ~MAP_ANONYMOUS; /* A mapping of file with MAP_SHARED is up to date */ if (vma_entry->fd == -1 || !(vma_entry->flags & MAP_SHARED)) prot |= PROT_WRITE; pr_debug("\tmmap(%"PRIx64" -> %"PRIx64", %x %x %d)\n", vma_entry->start, vma_entry->end, prot, flags, (int)vma_entry->fd); /* * Should map memory here. Note we map them as * writable since we're going to restore page * contents. */ addr = sys_mmap(decode_pointer(vma_entry->start), vma_entry_len(vma_entry), prot, flags, vma_entry->fd, vma_entry->pgoff); if (vma_entry->fd != -1) sys_close(vma_entry->fd); return addr; }
asmlinkage int sunos_shmsys(int op, u32 arg1, u32 arg2, u32 arg3) { struct shmid_ds ksds; unsigned long raddr; mm_segment_t old_fs = get_fs(); int rval; switch(op) { case 0: /* sys_shmat(): attach a shared memory area */ rval = sys_shmat((int)arg1,(char *)A(arg2),(int)arg3,&raddr); if(!rval) rval = (int) raddr; break; case 1: /* sys_shmctl(): modify shared memory area attr. */ if(!sunos_shmid_get((struct shmid_ds32 *)A(arg3), &ksds)) { set_fs(KERNEL_DS); rval = sys_shmctl((int)arg1,(int)arg2, &ksds); set_fs(old_fs); if(!rval) rval = sunos_shmid_put((struct shmid_ds32 *)A(arg3), &ksds); } else rval = -EFAULT; break; case 2: /* sys_shmdt(): detach a shared memory area */ rval = sys_shmdt((char *)A(arg1)); break; case 3: /* sys_shmget(): get a shared memory area */ rval = sys_shmget((key_t)arg1,(int)arg2,(int)arg3); break; default: rval = -EINVAL; break; }; return rval; }
static int linux32_shmat(struct lwp *l, const struct linux32_sys_ipc_args *uap, register_t *retval) { struct sys_shmat_args ua; netbsd32_pointer_t addr32; int error; SCARG(&ua, shmid) = SCARG(uap, a1); SCARG(&ua, shmaddr) = SCARG_P32(uap, ptr); SCARG(&ua, shmflg) = SCARG(uap, a2); if ((error = sys_shmat(l, &ua, retval))) return error; NETBSD32PTR32(addr32, (const void *)(uintptr_t)retval[0]); error = copyout(&addr32, NETBSD32IPTR64(SCARG(uap, a3)), sizeof addr32); if (error == 0) retval[0] = 0; return error; }
/* * sys_ipc() is the de-multiplexer for the SysV IPC calls.. * * This is really horribly ugly. */ asmlinkage int sys_ipc (uint call, int first, int second, int third, void *ptr, long fifth) { int version; version = call >> 16; /* hack for backward compatibility */ call &= 0xffff; if (call <= SEMCTL) switch (call) { case SEMOP: return sys_semop (first, (struct sembuf *)ptr, second); case SEMGET: return sys_semget (first, second, third); case SEMCTL: { union semun fourth; int err; if (!ptr) return -EINVAL; if ((err = verify_area (VERIFY_READ, ptr, sizeof(long)))) return err; fourth.__pad = get_user((void **)ptr); return sys_semctl (first, second, third, fourth); } default: return -EINVAL; } if (call <= MSGCTL) switch (call) { case MSGSND: return sys_msgsnd (first, (struct msgbuf *) ptr, second, third); case MSGRCV: switch (version) { case 0: { struct ipc_kludge tmp; int err; if (!ptr) return -EINVAL; if ((err = verify_area (VERIFY_READ, ptr, sizeof(tmp)))) return err; memcpy_fromfs (&tmp,(struct ipc_kludge *) ptr, sizeof (tmp)); return sys_msgrcv (first, tmp.msgp, second, tmp.msgtyp, third); } case 1: default: return sys_msgrcv (first, (struct msgbuf *) ptr, second, fifth, third); } case MSGGET: return sys_msgget ((key_t) first, second); case MSGCTL: return sys_msgctl (first, second, (struct msqid_ds *) ptr); default: return -EINVAL; } if (call <= SHMCTL) switch (call) { case SHMAT: switch (version) { case 0: default: { ulong raddr; int err; if ((err = verify_area(VERIFY_WRITE, (ulong*) third, sizeof(ulong)))) return err; err = sys_shmat (first, (char *) ptr, second, &raddr); if (err) return err; put_user (raddr, (ulong *) third); return 0; } case 1: /* iBCS2 emulator entry point */ if (get_fs() != get_ds()) return -EINVAL; return sys_shmat (first, (char *) ptr, second, (ulong *) third); } case SHMDT: return sys_shmdt ((char *)ptr); case SHMGET: return sys_shmget (first, second, third); case SHMCTL: return sys_shmctl (first, second, (struct shmid_ds *) ptr); default: return -EINVAL; } return -EINVAL; }
/* * sys_ipc() is the de-multiplexer for the SysV IPC calls.. * * This is really horribly ugly. */ asmlinkage int sys_ipc (uint call, int first, int second, int third, void *ptr, long fifth) { int version, ret; version = call >> 16; /* hack for backward compatibility */ call &= 0xffff; switch (call) { case SEMOP: return sys_semtimedop (first, (struct sembuf *)ptr, second, NULL); case SEMTIMEDOP: return sys_semtimedop (first, (struct sembuf *)ptr, second, (const struct timespec *)fifth); case SEMGET: return sys_semget (first, second, third); case SEMCTL: { union semun fourth; if (!ptr) return -EINVAL; if (get_user(fourth.__pad, (void **) ptr)) return -EFAULT; return sys_semctl (first, second, third, fourth); } case MSGSND: return sys_msgsnd (first, (struct msgbuf *) ptr, second, third); case MSGRCV: switch (version) { case 0: { struct ipc_kludge tmp; if (!ptr) return -EINVAL; if (copy_from_user(&tmp, (struct ipc_kludge *) ptr, sizeof (tmp))) return -EFAULT; return sys_msgrcv (first, tmp.msgp, second, tmp.msgtyp, third); } default: return sys_msgrcv (first, (struct msgbuf *) ptr, second, fifth, third); } case MSGGET: return sys_msgget ((key_t) first, second); case MSGCTL: return sys_msgctl (first, second, (struct msqid_ds *) ptr); case SHMAT: switch (version) { default: { ulong raddr; ret = sys_shmat (first, (char *) ptr, second, &raddr); if (ret) return ret; return put_user (raddr, (ulong *) third); } case 1: /* iBCS2 emulator entry point */ if (!segment_eq(get_fs(), get_ds())) return -EINVAL; return sys_shmat (first, (char *) ptr, second, (ulong *) third); } case SHMDT: return sys_shmdt ((char *)ptr); case SHMGET: return sys_shmget (first, second, third); case SHMCTL: return sys_shmctl (first, second, (struct shmid_ds *) ptr); default: return -ENOSYS; } }
/* * sys_ipc() is the de-multiplexer for the SysV IPC calls.. * * This is really horribly ugly. */ int sys_ipc (uint call, int first, int second, int third, void *ptr, long fifth) { int version, ret; version = call >> 16; /* hack for backward compatibility */ call &= 0xffff; ret = -EINVAL; switch (call) { case SEMOP: ret = sys_semop (first, (struct sembuf *)ptr, second); break; case SEMGET: ret = sys_semget (first, second, third); break; case SEMCTL: { union semun fourth; if (!ptr) break; if ((ret = verify_area (VERIFY_READ, ptr, sizeof(long))) || (ret = get_user(fourth.__pad, (void **)ptr))) break; ret = sys_semctl (first, second, third, fourth); break; } case MSGSND: ret = sys_msgsnd (first, (struct msgbuf *) ptr, second, third); break; case MSGRCV: switch (version) { case 0: { struct ipc_kludge tmp; if (!ptr) break; if ((ret = verify_area (VERIFY_READ, ptr, sizeof(tmp))) || (ret = copy_from_user(&tmp, (struct ipc_kludge *) ptr, sizeof (tmp)))) break; ret = sys_msgrcv (first, tmp.msgp, second, tmp.msgtyp, third); break; } default: ret = sys_msgrcv (first, (struct msgbuf *) ptr, second, fifth, third); break; } break; case MSGGET: ret = sys_msgget ((key_t) first, second); break; case MSGCTL: ret = sys_msgctl (first, second, (struct msqid_ds *) ptr); break; case SHMAT: switch (version) { default: { ulong raddr; if ((ret = verify_area(VERIFY_WRITE, (ulong*) third, sizeof(ulong)))) break; ret = sys_shmat (first, (char *) ptr, second, &raddr); if (ret) break; ret = put_user (raddr, (ulong *) third); break; } case 1: /* iBCS2 emulator entry point */ if (!segment_eq(get_fs(), get_ds())) break; ret = sys_shmat (first, (char *) ptr, second, (ulong *) third); break; } break; case SHMDT: ret = sys_shmdt ((char *)ptr); break; case SHMGET: ret = sys_shmget (first, second, third); break; case SHMCTL: ret = sys_shmctl (first, second, (struct shmid_ds *) ptr); break; } return ret; }
asmlinkage int sys_ipc (uint call, int first, int second, int third, void *ptr, long fifth) { int version, err; version = call >> 16; /* hack for backward compatibility */ call &= 0xffff; if (call <= SEMCTL) switch (call) { case SEMOP: err = sys_semtimedop (first, (struct sembuf *)ptr, second, NULL); goto out; case SEMTIMEDOP: err = sys_semtimedop (first, (struct sembuf *)ptr, second, (const struct timespec *) fifth); goto out; case SEMGET: err = sys_semget (first, second, third); goto out; case SEMCTL: { union semun fourth; err = -EINVAL; if (!ptr) goto out; err = -EFAULT; if(get_user(fourth.__pad, (void **)ptr)) goto out; err = sys_semctl (first, second, third, fourth); goto out; } default: err = -ENOSYS; goto out; } if (call <= MSGCTL) switch (call) { case MSGSND: err = sys_msgsnd (first, (struct msgbuf *) ptr, second, third); goto out; case MSGRCV: switch (version) { case 0: { struct ipc_kludge tmp; err = -EINVAL; if (!ptr) goto out; err = -EFAULT; if(copy_from_user(&tmp,(struct ipc_kludge *) ptr, sizeof (tmp))) goto out; err = sys_msgrcv (first, tmp.msgp, second, tmp.msgtyp, third); goto out; } case 1: default: err = sys_msgrcv (first, (struct msgbuf *) ptr, second, fifth, third); goto out; } case MSGGET: err = sys_msgget ((key_t) first, second); goto out; case MSGCTL: err = sys_msgctl (first, second, (struct msqid_ds *) ptr); goto out; default: err = -ENOSYS; goto out; } if (call <= SHMCTL) switch (call) { case SHMAT: switch (version) { case 0: default: { ulong raddr; err = sys_shmat (first, (char *) ptr, second, &raddr); if (err) goto out; err = -EFAULT; if(put_user (raddr, (ulong *) third)) goto out; err = 0; goto out; } case 1: /* iBCS2 emulator entry point */ err = sys_shmat (first, (char *) ptr, second, (ulong *) third); goto out; } case SHMDT: err = sys_shmdt ((char *)ptr); goto out; case SHMGET: err = sys_shmget (first, second, third); goto out; case SHMCTL: err = sys_shmctl (first, second, (struct shmid_ds *) ptr); goto out; default: err = -ENOSYS; goto out; } else err = -ENOSYS; out: return err; }
/* * sys_ipc() is the de-multiplexer for the SysV IPC calls.. * * This is really horribly ugly. */ asmlinkage int sys_ipc (uint call, int first, int second, int third, void *ptr, long fifth) { int version, ret; lock_kernel(); version = call >> 16; /* hack for backward compatibility */ call &= 0xffff; if (call <= SEMCTL) switch (call) { case SEMOP: ret = sys_semop (first, (struct sembuf *)ptr, second); goto out; case SEMGET: ret = sys_semget (first, second, third); goto out; case SEMCTL: { union semun fourth; ret = -EINVAL; if (!ptr) goto out; ret = -EFAULT; if (get_user(fourth.__pad, (void **) ptr)) goto out; ret = sys_semctl (first, second, third, fourth); goto out; } default: ret = -EINVAL; goto out; } if (call <= MSGCTL) switch (call) { case MSGSND: ret = sys_msgsnd (first, (struct msgbuf *) ptr, second, third); goto out; case MSGRCV: switch (version) { case 0: { struct ipc_kludge tmp; ret = -EINVAL; if (!ptr) goto out; ret = -EFAULT; if (copy_from_user(&tmp,(struct ipc_kludge *) ptr, sizeof (tmp))) goto out; ret = sys_msgrcv (first, tmp.msgp, second, tmp.msgtyp, third); goto out; } case 1: default: ret = sys_msgrcv (first, (struct msgbuf *) ptr, second, fifth, third); goto out; } case MSGGET: ret = sys_msgget ((key_t) first, second); goto out; case MSGCTL: ret = sys_msgctl (first, second, (struct msqid_ds *) ptr); goto out; default: ret = -EINVAL; goto out; } if (call <= SHMCTL) switch (call) { case SHMAT: switch (version) { case 0: default: { ulong raddr; ret = sys_shmat (first, (char *) ptr, second, &raddr); if (ret) goto out; ret = put_user (raddr, (ulong *) third); goto out; } case 1: /* iBCS2 emulator entry point */ ret = -EINVAL; if (!segment_eq(get_fs(), get_ds())) goto out; ret = sys_shmat (first, (char *) ptr, second, (ulong *) third); goto out; } case SHMDT: ret = sys_shmdt ((char *)ptr); goto out; case SHMGET: ret = sys_shmget (first, second, third); goto out; case SHMCTL: ret = sys_shmctl (first, second, (struct shmid_ds *) ptr); goto out; default: ret = -EINVAL; goto out; } else ret = -EINVAL; out: unlock_kernel(); return ret; }