1/*
  2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
  3 *
  4 *   This program is free software; you can redistribute it and/or
  5 *   modify it under the terms of the GNU General Public License
  6 *   as published by the Free Software Foundation, version 2.
  7 *
  8 *   This program is distributed in the hope that it will be useful, but
  9 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 10 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 11 *   NON INFRINGEMENT.  See the GNU General Public License for
 12 *   more details.
 13 */
 14
 15/* Adjust unistd.h to provide 32-bit numbers and functions. */
 16#define __SYSCALL_COMPAT
 17
 18#include <linux/compat.h>
 19#include <linux/syscalls.h>
 20#include <linux/kdev_t.h>
 21#include <linux/fs.h>
 22#include <linux/fcntl.h>
 23#include <linux/uaccess.h>
 24#include <linux/signal.h>
 25#include <asm/syscalls.h>
 26#include <asm/byteorder.h>
 27
 28/*
 29 * Syscalls that take 64-bit numbers traditionally take them in 32-bit
 30 * "high" and "low" value parts on 32-bit architectures.
 31 * In principle, one could imagine passing some register arguments as
 32 * fully 64-bit on TILE-Gx in 32-bit mode, but it seems easier to
 33 * adopt the usual convention.
 34 */
 35
 36#ifdef __BIG_ENDIAN
 37#define SYSCALL_PAIR(name) u32, name ## _hi, u32, name ## _lo
 38#else
 39#define SYSCALL_PAIR(name) u32, name ## _lo, u32, name ## _hi
 40#endif
 41
 42COMPAT_SYSCALL_DEFINE4(truncate64, char __user *, filename, u32, dummy,
 43		       SYSCALL_PAIR(length))
 44{
 45	return sys_truncate(filename, ((loff_t)length_hi << 32) | length_lo);
 46}
 47
 48COMPAT_SYSCALL_DEFINE4(ftruncate64, unsigned int, fd, u32, dummy,
 49		       SYSCALL_PAIR(length))
 50{
 51	return sys_ftruncate(fd, ((loff_t)length_hi << 32) | length_lo);
 52}
 53
 54COMPAT_SYSCALL_DEFINE6(pread64, unsigned int, fd, char __user *, ubuf,
 55		       size_t, count, u32, dummy, SYSCALL_PAIR(offset))
 56{
 57	return sys_pread64(fd, ubuf, count,
 58			   ((loff_t)offset_hi << 32) | offset_lo);
 59}
 60
 61COMPAT_SYSCALL_DEFINE6(pwrite64, unsigned int, fd, char __user *, ubuf,
 62		       size_t, count, u32, dummy, SYSCALL_PAIR(offset))
 63{
 64	return sys_pwrite64(fd, ubuf, count,
 65			    ((loff_t)offset_hi << 32) | offset_lo);
 66}
 67
 68COMPAT_SYSCALL_DEFINE6(sync_file_range2, int, fd, unsigned int, flags,
 69		       SYSCALL_PAIR(offset), SYSCALL_PAIR(nbytes))
 
 70{
 71	return sys_sync_file_range(fd, ((loff_t)offset_hi << 32) | offset_lo,
 72				   ((loff_t)nbytes_hi << 32) | nbytes_lo,
 73				   flags);
 74}
 75
 76COMPAT_SYSCALL_DEFINE6(fallocate, int, fd, int, mode,
 77		       SYSCALL_PAIR(offset), SYSCALL_PAIR(len))
 
 78{
 79	return sys_fallocate(fd, mode, ((loff_t)offset_hi << 32) | offset_lo,
 80			     ((loff_t)len_hi << 32) | len_lo);
 81}
 82
 83/*
 84 * Avoid bug in generic sys_llseek() that specifies offset_high and
 85 * offset_low as "unsigned long", thus making it possible to pass
 86 * a sign-extended high 32 bits in offset_low.
 87 * Note that we do not use SYSCALL_PAIR here since glibc passes the
 88 * high and low parts explicitly in that order.
 89 */
 90COMPAT_SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned int, offset_high,
 91		       unsigned int, offset_low, loff_t __user *, result,
 92		       unsigned int, origin)
 93{
 94	return sys_llseek(fd, offset_high, offset_low, result, origin);
 95}
 96
 97/* Provide the compat syscall number to call mapping. */
 98#undef __SYSCALL
 99#define __SYSCALL(nr, call) [nr] = (call),
100
101/* See comments in sys.c */
102#define compat_sys_fadvise64_64 sys32_fadvise64_64
103#define compat_sys_readahead sys32_readahead
104#define sys_llseek compat_sys_llseek
105
106/* Call the assembly trampolines where necessary. */
107#define compat_sys_rt_sigreturn _compat_sys_rt_sigreturn
108#define sys_clone _sys_clone
109
110/*
111 * Note that we can't include <linux/unistd.h> here since the header
112 * guard will defeat us; <asm/unistd.h> checks for __SYSCALL as well.
113 */
114void *compat_sys_call_table[__NR_syscalls] = {
115	[0 ... __NR_syscalls-1] = sys_ni_syscall,
116#include <asm/unistd.h>
117};

  1/*
  2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
  3 *
  4 *   This program is free software; you can redistribute it and/or
  5 *   modify it under the terms of the GNU General Public License
  6 *   as published by the Free Software Foundation, version 2.
  7 *
  8 *   This program is distributed in the hope that it will be useful, but
  9 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 10 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 11 *   NON INFRINGEMENT.  See the GNU General Public License for
 12 *   more details.
 13 */
 14
 15/* Adjust unistd.h to provide 32-bit numbers and functions. */
 16#define __SYSCALL_COMPAT
 17
 18#include <linux/compat.h>
 19#include <linux/syscalls.h>
 20#include <linux/kdev_t.h>
 21#include <linux/fs.h>
 22#include <linux/fcntl.h>
 23#include <linux/uaccess.h>
 24#include <linux/signal.h>
 25#include <asm/syscalls.h>
 
 26
 27/*
 28 * Syscalls that take 64-bit numbers traditionally take them in 32-bit
 29 * "high" and "low" value parts on 32-bit architectures.
 30 * In principle, one could imagine passing some register arguments as
 31 * fully 64-bit on TILE-Gx in 32-bit mode, but it seems easier to
 32 * adapt the usual convention.
 33 */
 34
 
 
 
 
 
 
 35COMPAT_SYSCALL_DEFINE4(truncate64, char __user *, filename, u32, dummy,
 36                       u32, low, u32, high)
 37{
 38	return sys_truncate(filename, ((loff_t)high << 32) | low);
 39}
 40
 41COMPAT_SYSCALL_DEFINE4(ftruncate64, unsigned int, fd, u32, dummy,
 42                       u32, low, u32, high)
 43{
 44	return sys_ftruncate(fd, ((loff_t)high << 32) | low);
 45}
 46
 47COMPAT_SYSCALL_DEFINE6(pread64, unsigned int, fd, char __user *, ubuf,
 48                       size_t, count, u32, dummy, u32, low, u32, high)
 49{
 50	return sys_pread64(fd, ubuf, count, ((loff_t)high << 32) | low);
 
 51}
 52
 53COMPAT_SYSCALL_DEFINE6(pwrite64, unsigned int, fd, char __user *, ubuf,
 54                       size_t, count, u32, dummy, u32, low, u32, high)
 55{
 56	return sys_pwrite64(fd, ubuf, count, ((loff_t)high << 32) | low);
 
 57}
 58
 59COMPAT_SYSCALL_DEFINE6(sync_file_range2, int, fd, unsigned int, flags,
 60                       u32, offset_lo, u32, offset_hi,
 61                       u32, nbytes_lo, u32, nbytes_hi)
 62{
 63	return sys_sync_file_range(fd, ((loff_t)offset_hi << 32) | offset_lo,
 64				   ((loff_t)nbytes_hi << 32) | nbytes_lo,
 65				   flags);
 66}
 67
 68COMPAT_SYSCALL_DEFINE6(fallocate, int, fd, int, mode,
 69                       u32, offset_lo, u32, offset_hi,
 70                       u32, len_lo, u32, len_hi)
 71{
 72	return sys_fallocate(fd, mode, ((loff_t)offset_hi << 32) | offset_lo,
 73			     ((loff_t)len_hi << 32) | len_lo);
 74}
 75
 76/*
 77 * Avoid bug in generic sys_llseek() that specifies offset_high and
 78 * offset_low as "unsigned long", thus making it possible to pass
 79 * a sign-extended high 32 bits in offset_low.
 
 
 80 */
 81COMPAT_SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned int, offset_high,
 82		       unsigned int, offset_low, loff_t __user *, result,
 83		       unsigned int, origin)
 84{
 85	return sys_llseek(fd, offset_high, offset_low, result, origin);
 86}
 87
 88/* Provide the compat syscall number to call mapping. */
 89#undef __SYSCALL
 90#define __SYSCALL(nr, call) [nr] = (call),
 91
 92/* See comments in sys.c */
 93#define compat_sys_fadvise64_64 sys32_fadvise64_64
 94#define compat_sys_readahead sys32_readahead
 95#define sys_llseek compat_sys_llseek
 96
 97/* Call the assembly trampolines where necessary. */
 98#define compat_sys_rt_sigreturn _compat_sys_rt_sigreturn
 99#define sys_clone _sys_clone
100
101/*
102 * Note that we can't include <linux/unistd.h> here since the header
103 * guard will defeat us; <asm/unistd.h> checks for __SYSCALL as well.
104 */
105void *compat_sys_call_table[__NR_syscalls] = {
106	[0 ... __NR_syscalls-1] = sys_ni_syscall,
107#include <asm/unistd.h>
108};