arch/s390/kernel/sys_s390.c - android_kernel_htc_msm8960 - Gitiles

 /*
  *  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/fs.h>
 #include <linux/smp.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>
 #include <linux/personality.h>
 #include <linux/unistd.h>
 #include <linux/ipc.h>
 #include <asm/uaccess.h>
 #include "entry.h"

 /* 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;
 };

 SYSCALL_DEFINE1(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;
 }

 SYSCALL_DEFINE1(s390_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;
 }

 /*
  * sys_ipc() is the de-multiplexer for the SysV IPC calls..
  *
  * This is really horribly ugly.
  */
 SYSCALL_DEFINE5(ipc, uint, call, int, first, unsigned long, 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,
 				       (unsigned)second, NULL);
 	case SEMTIMEDOP:
 		return sys_semtimedop(first, (struct sembuf __user *)ptr,
 				       (unsigned)second,
 				       (const struct timespec __user *) third);
         case SEMGET:
                 return sys_semget(first, (int)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, (int)second, third, fourth);
         }
         case MSGSND:
 		return sys_msgsnd (first, (struct msgbuf __user *) ptr,
                                    (size_t)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,
                                    (size_t)second, tmp.msgtyp, third);
         case MSGGET:
                 return sys_msgget((key_t)first, (int)second);
         case MSGCTL:
                 return sys_msgctl(first, (int)second,
 				   (struct msqid_ds __user *)ptr);

 	case SHMAT: {
 		ulong raddr;
 		ret = do_shmat(first, (char __user *)ptr,
 				(int)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, (size_t)second, third);
 	case SHMCTL:
 		return sys_shmctl(first, (int)second,
                                    (struct shmid_ds __user *) ptr);
 	default:
 		return -ENOSYS;

 	}

 	return -EINVAL;
 }

 #ifdef CONFIG_64BIT
 SYSCALL_DEFINE1(s390_newuname, struct new_utsname __user *, name)
 {
 	int ret = sys_newuname(name);

 	if (personality(current->personality) == PER_LINUX32 && !ret) {
 		ret = copy_to_user(name->machine, "s390\0\0\0\0", 8);
 		if (ret) ret = -EFAULT;
 	}
 	return ret;
 }

 SYSCALL_DEFINE1(s390_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_64BIT */

 /*
  * Wrapper function for sys_fadvise64/fadvise64_64
  */
 #ifndef CONFIG_64BIT

 SYSCALL_DEFINE5(s390_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);
 }

 struct fadvise64_64_args {
 	int fd;
 	long long offset;
 	long long len;
 	int advice;
 };

 SYSCALL_DEFINE1(s390_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);
 }

 /*
  * This is a wrapper to call sys_fallocate(). For 31 bit s390 the last
  * 64 bit argument "len" is split into the upper and lower 32 bits. The
  * system call wrapper in the user space loads the value to %r6/%r7.
  * The code in entry.S keeps the values in %r2 - %r6 where they are and
  * stores %r7 to 96(%r15). But the standard C linkage requires that
  * the whole 64 bit value for len is stored on the stack and doesn't
  * use %r6 at all. So s390_fallocate has to convert the arguments from
  *   %r2: fd, %r3: mode, %r4/%r5: offset, %r6/96(%r15)-99(%r15): len
  * to
  *   %r2: fd, %r3: mode, %r4/%r5: offset, 96(%r15)-103(%r15): len
  */
 SYSCALL_DEFINE(s390_fallocate)(int fd, int mode, loff_t offset,
 			       u32 len_high, u32 len_low)
 {
 	return sys_fallocate(fd, mode, offset, ((u64)len_high << 32) | len_low);
 }
 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
 asmlinkage long SyS_s390_fallocate(long fd, long mode, loff_t offset,
 				   long len_high, long len_low)
 {
 	return SYSC_s390_fallocate((int) fd, (int) mode, offset,
 				   (u32) len_high, (u32) len_low);
 }
 SYSCALL_ALIAS(sys_s390_fallocate, SyS_s390_fallocate);
 #endif

 #endif
	/*
	* 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/fs.h>
	#include <linux/smp.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>
	#include <linux/personality.h>
	#include <linux/unistd.h>
	#include <linux/ipc.h>
	#include <asm/uaccess.h>
	#include "entry.h"

	/* 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;
	};

	SYSCALL_DEFINE1(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;
	}

	SYSCALL_DEFINE1(s390_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;
	}

	/*
	* sys_ipc() is the de-multiplexer for the SysV IPC calls..
	*
	* This is really horribly ugly.
	*/
	SYSCALL_DEFINE5(ipc, uint, call, int, first, unsigned long, 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,
	(unsigned)second, NULL);
	case SEMTIMEDOP:
	return sys_semtimedop(first, (struct sembuf __user *)ptr,
	(unsigned)second,
	(const struct timespec __user *) third);
	case SEMGET:
	return sys_semget(first, (int)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, (int)second, third, fourth);
	}
	case MSGSND:
	return sys_msgsnd (first, (struct msgbuf __user *) ptr,
	(size_t)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,
	(size_t)second, tmp.msgtyp, third);
	case MSGGET:
	return sys_msgget((key_t)first, (int)second);
	case MSGCTL:
	return sys_msgctl(first, (int)second,
	(struct msqid_ds __user *)ptr);

	case SHMAT: {
	ulong raddr;
	ret = do_shmat(first, (char __user *)ptr,
	(int)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, (size_t)second, third);
	case SHMCTL:
	return sys_shmctl(first, (int)second,
	(struct shmid_ds __user *) ptr);
	default:
	return -ENOSYS;

	}

	return -EINVAL;
	}

	#ifdef CONFIG_64BIT
	SYSCALL_DEFINE1(s390_newuname, struct new_utsname __user *, name)
	{
	int ret = sys_newuname(name);

	if (personality(current->personality) == PER_LINUX32 && !ret) {
	ret = copy_to_user(name->machine, "s390\0\0\0\0", 8);
	if (ret) ret = -EFAULT;
	}
	return ret;
	}

	SYSCALL_DEFINE1(s390_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_64BIT */

	/*
	* Wrapper function for sys_fadvise64/fadvise64_64
	*/
	#ifndef CONFIG_64BIT

	SYSCALL_DEFINE5(s390_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);
	}

	struct fadvise64_64_args {
	int fd;
	long long offset;
	long long len;
	int advice;
	};

	SYSCALL_DEFINE1(s390_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);
	}

	/*
	* This is a wrapper to call sys_fallocate(). For 31 bit s390 the last
	* 64 bit argument "len" is split into the upper and lower 32 bits. The
	* system call wrapper in the user space loads the value to %r6/%r7.
	* The code in entry.S keeps the values in %r2 - %r6 where they are and
	* stores %r7 to 96(%r15). But the standard C linkage requires that
	* the whole 64 bit value for len is stored on the stack and doesn't
	* use %r6 at all. So s390_fallocate has to convert the arguments from
	* %r2: fd, %r3: mode, %r4/%r5: offset, %r6/96(%r15)-99(%r15): len
	* to
	* %r2: fd, %r3: mode, %r4/%r5: offset, 96(%r15)-103(%r15): len
	*/
	SYSCALL_DEFINE(s390_fallocate)(int fd, int mode, loff_t offset,
	u32 len_high, u32 len_low)
	{
	return sys_fallocate(fd, mode, offset, ((u64)len_high << 32) \| len_low);
	}
	#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
	asmlinkage long SyS_s390_fallocate(long fd, long mode, loff_t offset,
	long len_high, long len_low)
	{
	return SYSC_s390_fallocate((int) fd, (int) mode, offset,
	(u32) len_high, (u32) len_low);
	}
	SYSCALL_ALIAS(sys_s390_fallocate, SyS_s390_fallocate);
	#endif

	#endif