about summary refs log tree commit diff
path: root/sysdeps/unix/sysv/linux/tile/clone.S
blob: d7d2a3b9682059bb9fa12c1970a2598269d5de17 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
/* Copyright (C) 2011-2017 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Chris Metcalf <cmetcalf@tilera.com>, 2011.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library.  If not, see
   <http://www.gnu.org/licenses/>.  */

/* clone() is even more special than fork() as it mucks with stacks
   and invokes a function in the right context after it's all over.  */

#include <sysdep.h>
#define _ERRNO_H 1
#include <bits/errno.h>

#include <asm/unistd.h>
#include <arch/abi.h>
#include <tls.h>
#include <linux/sched.h>

/* What we save where in the stack frame; must include all callee-saves. */
#define FRAME_NEXT_LR   (0 * REGSIZE)  /* reserved by ABI; not used here */
#define FRAME_SP        (1 * REGSIZE)
#define FRAME_R30       (2 * REGSIZE)
#define FRAME_R31       (3 * REGSIZE)
#define FRAME_R32       (4 * REGSIZE)
#define FRAME_SIZE      (5 * REGSIZE)

/* int clone(int (*fn)(void *arg), void *child_stack, int flags, void *arg,
             pid_t *ptid, struct user_desc *tls, pid_t *ctid); */

	.text
ENTRY (__clone)
	/* Create a stack frame so we can pass callee-saves to new task. */
	{
	 move r10, sp
	 ST sp, lr
	 ADDI_PTR sp, sp, -FRAME_SIZE
	}
	cfi_offset (lr, 0)
	cfi_def_cfa_offset (FRAME_SIZE)
	ADDI_PTR r11, sp, FRAME_SP
	{
	 ST r11, r10
	 ADDI_PTR r11, sp, FRAME_R30
	}
	{
	 ST r11, r30
	 ADDI_PTR r11, sp, FRAME_R31
	}
	cfi_offset (r30, FRAME_R30 - FRAME_SIZE)
	{
	 ST r11, r31
	 ADDI_PTR r11, sp, FRAME_R32
	}
	cfi_offset (r31, FRAME_R31 - FRAME_SIZE)
	ST r11, r32
	cfi_offset (r32, FRAME_R32 - FRAME_SIZE)

	/* sanity check arguments */
	BEQZ r0, .Linvalid
	BEQZ r1, .Linvalid

	/* Make sure child stack is properly aligned, and set up the
	   top frame so that we can call out of it immediately in the
	   child.  Setting it up here means we fault in the parent if
	   it's bogus, which is probably cleaner than faulting first
	   thing in the child. */
	ADDI_PTR r1, r1, -C_ABI_SAVE_AREA_SIZE
	andi r1, r1, -C_ABI_SAVE_AREA_SIZE
	ADDI_PTR r9, r1, REGSIZE /* sp of this frame on entry, i.e. zero */
	ST r9, zero

	/* We need to switch the argument convention around from
	   libc to kernel:

	   libc:
	    r0 fn
	    r1 child_stack
	    r2 flags
	    r3 arg
	    r4 ptid
	    r5 tls
	    r6 ctid

	   kernel:
	    r0 flags
	    r1 child_stack [same as libc]
	    r2 ptid
	    r3 ctid
	    r4 tls

	   Plus the callee-saves as described at .Lthread_start, below.  */
	{
	 move r32, r0
	 move r0, r2
	}
	{
	 move r31, r3
	 move r3, r6
	}
	{
	 move r30, r2
	 move r2, r4
	}
	{
	 move r4, r5
	 moveli TREG_SYSCALL_NR_NAME, __NR_clone
	}
	swint1
	BEQZ r0, .Lthread_start  /* If in child task.  */

.Ldone:
	/* Restore the callee-saved registers and return. */
	ADDLI_PTR lr, sp, FRAME_SIZE
	{
	 LD lr, lr
	 ADDLI_PTR r30, sp, FRAME_R30
	}
	{
	 LD r30, r30
	 ADDLI_PTR r31, sp, FRAME_R31
	}
	{
	 LD r31, r31
	 ADDLI_PTR r32, sp, FRAME_R32
	}
	{
	 LD r32, r32
	 ADDI_PTR sp, sp, FRAME_SIZE
	}
	cfi_def_cfa_offset (0)

	BNEZ r1, .Lerror
	jrp lr

.Lerror:
	j SYSCALL_ERROR_NAME

.Linvalid:
	{
	 movei r1, EINVAL
	 j .Ldone
	}

/* This function expects to receive:

   sp: the top of a valid stack area
   r30: clone() flags
   r31: the argument to pass to the user function
   r32: the user function pointer  */

.Lthread_start:
	cfi_def_cfa_offset (FRAME_SIZE)
	cfi_undefined (lr)
	{
	 /* Invoke user function with specified argument. */
	 move r0, r31
	 jalr r32
	}
	{
	 j HIDDEN_JUMPTARGET(_exit)
	 info INFO_OP_CANNOT_BACKTRACE   /* Notify backtracer to stop. */
	}
PSEUDO_END (__clone)

libc_hidden_def (__clone)
weak_alias (__clone, clone)