arch/sparc/kernel/sys_sparc_32.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* linux/arch/sparc/kernel/sys_sparc.c
   3  *
   4  * This file contains various random system calls that
   5  * have a non-standard calling sequence on the Linux/sparc
   6  * platform.
   7  */
   8
   9 #include <linux/errno.h>
  10 #include <linux/types.h>
  11 #include <linux/sched/signal.h>
  12 #include <linux/sched/mm.h>
  13 #include <linux/sched/debug.h>
  14 #include <linux/mm.h>
  15 #include <linux/fs.h>
  16 #include <linux/file.h>
  17 #include <linux/sem.h>
  18 #include <linux/msg.h>
  19 #include <linux/shm.h>
  20 #include <linux/stat.h>
  21 #include <linux/syscalls.h>
  22 #include <linux/mman.h>
  23 #include <linux/utsname.h>
  24 #include <linux/smp.h>
  25 #include <linux/ipc.h>
  26 #include <linux/hugetlb.h>
  27
  28 #include <linux/uaccess.h>
  29 #include <asm/unistd.h>
  30
  31 #include "systbls.h"
  32
  33 /* #define DEBUG_UNIMP_SYSCALL */
  34
  35 /* XXX Make this per-binary type, this way we can detect the type of
  36  * XXX a binary.  Every Sparc executable calls this very early on.
  37  */
  38 SYSCALL_DEFINE0(getpagesize)
  39 {
  40         return PAGE_SIZE; /* Possibly older binaries want 8192 on sun4's? */
  41 }
  42
  43 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags, vm_flags_t vm_flags)
  44 {
  45         struct vm_unmapped_area_info info = {};
  46         bool file_hugepage = false;
  47
  48         if (filp && is_file_hugepages(filp))
  49                 file_hugepage = true;
  50
  51         if (flags & MAP_FIXED) {
  52                 /* We do not accept a shared mapping if it would violate
  53                  * cache aliasing constraints.
  54                  */
  55                 if (!file_hugepage && (flags & MAP_SHARED) &&
  56                     ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))
  57                         return -EINVAL;
  58                 return addr;
  59         }
  60
  61         /* See asm-sparc/uaccess.h */
  62         if (len > TASK_SIZE - PAGE_SIZE)
  63                 return -ENOMEM;
  64         if (!addr)
  65                 addr = TASK_UNMAPPED_BASE;
  66
  67         info.length = len;
  68         info.low_limit = addr;
  69         info.high_limit = TASK_SIZE;
  70         if (!file_hugepage) {
  71                 info.align_mask = (flags & MAP_SHARED) ?
  72                         (PAGE_MASK & (SHMLBA - 1)) : 0;
  73                 info.align_offset = pgoff << PAGE_SHIFT;
  74         } else {
  75                 info.align_mask = huge_page_mask_align(filp);
  76         }
  77         return vm_unmapped_area(&info);
  78 }
  79
  80 /*
  81  * sys_pipe() is the normal C calling standard for creating
  82  * a pipe. It's not the way unix traditionally does this, though.
  83  */
  84 SYSCALL_DEFINE0(sparc_pipe)
  85 {
  86         int fd[2];
  87         int error;
  88
  89         error = do_pipe_flags(fd, 0);
  90         if (error)
  91                 goto out;
  92         current_pt_regs()->u_regs[UREG_I1] = fd[1];
  93         error = fd[0];
  94 out:
  95         return error;
  96 }
  97
  98 int sparc_mmap_check(unsigned long addr, unsigned long len)
  99 {
 100         /* See asm-sparc/uaccess.h */
 101         if (len > TASK_SIZE - PAGE_SIZE || addr + len > TASK_SIZE - PAGE_SIZE)
 102                 return -EINVAL;
 103
 104         return 0;
 105 }
 106
 107 /* Linux version of mmap */
 108
 109 SYSCALL_DEFINE6(mmap2, unsigned long, addr, unsigned long, len,
 110         unsigned long, prot, unsigned long, flags, unsigned long, fd,
 111         unsigned long, pgoff)
 112 {
 113         /* Make sure the shift for mmap2 is constant (12), no matter what PAGE_SIZE
 114            we have. */
 115         return ksys_mmap_pgoff(addr, len, prot, flags, fd,
 116                                pgoff >> (PAGE_SHIFT - 12));
 117 }
 118
 119 SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
 120         unsigned long, prot, unsigned long, flags, unsigned long, fd,
 121         unsigned long, off)
 122 {
 123         /* no alignment check? */
 124         return ksys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
 125 }
 126
 127 SYSCALL_DEFINE5(sparc_remap_file_pages, unsigned long, start, unsigned long, size,
 128                            unsigned long, prot, unsigned long, pgoff,
 129                            unsigned long, flags)
 130 {
 131         /* This works on an existing mmap so we don't need to validate
 132          * the range as that was done at the original mmap call.
 133          */
 134         return sys_remap_file_pages(start, size, prot,
 135                                     (pgoff >> (PAGE_SHIFT - 12)), flags);
 136 }
 137
 138 SYSCALL_DEFINE0(nis_syscall)
 139 {
 140         static int count = 0;
 141         struct pt_regs *regs = current_pt_regs();
 142
 143         if (count++ > 5)
 144                 return -ENOSYS;
 145         printk ("%s[%d]: Unimplemented SPARC system call %d\n",
 146                 current->comm, task_pid_nr(current), (int)regs->u_regs[1]);
 147 #ifdef DEBUG_UNIMP_SYSCALL
 148         show_regs (regs);
 149 #endif
 150         return -ENOSYS;
 151 }
 152
 153 /* #define DEBUG_SPARC_BREAKPOINT */
 154
 155 asmlinkage void
 156 sparc_breakpoint (struct pt_regs *regs)
 157 {
 158
 159 #ifdef DEBUG_SPARC_BREAKPOINT
 160         printk ("TRAP: Entering kernel PC=%x, nPC=%x\n", regs->pc, regs->npc);
 161 #endif
 162         force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->pc);
 163
 164 #ifdef DEBUG_SPARC_BREAKPOINT
 165         printk ("TRAP: Returning to space: PC=%x nPC=%x\n", regs->pc, regs->npc);
 166 #endif
 167 }
 168
 169 SYSCALL_DEFINE3(sparc_sigaction, int, sig,
 170                 struct old_sigaction __user *,act,
 171                 struct old_sigaction __user *,oact)
 172 {
 173         WARN_ON_ONCE(sig >= 0);
 174         return sys_sigaction(-sig, act, oact);
 175 }
 176
 177 SYSCALL_DEFINE5(rt_sigaction, int, sig,
 178                  const struct sigaction __user *, act,
 179                  struct sigaction __user *, oact,
 180                  void __user *, restorer,
 181                  size_t, sigsetsize)
 182 {
 183         struct k_sigaction new_ka, old_ka;
 184         int ret;
 185
 186         /* XXX: Don't preclude handling different sized sigset_t's.  */
 187         if (sigsetsize != sizeof(sigset_t))
 188                 return -EINVAL;
 189
 190         if (act) {
 191                 new_ka.ka_restorer = restorer;
 192                 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
 193                         return -EFAULT;
 194         }
 195
 196         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 197
 198         if (!ret && oact) {
 199                 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
 200                         return -EFAULT;
 201         }
 202
 203         return ret;
 204 }
 205
 206 SYSCALL_DEFINE2(getdomainname, char __user *, name, int, len)
 207 {
 208         int nlen, err;
 209         char tmp[__NEW_UTS_LEN + 1];
 210
 211         if (len < 0)
 212                 return -EINVAL;
 213
 214         down_read(&uts_sem);
 215
 216         nlen = strlen(utsname()->domainname) + 1;
 217         err = -EINVAL;
 218         if (nlen > len)
 219                 goto out_unlock;
 220         memcpy(tmp, utsname()->domainname, nlen);
 221
 222         up_read(&uts_sem);
 223
 224         if (copy_to_user(name, tmp, nlen))
 225                 return -EFAULT;
 226         return 0;
 227
 228 out_unlock:
 229         up_read(&uts_sem);
 230         return err;
 231 }