arch/tile/kernel/compat.c

   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/msg.h>
  20 #include <linux/syscalls.h>
  21 #include <linux/kdev_t.h>
  22 #include <linux/fs.h>
  23 #include <linux/fcntl.h>
  24 #include <linux/smp_lock.h>
  25 #include <linux/uaccess.h>
  26 #include <linux/signal.h>
  27 #include <asm/syscalls.h>
  28
  29 /*
  30  * Syscalls that take 64-bit numbers traditionally take them in 32-bit
  31  * "high" and "low" value parts on 32-bit architectures.
  32  * In principle, one could imagine passing some register arguments as
  33  * fully 64-bit on TILE-Gx in 32-bit mode, but it seems easier to
  34  * adapt the usual convention.
  35  */
  36
  37 long compat_sys_truncate64(char __user *filename, u32 dummy, u32 low, u32 high)
  38 {
  39         return sys_truncate(filename, ((loff_t)high << 32) | low);
  40 }
  41
  42 long compat_sys_ftruncate64(unsigned int fd, u32 dummy, u32 low, u32 high)
  43 {
  44         return sys_ftruncate(fd, ((loff_t)high << 32) | low);
  45 }
  46
  47 long compat_sys_pread64(unsigned int fd, char __user *ubuf, size_t count,
  48                         u32 dummy, u32 low, u32 high)
  49 {
  50         return sys_pread64(fd, ubuf, count, ((loff_t)high << 32) | low);
  51 }
  52
  53 long compat_sys_pwrite64(unsigned int fd, char __user *ubuf, size_t count,
  54                          u32 dummy, u32 low, u32 high)
  55 {
  56         return sys_pwrite64(fd, ubuf, count, ((loff_t)high << 32) | low);
  57 }
  58
  59 long compat_sys_lookup_dcookie(u32 low, u32 high, char __user *buf, size_t len)
  60 {
  61         return sys_lookup_dcookie(((loff_t)high << 32) | low, buf, len);
  62 }
  63
  64 long compat_sys_sync_file_range2(int fd, unsigned int flags,
  65                                  u32 offset_lo, u32 offset_hi,
  66                                  u32 nbytes_lo, u32 nbytes_hi)
  67 {
  68         return sys_sync_file_range(fd, ((loff_t)offset_hi << 32) | offset_lo,
  69                                    ((loff_t)nbytes_hi << 32) | nbytes_lo,
  70                                    flags);
  71 }
  72
  73 long compat_sys_fallocate(int fd, int mode,
  74                           u32 offset_lo, u32 offset_hi,
  75                           u32 len_lo, u32 len_hi)
  76 {
  77         return sys_fallocate(fd, mode, ((loff_t)offset_hi << 32) | offset_lo,
  78                              ((loff_t)len_hi << 32) | len_lo);
  79 }
  80
  81
  82
  83 long compat_sys_sched_rr_get_interval(compat_pid_t pid,
  84                                       struct compat_timespec __user *interval)
  85 {
  86         struct timespec t;
  87         int ret;
  88         mm_segment_t old_fs = get_fs();
  89
  90         set_fs(KERNEL_DS);
  91         ret = sys_sched_rr_get_interval(pid,
  92                                         (struct timespec __force __user *)&t);
  93         set_fs(old_fs);
  94         if (put_compat_timespec(&t, interval))
  95                 return -EFAULT;
  96         return ret;
  97 }
  98
  99 /*
 100  * The usual compat_sys_msgsnd() and _msgrcv() seem to be assuming
 101  * some different calling convention than our normal 32-bit tile code.
 102  */
 103
 104 /* Already defined in ipc/compat.c, but we need it here. */
 105 struct compat_msgbuf {
 106         compat_long_t mtype;
 107         char mtext[1];
 108 };
 109
 110 long tile_compat_sys_msgsnd(int msqid,
 111                             struct compat_msgbuf __user *msgp,
 112                             size_t msgsz, int msgflg)
 113 {
 114         compat_long_t mtype;
 115
 116         if (get_user(mtype, &msgp->mtype))
 117                 return -EFAULT;
 118         return do_msgsnd(msqid, mtype, msgp->mtext, msgsz, msgflg);
 119 }
 120
 121 long tile_compat_sys_msgrcv(int msqid,
 122                             struct compat_msgbuf __user *msgp,
 123                             size_t msgsz, long msgtyp, int msgflg)
 124 {
 125         long err, mtype;
 126
 127         err =  do_msgrcv(msqid, &mtype, msgp->mtext, msgsz, msgtyp, msgflg);
 128         if (err < 0)
 129                 goto out;
 130
 131         if (put_user(mtype, &msgp->mtype))
 132                 err = -EFAULT;
 133  out:
 134         return err;
 135 }
 136
 137 /* Provide the compat syscall number to call mapping. */
 138 #undef __SYSCALL
 139 #define __SYSCALL(nr, call) [nr] = (compat_##call),
 140
 141 /* The generic versions of these don't work for Tile. */
 142 #define compat_sys_msgrcv tile_compat_sys_msgrcv
 143 #define compat_sys_msgsnd tile_compat_sys_msgsnd
 144
 145 /* See comments in sys.c */
 146 #define compat_sys_fadvise64 sys32_fadvise64
 147 #define compat_sys_fadvise64_64 sys32_fadvise64_64
 148 #define compat_sys_readahead sys32_readahead
 149 #define compat_sys_sync_file_range compat_sys_sync_file_range2
 150
 151 /* We leverage the "struct stat64" type for 32-bit time_t/nsec. */
 152 #define compat_sys_stat64 sys_stat64
 153 #define compat_sys_lstat64 sys_lstat64
 154 #define compat_sys_fstat64 sys_fstat64
 155 #define compat_sys_fstatat64 sys_fstatat64
 156
 157 /* The native sys_ptrace dynamically handles compat binaries. */
 158 #define compat_sys_ptrace sys_ptrace
 159
 160 /* Call the trampolines to manage pt_regs where necessary. */
 161 #define compat_sys_execve _compat_sys_execve
 162 #define compat_sys_sigaltstack _compat_sys_sigaltstack
 163 #define compat_sys_rt_sigreturn _compat_sys_rt_sigreturn
 164 #define sys_clone _sys_clone
 165
 166 /*
 167  * Note that we can't include <linux/unistd.h> here since the header
 168  * guard will defeat us; <asm/unistd.h> checks for __SYSCALL as well.
 169  */
 170 void *compat_sys_call_table[__NR_syscalls] = {
 171         [0 ... __NR_syscalls-1] = sys_ni_syscall,
 172 #include <asm/unistd.h>
 173 };