asmlinkage int sunos_shmsys(int op, unsigned long arg1, unsigned long arg2, unsigned long arg3) { unsigned long raddr; int rval; switch(op) { case 0: /* do_shmat(): attach a shared memory area */ rval = do_shmat((int)arg1,(char __user *)arg2,(int)arg3,&raddr); if (!rval) rval = (int) raddr; break; case 1: /* sys_shmctl(): modify shared memory area attr. */ rval = sys_shmctl((int)arg1,(int)arg2,(struct shmid_ds __user *)arg3); break; case 2: /* sys_shmdt(): detach a shared memory area */ rval = sys_shmdt((char __user *)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; }
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 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: /* do_shmat(): attach a shared memory area */ rval = do_shmat((int)arg1,(char __user *)(unsigned long)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 __user *)(unsigned long)arg3, &ksds)) { set_fs(KERNEL_DS); rval = sys_shmctl((int) arg1,(int) arg2, (struct shmid_ds __user *) &ksds); set_fs(old_fs); if (!rval) rval = sunos_shmid_put((struct shmid_ds32 __user *)(unsigned long)arg3, &ksds); } else rval = -EFAULT; break; case 2: /* sys_shmdt(): detach a shared memory area */ rval = sys_shmdt((char __user *)(unsigned long)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; }
/* * 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; }
SYSCALL_DEFINE6(sparc_ipc, unsigned int, call, int, first, unsigned long, second, unsigned long, third, void __user *, ptr, long, fifth) { long err; /* No need for backward compatibility. We can start fresh... */ if (call <= SEMCTL) { switch (call) { case SEMOP: err = sys_semtimedop(first, ptr, (unsigned)second, NULL); goto out; case SEMTIMEDOP: err = sys_semtimedop(first, ptr, (unsigned)second, (const struct timespec __user *) (unsigned long) fifth); goto out; case SEMGET: err = sys_semget(first, (int)second, (int)third); goto out; case SEMCTL: { err = sys_semctl(first, second, (int)third | IPC_64, (union semun) ptr); goto out; } default: err = -ENOSYS; goto out; } } if (call <= MSGCTL) { switch (call) { case MSGSND: err = sys_msgsnd(first, ptr, (size_t)second, (int)third); goto out; case MSGRCV: err = sys_msgrcv(first, ptr, (size_t)second, fifth, (int)third); goto out; case MSGGET: err = sys_msgget((key_t)first, (int)second); goto out; case MSGCTL: err = sys_msgctl(first, (int)second | IPC_64, ptr); goto out; default: err = -ENOSYS; goto out; } } if (call <= SHMCTL) { switch (call) { case SHMAT: { ulong raddr; err = do_shmat(first, ptr, (int)second, &raddr); if (!err) { if (put_user(raddr, (ulong __user *) third)) err = -EFAULT; } goto out; } case SHMDT: err = sys_shmdt(ptr); goto out; case SHMGET: err = sys_shmget(first, (size_t)second, (int)third); goto out; case SHMCTL: err = sys_shmctl(first, (int)second | IPC_64, 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; 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. This will be remove with new toolchain. */ asmlinkage long 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; ret = (access_ok(VERIFY_READ, ptr, sizeof(long)) ? 0 : -EFAULT) || (get_user(fourth.__pad, (void **)ptr)) ; if (ret) 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; ret = (access_ok(VERIFY_READ, ptr, sizeof(tmp)) ? 0 : -EFAULT) || copy_from_user(&tmp, (struct ipc_kludge *) ptr, sizeof(tmp)); if (ret) 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; ret = access_ok(VERIFY_WRITE, (ulong *) third, sizeof(ulong)) ? 0 : -EFAULT; if (ret) break; ret = do_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 = do_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; }
long compat_sys_shmctl(int first, int second, void __user *uptr) { void __user *p; struct shmid64_ds s64; struct shminfo64 smi; int err, err2; int version = compat_ipc_parse_version(&second); memset(&s64, 0, sizeof(s64)); switch (second & (~IPC_64)) { case IPC_RMID: case SHM_LOCK: case SHM_UNLOCK: err = sys_shmctl(first, second, uptr); break; case IPC_INFO: p = compat_alloc_user_space(sizeof(smi)); err = sys_shmctl(first, second, p); if (err < 0) break; if (copy_from_user(&smi, p, sizeof(smi))) err2 = -EFAULT; else if (version == IPC_64) err2 = put_compat_shminfo64(&smi, uptr); else err2 = put_compat_shminfo(&smi, uptr); if (err2) err = -EFAULT; break; case IPC_SET: if (version == IPC_64) { err = get_compat_shmid64_ds(&s64, uptr); } else { err = get_compat_shmid_ds(&s64, uptr); } if (err) break; p = compat_alloc_user_space(sizeof(s64)); if (copy_to_user(p, &s64, sizeof(s64))) err = -EFAULT; else err = sys_shmctl(first, second, p); break; case IPC_STAT: case SHM_STAT: p = compat_alloc_user_space(sizeof(s64)); err = sys_shmctl(first, second, p); if (err < 0) break; if (copy_from_user(&s64, p, sizeof(s64))) err2 = -EFAULT; else if (version == IPC_64) err2 = put_compat_shmid64_ds(&s64, uptr); else err2 = put_compat_shmid_ds(&s64, uptr); if (err2) err = -EFAULT; break; case SHM_INFO: p = compat_alloc_user_space(sizeof(struct shm_info)); err = sys_shmctl(first, second, p); if (err < 0) break; err2 = put_compat_shm_info(p, uptr); if (err2) err = -EFAULT; break; default: err = -EINVAL; break; } 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, long third, void *ptr, long fifth) { int version, ret; PPCDBG(PPCDBG_SYS64X, "sys_ipc - entered - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm); 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, (struct msgbuf *)(unsigned long)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; } PPCDBG(PPCDBG_SYS64X, "sys_ipc - exited - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm); 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; }
SYSCALL_DEFINE6(ipc, unsigned int, call, int, first, unsigned long, second, unsigned long, third, void __user *, 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 __user *)ptr, second, NULL); case SEMTIMEDOP: return sys_semtimedop(first, (struct sembuf __user *)ptr, second, (const struct timespec __user *)fifth); case SEMGET: return sys_semget(first, second, third); case SEMCTL: { unsigned long arg; if (!ptr) return -EINVAL; if (get_user(arg, (unsigned long __user *) ptr)) return -EFAULT; return sys_semctl(first, second, third, arg); } case MSGSND: return sys_msgsnd(first, (struct msgbuf __user *) 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 __user *) ptr, sizeof(tmp))) return -EFAULT; return sys_msgrcv(first, tmp.msgp, second, tmp.msgtyp, third); } default: return sys_msgrcv(first, (struct msgbuf __user *) ptr, second, fifth, third); } case MSGGET: return sys_msgget((key_t) first, second); case MSGCTL: return sys_msgctl(first, second, (struct msqid_ds __user *)ptr); case SHMAT: switch (version) { default: { unsigned long raddr; ret = do_shmat(first, (char __user *)ptr, second, &raddr, SHMLBA); if (ret) return ret; return put_user(raddr, (unsigned long __user *) third); } case 1: /* * This was the entry point for kernel-originating calls * from iBCS2 in 2.2 days. */ return -EINVAL; } case SHMDT: return sys_shmdt((char __user *)ptr); case SHMGET: return sys_shmget(first, second, third); case SHMCTL: return sys_shmctl(first, second, (struct shmid_ds __user *) ptr); default: return -ENOSYS; } }