1/* 2 * linux/arch/arm/kernel/sys_arm.c 3 * 4 * Copyright (C) People who wrote linux/arch/i386/kernel/sys_i386.c 5 * Copyright (C) 1995, 1996 Russell King. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * This file contains various random system calls that 12 * have a non-standard calling sequence on the Linux/arm 13 * platform. 14 */ 15#include <linux/module.h> 16#include <linux/errno.h> 17#include <linux/sched.h> 18#include <linux/mm.h> 19#include <linux/sem.h> 20#include <linux/msg.h> 21#include <linux/shm.h> 22#include <linux/stat.h> 23#include <linux/syscalls.h> 24#include <linux/mman.h> 25#include <linux/fs.h> 26#include <linux/file.h> 27#include <linux/ipc.h> 28#include <linux/uaccess.h> 29#include <linux/slab.h> 30 31/* Fork a new task - this creates a new program thread. 32 * This is called indirectly via a small wrapper 33 */ 34asmlinkage int sys_fork(struct pt_regs *regs) 35{ 36#ifdef CONFIG_MMU 37 return do_fork(SIGCHLD, regs->ARM_sp, regs, 0, NULL, NULL); 38#else 39 /* can not support in nommu mode */ 40 return(-EINVAL); 41#endif 42} 43 44/* Clone a task - this clones the calling program thread. 45 * This is called indirectly via a small wrapper 46 */ 47asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp, 48 int __user *parent_tidptr, int tls_val, 49 int __user *child_tidptr, struct pt_regs *regs) 50{ 51 if (!newsp) 52 newsp = regs->ARM_sp; 53 54 return do_fork(clone_flags, newsp, regs, 0, parent_tidptr, child_tidptr); 55} 56 57asmlinkage int sys_vfork(struct pt_regs *regs) 58{ 59 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->ARM_sp, regs, 0, NULL, NULL); 60} 61 62/* sys_execve() executes a new program. 63 * This is called indirectly via a small wrapper 64 */ 65asmlinkage int sys_execve(const char __user *filenamei, 66 const char __user *const __user *argv, 67 const char __user *const __user *envp, struct pt_regs *regs) 68{ 69 int error; 70 char * filename; 71 72 filename = getname(filenamei); 73 error = PTR_ERR(filename); 74 if (IS_ERR(filename)) 75 goto out; 76 error = do_execve(filename, argv, envp, regs); 77 putname(filename); 78out: 79 return error; 80} 81 82int kernel_execve(const char *filename, 83 const char *const argv[], 84 const char *const envp[]) 85{ 86 struct pt_regs regs; 87 int ret; 88 89 memset(®s, 0, sizeof(struct pt_regs)); 90 ret = do_execve(filename, 91 (const char __user *const __user *)argv, 92 (const char __user *const __user *)envp, ®s); 93 if (ret < 0) 94 goto out; 95 96 /* 97 * Save argc to the register structure for userspace. 98 */ 99 regs.ARM_r0 = ret; 100 101 /* 102 * We were successful. We won't be returning to our caller, but 103 * instead to user space by manipulating the kernel stack. 104 */ 105 asm( "add r0, %0, %1\n\t" 106 "mov r1, %2\n\t" 107 "mov r2, %3\n\t" 108 "bl memmove\n\t" /* copy regs to top of stack */ 109 "mov r8, #0\n\t" /* not a syscall */ 110 "mov r9, %0\n\t" /* thread structure */ 111 "mov sp, r0\n\t" /* reposition stack pointer */ 112 "b ret_to_user" 113 : 114 : "r" (current_thread_info()), 115 "Ir" (THREAD_START_SP - sizeof(regs)), 116 "r" (®s), 117 "Ir" (sizeof(regs)) 118 : "r0", "r1", "r2", "r3", "ip", "lr", "memory"); 119 120 out: 121 return ret; 122} 123EXPORT_SYMBOL(kernel_execve); 124 125/* 126 * Since loff_t is a 64 bit type we avoid a lot of ABI hassle 127 * with a different argument ordering. 128 */ 129asmlinkage long sys_arm_fadvise64_64(int fd, int advice, 130 loff_t offset, loff_t len) 131{ 132 return sys_fadvise64_64(fd, offset, len, advice); 133} 134