/* *  arch/s390/kernel/sys_s390.c * *  S390 version *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com), *               Thomas Spatzier (tspat@de.ibm.com) * *  Derived from "arch/i386/kernel/sys_i386.c" * *  This file contains various random system calls that *  have a non-standard calling sequence on the Linux/s390 *  platform. */#include <linux/errno.h>#include <linux/sched.h>#include <linux/mm.h>#include <linux/smp.h>#include <linux/smp_lock.h>#include <linux/sem.h>#include <linux/msg.h>#include <linux/shm.h>#include <linux/stat.h>#include <linux/syscalls.h>#include <linux/mman.h>#include <linux/file.h>#include <linux/utsname.h>#ifdef CONFIG_ARCH_S390X#include <linux/personality.h>#endif /* CONFIG_ARCH_S390X */#include <asm/uaccess.h>#include <asm/ipc.h>/* * sys_pipe() is the normal C calling standard for creating * a pipe. It's not the way Unix traditionally does this, though. */asmlinkage long sys_pipe(unsigned long __user *fildes){	int fd[2];	int error;	error = do_pipe(fd);	if (!error) {		if (copy_to_user(fildes, fd, 2*sizeof(int)))			error = -EFAULT;	}	return error;}/* common code for old and new mmaps */static inline long do_mmap2(	unsigned long addr, unsigned long len,	unsigned long prot, unsigned long flags,	unsigned long fd, unsigned long pgoff){	long error = -EBADF;	struct file * file = NULL;	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);	if (!(flags & MAP_ANONYMOUS)) {		file = fget(fd);		if (!file)			goto out;	}	down_write(&current->mm->mmap_sem);	error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);	up_write(&current->mm->mmap_sem);	if (file)		fput(file);out:	return error;}/* * Perform the select(nd, in, out, ex, tv) and mmap() system * calls. Linux for S/390 isn't able to handle more than 5 * system call parameters, so these system calls used a memory * block for parameter passing.. */struct mmap_arg_struct {	unsigned long addr;	unsigned long len;	unsigned long prot;	unsigned long flags;	unsigned long fd;	unsigned long offset;};asmlinkage long sys_mmap2(struct mmap_arg_struct __user  *arg){	struct mmap_arg_struct a;	int error = -EFAULT;	if (copy_from_user(&a, arg, sizeof(a)))		goto out;	error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset);out:	return error;}asmlinkage long old_mmap(struct mmap_arg_struct __user *arg){	struct mmap_arg_struct a;	long error = -EFAULT;	if (copy_from_user(&a, arg, sizeof(a)))		goto out;	error = -EINVAL;	if (a.offset & ~PAGE_MASK)		goto out;	error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT);out:	return error;}#ifndef CONFIG_ARCH_S390Xstruct sel_arg_struct {	unsigned long n;	fd_set *inp, *outp, *exp;	struct timeval *tvp;};asmlinkage long old_select(struct sel_arg_struct __user *arg){	struct sel_arg_struct a;	if (copy_from_user(&a, arg, sizeof(a)))		return -EFAULT;	/* sys_select() does the appropriate kernel locking */	return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);}#endif /* CONFIG_ARCH_S390X *//* * sys_ipc() is the de-multiplexer for the SysV IPC calls.. * * This is really horribly ugly. */asmlinkage long sys_ipc(uint call, int first, int second,				  unsigned long third, void __user *ptr){        struct ipc_kludge tmp;	int ret;        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 *) third);        case SEMGET:                return sys_semget (first, second, third);        case SEMCTL: {                union semun fourth;                if (!ptr)                        return -EINVAL;                if (get_user(fourth.__pad, (void __user * __user *) ptr))                        return -EFAULT;                return sys_semctl (first, second, third, fourth);        }        case MSGSND:		return sys_msgsnd (first, (struct msgbuf __user *) ptr,                                   second, third);		break;        case MSGRCV:                if (!ptr)                        return -EINVAL;                if (copy_from_user (&tmp, (struct ipc_kludge __user *) 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 __user *) ptr);	case SHMAT: {		ulong raddr;		ret = do_shmat (first, (char __user *) ptr, second, &raddr);		if (ret)			return ret;		return put_user (raddr, (ulong __user *) third);		break;        }	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;	}	return -EINVAL;}#ifdef CONFIG_ARCH_S390Xasmlinkage long s390x_newuname(struct new_utsname __user *name){	int ret = sys_newuname(name);	if (current->personality == PER_LINUX32 && !ret) {		ret = copy_to_user(name->machine, "s390\0\0\0\0", 8);		if (ret) ret = -EFAULT;	}	return ret;}asmlinkage long s390x_personality(unsigned long personality){	int ret;	if (current->personality == PER_LINUX32 && personality == PER_LINUX)		personality = PER_LINUX32;	ret = sys_personality(personality);	if (ret == PER_LINUX32)		ret = PER_LINUX;	return ret;}#endif /* CONFIG_ARCH_S390X *//* * Wrapper function for sys_fadvise64/fadvise64_64 */#ifndef CONFIG_ARCH_S390Xasmlinkage longs390_fadvise64(int fd, u32 offset_high, u32 offset_low, size_t len, int advice){	return sys_fadvise64(fd, (u64) offset_high << 32 | offset_low,			len, advice);}#endifstruct fadvise64_64_args {	int fd;	long long offset;	long long len;	int advice;};asmlinkage longs390_fadvise64_64(struct fadvise64_64_args __user *args){	struct fadvise64_64_args a;	if ( copy_from_user(&a, args, sizeof(a)) )		return -EFAULT;	return sys_fadvise64_64(a.fd, a.offset, a.len, a.advice);}