arch/sparc/kernel/sys_sparc32.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* sys_sparc32.c: Conversion between 32bit and 64bit native syscalls.
   3  *
   4  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   5  * Copyright (C) 1997, 2007 David S. Miller (davem@davemloft.net)
   6  *
   7  * These routines maintain argument size conversion between 32bit and 64bit
   8  * environment.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/sched.h>
  13 #include <linux/capability.h>
  14 #include <linux/fs.h>
  15 #include <linux/mm.h>
  16 #include <linux/file.h>
  17 #include <linux/signal.h>
  18 #include <linux/resource.h>
  19 #include <linux/times.h>
  20 #include <linux/smp.h>
  21 #include <linux/sem.h>
  22 #include <linux/msg.h>
  23 #include <linux/shm.h>
  24 #include <linux/uio.h>
  25 #include <linux/nfs_fs.h>
  26 #include <linux/quota.h>
  27 #include <linux/poll.h>
  28 #include <linux/personality.h>
  29 #include <linux/stat.h>
  30 #include <linux/filter.h>
  31 #include <linux/highmem.h>
  32 #include <linux/highuid.h>
  33 #include <linux/mman.h>
  34 #include <linux/ipv6.h>
  35 #include <linux/in.h>
  36 #include <linux/icmpv6.h>
  37 #include <linux/syscalls.h>
  38 #include <linux/sysctl.h>
  39 #include <linux/binfmts.h>
  40 #include <linux/dnotify.h>
  41 #include <linux/security.h>
  42 #include <linux/compat.h>
  43 #include <linux/vfs.h>
  44 #include <linux/ptrace.h>
  45 #include <linux/slab.h>
  46
  47 #include <asm/types.h>
  48 #include <linux/uaccess.h>
  49 #include <asm/fpumacro.h>
  50 #include <asm/mmu_context.h>
  51 #include <asm/compat_signal.h>
  52
  53 #include "systbls.h"
  54
  55 COMPAT_SYSCALL_DEFINE3(truncate64, const char __user *, path, u32, high, u32, low)
  56 {
  57         return ksys_truncate(path, ((u64)high << 32) | low);
  58 }
  59
  60 COMPAT_SYSCALL_DEFINE3(ftruncate64, unsigned int, fd, u32, high, u32, low)
  61 {
  62         return ksys_ftruncate(fd, ((u64)high << 32) | low);
  63 }
  64
  65 static int cp_compat_stat64(struct kstat *stat,
  66                             struct compat_stat64 __user *statbuf)
  67 {
  68         int err;
  69
  70         err  = put_user(huge_encode_dev(stat->dev), &statbuf->st_dev);
  71         err |= put_user(stat->ino, &statbuf->st_ino);
  72         err |= put_user(stat->mode, &statbuf->st_mode);
  73         err |= put_user(stat->nlink, &statbuf->st_nlink);
  74         err |= put_user(from_kuid_munged(current_user_ns(), stat->uid), &statbuf->st_uid);
  75         err |= put_user(from_kgid_munged(current_user_ns(), stat->gid), &statbuf->st_gid);
  76         err |= put_user(huge_encode_dev(stat->rdev), &statbuf->st_rdev);
  77         err |= put_user(0, (unsigned long __user *) &statbuf->__pad3[0]);
  78         err |= put_user(stat->size, &statbuf->st_size);
  79         err |= put_user(stat->blksize, &statbuf->st_blksize);
  80         err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[0]);
  81         err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[4]);
  82         err |= put_user(stat->blocks, &statbuf->st_blocks);
  83         err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
  84         err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
  85         err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
  86         err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
  87         err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
  88         err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
  89         err |= put_user(0, &statbuf->__unused4);
  90         err |= put_user(0, &statbuf->__unused5);
  91
  92         return err;
  93 }
  94
  95 COMPAT_SYSCALL_DEFINE2(stat64, const char __user *, filename,
  96                 struct compat_stat64 __user *, statbuf)
  97 {
  98         struct kstat stat;
  99         int error = vfs_stat(filename, &stat);
 100
 101         if (!error)
 102                 error = cp_compat_stat64(&stat, statbuf);
 103         return error;
 104 }
 105
 106 COMPAT_SYSCALL_DEFINE2(lstat64, const char __user *, filename,
 107                 struct compat_stat64 __user *, statbuf)
 108 {
 109         struct kstat stat;
 110         int error = vfs_lstat(filename, &stat);
 111
 112         if (!error)
 113                 error = cp_compat_stat64(&stat, statbuf);
 114         return error;
 115 }
 116
 117 COMPAT_SYSCALL_DEFINE2(fstat64, unsigned int, fd,
 118                 struct compat_stat64 __user *, statbuf)
 119 {
 120         struct kstat stat;
 121         int error = vfs_fstat(fd, &stat);
 122
 123         if (!error)
 124                 error = cp_compat_stat64(&stat, statbuf);
 125         return error;
 126 }
 127
 128 COMPAT_SYSCALL_DEFINE4(fstatat64, unsigned int, dfd,
 129                 const char __user *, filename,
 130                 struct compat_stat64 __user *, statbuf, int, flag)
 131 {
 132         struct kstat stat;
 133         int error;
 134
 135         error = vfs_fstatat(dfd, filename, &stat, flag);
 136         if (error)
 137                 return error;
 138         return cp_compat_stat64(&stat, statbuf);
 139 }
 140
 141 COMPAT_SYSCALL_DEFINE3(sparc_sigaction, int, sig,
 142                         struct compat_old_sigaction __user *,act,
 143                         struct compat_old_sigaction __user *,oact)
 144 {
 145         WARN_ON_ONCE(sig >= 0);
 146         return compat_sys_sigaction(-sig, act, oact);
 147 }
 148
 149 COMPAT_SYSCALL_DEFINE5(rt_sigaction, int, sig,
 150                         struct compat_sigaction __user *,act,
 151                         struct compat_sigaction __user *,oact,
 152                         void __user *,restorer,
 153                         compat_size_t,sigsetsize)
 154 {
 155         struct k_sigaction new_ka, old_ka;
 156         int ret;
 157
 158         /* XXX: Don't preclude handling different sized sigset_t's.  */
 159         if (sigsetsize != sizeof(compat_sigset_t))
 160                 return -EINVAL;
 161
 162         if (act) {
 163                 u32 u_handler, u_restorer;
 164
 165                 new_ka.ka_restorer = restorer;
 166                 ret = get_user(u_handler, &act->sa_handler);
 167                 new_ka.sa.sa_handler =  compat_ptr(u_handler);
 168                 ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
 169                 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
 170                 ret |= get_user(u_restorer, &act->sa_restorer);
 171                 new_ka.sa.sa_restorer = compat_ptr(u_restorer);
 172                 if (ret)
 173                         return -EFAULT;
 174         }
 175
 176         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 177
 178         if (!ret && oact) {
 179                 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
 180                 ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
 181                                          sizeof(oact->sa_mask));
 182                 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 183                 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
 184                 if (ret)
 185                         ret = -EFAULT;
 186         }
 187
 188         return ret;
 189 }
 190
 191 COMPAT_SYSCALL_DEFINE5(pread64, unsigned int, fd, char __user *, ubuf,
 192                         compat_size_t, count, u32, poshi, u32, poslo)
 193 {
 194         return ksys_pread64(fd, ubuf, count, ((u64)poshi << 32) | poslo);
 195 }
 196
 197 COMPAT_SYSCALL_DEFINE5(pwrite64, unsigned int, fd, char __user *, ubuf,
 198                         compat_size_t, count, u32, poshi, u32, poslo)
 199 {
 200         return ksys_pwrite64(fd, ubuf, count, ((u64)poshi << 32) | poslo);
 201 }
 202
 203 COMPAT_SYSCALL_DEFINE4(readahead, int, fd, u32, offhi, u32, offlo,
 204                      compat_size_t, count)
 205 {
 206         return ksys_readahead(fd, ((u64)offhi << 32) | offlo, count);
 207 }
 208
 209 COMPAT_SYSCALL_DEFINE5(fadvise64, int, fd, u32, offhi, u32, offlo,
 210                           compat_size_t, len, int, advice)
 211 {
 212         return ksys_fadvise64_64(fd, ((u64)offhi << 32) | offlo, len, advice);
 213 }
 214
 215 COMPAT_SYSCALL_DEFINE6(fadvise64_64, int, fd, u32, offhi, u32, offlo,
 216                              u32, lenhi, u32, lenlo, int, advice)
 217 {
 218         return ksys_fadvise64_64(fd,
 219                                  ((u64)offhi << 32) | offlo,
 220                                  ((u64)lenhi << 32) | lenlo,
 221                                  advice);
 222 }
 223
 224 COMPAT_SYSCALL_DEFINE6(sync_file_range, unsigned int, fd, u32, off_high, u32, off_low,
 225                         u32, nb_high, u32, nb_low, unsigned int, flags)
 226 {
 227         return ksys_sync_file_range(fd,
 228                                     ((u64)off_high << 32) | off_low,
 229                                     ((u64)nb_high << 32) | nb_low,
 230                                     flags);
 231 }
 232
 233 COMPAT_SYSCALL_DEFINE6(fallocate, int, fd, int, mode, u32, offhi, u32, offlo,
 234                                      u32, lenhi, u32, lenlo)
 235 {
 236         return ksys_fallocate(fd, mode, ((loff_t)offhi << 32) | offlo,
 237                               ((loff_t)lenhi << 32) | lenlo);
 238 }