1/*
2 * arch/alpha/kernel/entry.S
3 *
4 * Kernel entry-points.
5 */
6
7#include <asm/asm-offsets.h>
8#include <asm/thread_info.h>
9#include <asm/pal.h>
10#include <asm/errno.h>
11#include <asm/unistd.h>
12
13	.text
14	.set noat
15
16/* Stack offsets.  */
17#define SP_OFF			184
18#define SWITCH_STACK_SIZE	320
19
20/*
21 * This defines the normal kernel pt-regs layout.
22 *
23 * regs 9-15 preserved by C code
24 * regs 16-18 saved by PAL-code
25 * regs 29-30 saved and set up by PAL-code
26 * JRP - Save regs 16-18 in a special area of the stack, so that
27 * the palcode-provided values are available to the signal handler.
28 */
29
30#define SAVE_ALL			\
31	subq	$sp, SP_OFF, $sp;	\
32	stq	$0, 0($sp);		\
33	stq	$1, 8($sp);		\
34	stq	$2, 16($sp);		\
35	stq	$3, 24($sp);		\
36	stq	$4, 32($sp);		\
37	stq	$28, 144($sp);		\
38	lda	$2, alpha_mv;		\
39	stq	$5, 40($sp);		\
40	stq	$6, 48($sp);		\
41	stq	$7, 56($sp);		\
42	stq	$8, 64($sp);		\
43	stq	$19, 72($sp);		\
44	stq	$20, 80($sp);		\
45	stq	$21, 88($sp);		\
46	ldq	$2, HAE_CACHE($2);	\
47	stq	$22, 96($sp);		\
48	stq	$23, 104($sp);		\
49	stq	$24, 112($sp);		\
50	stq	$25, 120($sp);		\
51	stq	$26, 128($sp);		\
52	stq	$27, 136($sp);		\
53	stq	$2, 152($sp);		\
54	stq	$16, 160($sp);		\
55	stq	$17, 168($sp);		\
56	stq	$18, 176($sp)
57
58#define RESTORE_ALL			\
59	lda	$19, alpha_mv;		\
60	ldq	$0, 0($sp);		\
61	ldq	$1, 8($sp);		\
62	ldq	$2, 16($sp);		\
63	ldq	$3, 24($sp);		\
64	ldq	$21, 152($sp);		\
65	ldq	$20, HAE_CACHE($19);	\
66	ldq	$4, 32($sp);		\
67	ldq	$5, 40($sp);		\
68	ldq	$6, 48($sp);		\
69	ldq	$7, 56($sp);		\
70	subq	$20, $21, $20;		\
71	ldq	$8, 64($sp);		\
72	beq	$20, 99f;		\
73	ldq	$20, HAE_REG($19);	\
74	stq	$21, HAE_CACHE($19);	\
75	stq	$21, 0($20);		\
7699:;					\
77	ldq	$19, 72($sp);		\
78	ldq	$20, 80($sp);		\
79	ldq	$21, 88($sp);		\
80	ldq	$22, 96($sp);		\
81	ldq	$23, 104($sp);		\
82	ldq	$24, 112($sp);		\
83	ldq	$25, 120($sp);		\
84	ldq	$26, 128($sp);		\
85	ldq	$27, 136($sp);		\
86	ldq	$28, 144($sp);		\
87	addq	$sp, SP_OFF, $sp
88
89/*
90 * Non-syscall kernel entry points.
91 */
92
93	.align	4
94	.globl	entInt
95	.ent	entInt
96entInt:
97	SAVE_ALL
98	lda	$8, 0x3fff
99	lda	$26, ret_from_sys_call
100	bic	$sp, $8, $8
101	mov	$sp, $19
102	jsr	$31, do_entInt
103.end entInt
104
105	.align	4
106	.globl	entArith
107	.ent	entArith
108entArith:
109	SAVE_ALL
110	lda	$8, 0x3fff
111	lda	$26, ret_from_sys_call
112	bic	$sp, $8, $8
113	mov	$sp, $18
114	jsr	$31, do_entArith
115.end entArith
116
117	.align	4
118	.globl	entMM
119	.ent	entMM
120entMM:
121	SAVE_ALL
122/* save $9 - $15 so the inline exception code can manipulate them.  */
123	subq	$sp, 56, $sp
124	stq	$9, 0($sp)
125	stq	$10, 8($sp)
126	stq	$11, 16($sp)
127	stq	$12, 24($sp)
128	stq	$13, 32($sp)
129	stq	$14, 40($sp)
130	stq	$15, 48($sp)
131	addq	$sp, 56, $19
132/* handle the fault */
133	lda	$8, 0x3fff
134	bic	$sp, $8, $8
135	jsr	$26, do_page_fault
136/* reload the registers after the exception code played.  */
137	ldq	$9, 0($sp)
138	ldq	$10, 8($sp)
139	ldq	$11, 16($sp)
140	ldq	$12, 24($sp)
141	ldq	$13, 32($sp)
142	ldq	$14, 40($sp)
143	ldq	$15, 48($sp)
144	addq	$sp, 56, $sp
145/* finish up the syscall as normal.  */
146	br	ret_from_sys_call
147.end entMM
148
149	.align	4
150	.globl	entIF
151	.ent	entIF
152entIF:
153	SAVE_ALL
154	lda	$8, 0x3fff
155	lda	$26, ret_from_sys_call
156	bic	$sp, $8, $8
157	mov	$sp, $17
158	jsr	$31, do_entIF
159.end entIF
160
161	.align	4
162	.globl	entUna
163	.ent	entUna
164entUna:
165	lda	$sp, -256($sp)
166	stq	$0, 0($sp)
167	ldq	$0, 256($sp)	/* get PS */
168	stq	$1, 8($sp)
169	stq	$2, 16($sp)
170	stq	$3, 24($sp)
171	and	$0, 8, $0		/* user mode? */
172	stq	$4, 32($sp)
173	bne	$0, entUnaUser	/* yup -> do user-level unaligned fault */
174	stq	$5, 40($sp)
175	stq	$6, 48($sp)
176	stq	$7, 56($sp)
177	stq	$8, 64($sp)
178	stq	$9, 72($sp)
179	stq	$10, 80($sp)
180	stq	$11, 88($sp)
181	stq	$12, 96($sp)
182	stq	$13, 104($sp)
183	stq	$14, 112($sp)
184	stq	$15, 120($sp)
185	/* 16-18 PAL-saved */
186	stq	$19, 152($sp)
187	stq	$20, 160($sp)
188	stq	$21, 168($sp)
189	stq	$22, 176($sp)
190	stq	$23, 184($sp)
191	stq	$24, 192($sp)
192	stq	$25, 200($sp)
193	stq	$26, 208($sp)
194	stq	$27, 216($sp)
195	stq	$28, 224($sp)
196	mov	$sp, $19
197	stq	$gp, 232($sp)
198	lda	$8, 0x3fff
199	stq	$31, 248($sp)
200	bic	$sp, $8, $8
201	jsr	$26, do_entUna
202	ldq	$0, 0($sp)
203	ldq	$1, 8($sp)
204	ldq	$2, 16($sp)
205	ldq	$3, 24($sp)
206	ldq	$4, 32($sp)
207	ldq	$5, 40($sp)
208	ldq	$6, 48($sp)
209	ldq	$7, 56($sp)
210	ldq	$8, 64($sp)
211	ldq	$9, 72($sp)
212	ldq	$10, 80($sp)
213	ldq	$11, 88($sp)
214	ldq	$12, 96($sp)
215	ldq	$13, 104($sp)
216	ldq	$14, 112($sp)
217	ldq	$15, 120($sp)
218	/* 16-18 PAL-saved */
219	ldq	$19, 152($sp)
220	ldq	$20, 160($sp)
221	ldq	$21, 168($sp)
222	ldq	$22, 176($sp)
223	ldq	$23, 184($sp)
224	ldq	$24, 192($sp)
225	ldq	$25, 200($sp)
226	ldq	$26, 208($sp)
227	ldq	$27, 216($sp)
228	ldq	$28, 224($sp)
229	ldq	$gp, 232($sp)
230	lda	$sp, 256($sp)
231	call_pal PAL_rti
232.end entUna
233
234	.align	4
235	.ent	entUnaUser
236entUnaUser:
237	ldq	$0, 0($sp)	/* restore original $0 */
238	lda	$sp, 256($sp)	/* pop entUna's stack frame */
239	SAVE_ALL		/* setup normal kernel stack */
240	lda	$sp, -56($sp)
241	stq	$9, 0($sp)
242	stq	$10, 8($sp)
243	stq	$11, 16($sp)
244	stq	$12, 24($sp)
245	stq	$13, 32($sp)
246	stq	$14, 40($sp)
247	stq	$15, 48($sp)
248	lda	$8, 0x3fff
249	addq	$sp, 56, $19
250	bic	$sp, $8, $8
251	jsr	$26, do_entUnaUser
252	ldq	$9, 0($sp)
253	ldq	$10, 8($sp)
254	ldq	$11, 16($sp)
255	ldq	$12, 24($sp)
256	ldq	$13, 32($sp)
257	ldq	$14, 40($sp)
258	ldq	$15, 48($sp)
259	lda	$sp, 56($sp)
260	br	ret_from_sys_call
261.end entUnaUser
262
263	.align	4
264	.globl	entDbg
265	.ent	entDbg
266entDbg:
267	SAVE_ALL
268	lda	$8, 0x3fff
269	lda	$26, ret_from_sys_call
270	bic	$sp, $8, $8
271	mov	$sp, $16
272	jsr	$31, do_entDbg
273.end entDbg
274
275/*
276 * The system call entry point is special.  Most importantly, it looks
277 * like a function call to userspace as far as clobbered registers.  We
278 * do preserve the argument registers (for syscall restarts) and $26
279 * (for leaf syscall functions).
280 *
281 * So much for theory.  We don't take advantage of this yet.
282 *
283 * Note that a0-a2 are not saved by PALcode as with the other entry points.
284 */
285
286	.align	4
287	.globl	entSys
288	.globl	ret_from_sys_call
289	.ent	entSys
290entSys:
291	SAVE_ALL
292	lda	$8, 0x3fff
293	bic	$sp, $8, $8
294	lda	$4, NR_SYSCALLS($31)
295	stq	$16, SP_OFF+24($sp)
296	lda	$5, sys_call_table
297	lda	$27, sys_ni_syscall
298	cmpult	$0, $4, $4
299	ldl	$3, TI_FLAGS($8)
300	stq	$17, SP_OFF+32($sp)
301	s8addq	$0, $5, $5
302	stq	$18, SP_OFF+40($sp)
303	blbs	$3, strace
304	beq	$4, 1f
305	ldq	$27, 0($5)
3061:	jsr	$26, ($27), alpha_ni_syscall
307	ldgp	$gp, 0($26)
308	blt	$0, $syscall_error	/* the call failed */
309	stq	$0, 0($sp)
310	stq	$31, 72($sp)		/* a3=0 => no error */
311
312	.align	4
313ret_from_sys_call:
314	cmovne	$26, 0, $19		/* $19 = 0 => non-restartable */
315	ldq	$0, SP_OFF($sp)
316	and	$0, 8, $0
317	beq	$0, ret_to_kernel
318ret_to_user:
319	/* Make sure need_resched and sigpending don't change between
320		sampling and the rti.  */
321	lda	$16, 7
322	call_pal PAL_swpipl
323	ldl	$5, TI_FLAGS($8)
324	and	$5, _TIF_WORK_MASK, $2
325	bne	$2, work_pending
326restore_all:
327	RESTORE_ALL
328	call_pal PAL_rti
329
330ret_to_kernel:
331	lda	$16, 7
332	call_pal PAL_swpipl
333	br restore_all
334
335	.align 3
336$syscall_error:
337	/*
338	 * Some system calls (e.g., ptrace) can return arbitrary
339	 * values which might normally be mistaken as error numbers.
340	 * Those functions must zero $0 (v0) directly in the stack
341	 * frame to indicate that a negative return value wasn't an
342	 * error number..
343	 */
344	ldq	$19, 0($sp)	/* old syscall nr (zero if success) */
345	beq	$19, $ret_success
346
347	ldq	$20, 72($sp)	/* .. and this a3 */
348	subq	$31, $0, $0	/* with error in v0 */
349	addq	$31, 1, $1	/* set a3 for errno return */
350	stq	$0, 0($sp)
351	mov	$31, $26	/* tell "ret_from_sys_call" we can restart */
352	stq	$1, 72($sp)	/* a3 for return */
353	br	ret_from_sys_call
354
355$ret_success:
356	stq	$0, 0($sp)
357	stq	$31, 72($sp)	/* a3=0 => no error */
358	br	ret_from_sys_call
359.end entSys
360
361/*
362 * Do all cleanup when returning from all interrupts and system calls.
363 *
364 * Arguments:
365 *       $5: TI_FLAGS.
366 *       $8: current.
367 *      $19: The old syscall number, or zero if this is not a return
368 *           from a syscall that errored and is possibly restartable.
369 *      $20: The old a3 value
370 */
371
372	.align	4
373	.ent	work_pending
374work_pending:
375	and	$5, _TIF_NEED_RESCHED, $2
376	beq	$2, $work_notifysig
377
378$work_resched:
379	subq	$sp, 16, $sp
380	stq	$19, 0($sp)              /* save syscall nr */
381	stq	$20, 8($sp)              /* and error indication (a3) */
382	jsr	$26, schedule
383	ldq	$19, 0($sp)
384	ldq	$20, 8($sp)
385	addq	$sp, 16, $sp
386	/* Make sure need_resched and sigpending don't change between
387		sampling and the rti.  */
388	lda	$16, 7
389	call_pal PAL_swpipl
390	ldl	$5, TI_FLAGS($8)
391	and	$5, _TIF_WORK_MASK, $2
392	beq	$2, restore_all
393	and	$5, _TIF_NEED_RESCHED, $2
394	bne	$2, $work_resched
395
396$work_notifysig:
397	mov	$sp, $16
398	bsr	$1, do_switch_stack
399	mov	$sp, $17
400	mov	$5, $18
401	mov	$19, $9		/* save old syscall number */
402	mov	$20, $10	/* save old a3 */
403	and	$5, _TIF_SIGPENDING, $2
404	cmovne	$2, 0, $9	/* we don't want double syscall restarts */
405	jsr	$26, do_notify_resume
406	mov	$9, $19
407	mov	$10, $20
408	bsr	$1, undo_switch_stack
409	br	ret_to_user
410.end work_pending
411
412/*
413 * PTRACE syscall handler
414 */
415
416	.align	4
417	.ent	strace
418strace:
419	/* set up signal stack, call syscall_trace */
420	bsr	$1, do_switch_stack
421	jsr	$26, syscall_trace
422	bsr	$1, undo_switch_stack
423
424	/* get the system call number and the arguments back.. */
425	ldq	$0, 0($sp)
426	ldq	$16, SP_OFF+24($sp)
427	ldq	$17, SP_OFF+32($sp)
428	ldq	$18, SP_OFF+40($sp)
429	ldq	$19, 72($sp)
430	ldq	$20, 80($sp)
431	ldq	$21, 88($sp)
432
433	/* get the system call pointer.. */
434	lda	$1, NR_SYSCALLS($31)
435	lda	$2, sys_call_table
436	lda	$27, alpha_ni_syscall
437	cmpult	$0, $1, $1
438	s8addq	$0, $2, $2
439	beq	$1, 1f
440	ldq	$27, 0($2)
4411:	jsr	$26, ($27), sys_gettimeofday
442ret_from_straced:
443	ldgp	$gp, 0($26)
444
445	/* check return.. */
446	blt	$0, $strace_error	/* the call failed */
447	stq	$31, 72($sp)		/* a3=0 => no error */
448$strace_success:
449	stq	$0, 0($sp)		/* save return value */
450
451	bsr	$1, do_switch_stack
452	jsr	$26, syscall_trace
453	bsr	$1, undo_switch_stack
454	br	$31, ret_from_sys_call
455
456	.align	3
457$strace_error:
458	ldq	$19, 0($sp)	/* old syscall nr (zero if success) */
459	beq	$19, $strace_success
460	ldq	$20, 72($sp)	/* .. and this a3 */
461
462	subq	$31, $0, $0	/* with error in v0 */
463	addq	$31, 1, $1	/* set a3 for errno return */
464	stq	$0, 0($sp)
465	stq	$1, 72($sp)	/* a3 for return */
466
467	bsr	$1, do_switch_stack
468	mov	$19, $9		/* save old syscall number */
469	mov	$20, $10	/* save old a3 */
470	jsr	$26, syscall_trace
471	mov	$9, $19
472	mov	$10, $20
473	bsr	$1, undo_switch_stack
474
475	mov	$31, $26	/* tell "ret_from_sys_call" we can restart */
476	br	ret_from_sys_call
477.end strace
478
479/*
480 * Save and restore the switch stack -- aka the balance of the user context.
481 */
482
483	.align	4
484	.ent	do_switch_stack
485do_switch_stack:
486	lda	$sp, -SWITCH_STACK_SIZE($sp)
487	stq	$9, 0($sp)
488	stq	$10, 8($sp)
489	stq	$11, 16($sp)
490	stq	$12, 24($sp)
491	stq	$13, 32($sp)
492	stq	$14, 40($sp)
493	stq	$15, 48($sp)
494	stq	$26, 56($sp)
495	stt	$f0, 64($sp)
496	stt	$f1, 72($sp)
497	stt	$f2, 80($sp)
498	stt	$f3, 88($sp)
499	stt	$f4, 96($sp)
500	stt	$f5, 104($sp)
501	stt	$f6, 112($sp)
502	stt	$f7, 120($sp)
503	stt	$f8, 128($sp)
504	stt	$f9, 136($sp)
505	stt	$f10, 144($sp)
506	stt	$f11, 152($sp)
507	stt	$f12, 160($sp)
508	stt	$f13, 168($sp)
509	stt	$f14, 176($sp)
510	stt	$f15, 184($sp)
511	stt	$f16, 192($sp)
512	stt	$f17, 200($sp)
513	stt	$f18, 208($sp)
514	stt	$f19, 216($sp)
515	stt	$f20, 224($sp)
516	stt	$f21, 232($sp)
517	stt	$f22, 240($sp)
518	stt	$f23, 248($sp)
519	stt	$f24, 256($sp)
520	stt	$f25, 264($sp)
521	stt	$f26, 272($sp)
522	stt	$f27, 280($sp)
523	mf_fpcr	$f0		# get fpcr
524	stt	$f28, 288($sp)
525	stt	$f29, 296($sp)
526	stt	$f30, 304($sp)
527	stt	$f0, 312($sp)	# save fpcr in slot of $f31
528	ldt	$f0, 64($sp)	# dont let "do_switch_stack" change fp state.
529	ret	$31, ($1), 1
530.end do_switch_stack
531
532	.align	4
533	.ent	undo_switch_stack
534undo_switch_stack:
535	ldq	$9, 0($sp)
536	ldq	$10, 8($sp)
537	ldq	$11, 16($sp)
538	ldq	$12, 24($sp)
539	ldq	$13, 32($sp)
540	ldq	$14, 40($sp)
541	ldq	$15, 48($sp)
542	ldq	$26, 56($sp)
543	ldt	$f30, 312($sp)	# get saved fpcr
544	ldt	$f0, 64($sp)
545	ldt	$f1, 72($sp)
546	ldt	$f2, 80($sp)
547	ldt	$f3, 88($sp)
548	mt_fpcr	$f30		# install saved fpcr
549	ldt	$f4, 96($sp)
550	ldt	$f5, 104($sp)
551	ldt	$f6, 112($sp)
552	ldt	$f7, 120($sp)
553	ldt	$f8, 128($sp)
554	ldt	$f9, 136($sp)
555	ldt	$f10, 144($sp)
556	ldt	$f11, 152($sp)
557	ldt	$f12, 160($sp)
558	ldt	$f13, 168($sp)
559	ldt	$f14, 176($sp)
560	ldt	$f15, 184($sp)
561	ldt	$f16, 192($sp)
562	ldt	$f17, 200($sp)
563	ldt	$f18, 208($sp)
564	ldt	$f19, 216($sp)
565	ldt	$f20, 224($sp)
566	ldt	$f21, 232($sp)
567	ldt	$f22, 240($sp)
568	ldt	$f23, 248($sp)
569	ldt	$f24, 256($sp)
570	ldt	$f25, 264($sp)
571	ldt	$f26, 272($sp)
572	ldt	$f27, 280($sp)
573	ldt	$f28, 288($sp)
574	ldt	$f29, 296($sp)
575	ldt	$f30, 304($sp)
576	lda	$sp, SWITCH_STACK_SIZE($sp)
577	ret	$31, ($1), 1
578.end undo_switch_stack
579
580/*
581 * The meat of the context switch code.
582 */
583
584	.align	4
585	.globl	alpha_switch_to
586	.ent	alpha_switch_to
587alpha_switch_to:
588	.prologue 0
589	bsr	$1, do_switch_stack
590	call_pal PAL_swpctx
591	lda	$8, 0x3fff
592	bsr	$1, undo_switch_stack
593	bic	$sp, $8, $8
594	mov	$17, $0
595	ret
596.end alpha_switch_to
597
598/*
599 * New processes begin life here.
600 */
601
602	.globl	ret_from_fork
603	.align	4
604	.ent	ret_from_fork
605ret_from_fork:
606	lda	$26, ret_from_sys_call
607	mov	$17, $16
608	jmp	$31, schedule_tail
609.end ret_from_fork
610
611/*
612 * kernel_thread(fn, arg, clone_flags)
613 */
614	.align 4
615	.globl	kernel_thread
616	.ent	kernel_thread
617kernel_thread:
618	/* We can be called from a module.  */
619	ldgp	$gp, 0($27)
620	.prologue 1
621	subq	$sp, SP_OFF+6*8, $sp
622	br	$1, 2f		/* load start address */
623
624	/* We've now "returned" from a fake system call.  */
625	unop
626	blt	$0, 1f		/* error?  */
627	ldi	$1, 0x3fff
628	beq	$20, 1f		/* parent or child?  */
629
630	bic	$sp, $1, $8	/* in child.  */
631	jsr	$26, ($27)
632	ldgp	$gp, 0($26)
633	mov	$0, $16
634	mov	$31, $26
635	jmp	$31, sys_exit
636
6371:	ret			/* in parent.  */
638
639	.align 4
6402:	/* Fake a system call stack frame, as we can't do system calls
641	   from kernel space.  Note that we store FN and ARG as they
642	   need to be set up in the child for the call.  Also store $8
643	   and $26 for use in the parent.  */
644	stq	$31, SP_OFF($sp)	/* ps */
645	stq	$1, SP_OFF+8($sp)	/* pc */
646	stq	$gp, SP_OFF+16($sp)	/* gp */
647	stq	$16, 136($sp)		/* $27; FN for child */
648	stq	$17, SP_OFF+24($sp)	/* $16; ARG for child */
649	stq	$8, 64($sp)		/* $8 */
650	stq	$26, 128($sp)		/* $26 */
651	/* Avoid the HAE being gratuitously wrong, to avoid restoring it.  */
652	ldq	$2, alpha_mv+HAE_CACHE
653	stq	$2, 152($sp)		/* HAE */
654
655	/* Shuffle FLAGS to the front; add CLONE_VM.  */
656	ldi	$1, CLONE_VM|CLONE_UNTRACED
657	or	$18, $1, $16
658	bsr	$26, sys_clone
659
660	/* We don't actually care for a3 success widgetry in the kernel.
661	   Not for positive errno values.  */
662	stq	$0, 0($sp)		/* $0 */
663	br	ret_to_kernel
664.end kernel_thread
665
666/*
667 * kernel_execve(path, argv, envp)
668 */
669	.align	4
670	.globl	kernel_execve
671	.ent	kernel_execve
672kernel_execve:
673	/* We can be called from a module.  */
674	ldgp	$gp, 0($27)
675	lda	$sp, -(32+SIZEOF_PT_REGS+8)($sp)
676	.frame	$sp, 32+SIZEOF_PT_REGS+8, $26, 0
677	stq	$26, 0($sp)
678	stq	$16, 8($sp)
679	stq	$17, 16($sp)
680	stq	$18, 24($sp)
681	.prologue 1
682
683	lda	$16, 32($sp)
684	lda	$17, 0
685	lda	$18, SIZEOF_PT_REGS
686	bsr	$26, memset		!samegp
687
688	/* Avoid the HAE being gratuitously wrong, which would cause us
689	   to do the whole turn off interrupts thing and restore it.  */
690	ldq	$2, alpha_mv+HAE_CACHE
691	stq	$2, 152+32($sp)
692
693	ldq	$16, 8($sp)
694	ldq	$17, 16($sp)
695	ldq	$18, 24($sp)
696	lda	$19, 32($sp)
697	bsr	$26, do_execve		!samegp
698
699	ldq	$26, 0($sp)
700	bne	$0, 1f			/* error! */
701
702	/* Move the temporary pt_regs struct from its current location
703	   to the top of the kernel stack frame.  See copy_thread for
704	   details for a normal process.  */
705	lda	$16, 0x4000 - SIZEOF_PT_REGS($8)
706	lda	$17, 32($sp)
707	lda	$18, SIZEOF_PT_REGS
708	bsr	$26, memmove		!samegp
709
710	/* Take that over as our new stack frame and visit userland!  */
711	lda	$sp, 0x4000 - SIZEOF_PT_REGS($8)
712	br	$31, ret_from_sys_call
713
7141:	lda	$sp, 32+SIZEOF_PT_REGS+8($sp)
715	ret
716.end kernel_execve
717
718
719/*
720 * Special system calls.  Most of these are special in that they either
721 * have to play switch_stack games or in some way use the pt_regs struct.
722 */
723	.align	4
724	.globl	sys_fork
725	.ent	sys_fork
726sys_fork:
727	.prologue 0
728	mov	$sp, $21
729	bsr	$1, do_switch_stack
730	bis	$31, SIGCHLD, $16
731	mov	$31, $17
732	mov	$31, $18
733	mov	$31, $19
734	mov	$31, $20
735	jsr	$26, alpha_clone
736	bsr	$1, undo_switch_stack
737	ret
738.end sys_fork
739
740	.align	4
741	.globl	sys_clone
742	.ent	sys_clone
743sys_clone:
744	.prologue 0
745	mov	$sp, $21
746	bsr	$1, do_switch_stack
747	/* $16, $17, $18, $19, $20 come from the user.  */
748	jsr	$26, alpha_clone
749	bsr	$1, undo_switch_stack
750	ret
751.end sys_clone
752
753	.align	4
754	.globl	sys_vfork
755	.ent	sys_vfork
756sys_vfork:
757	.prologue 0
758	mov	$sp, $16
759	bsr	$1, do_switch_stack
760	jsr	$26, alpha_vfork
761	bsr	$1, undo_switch_stack
762	ret
763.end sys_vfork
764
765	.align	4
766	.globl	sys_sigreturn
767	.ent	sys_sigreturn
768sys_sigreturn:
769	.prologue 0
770	lda	$9, ret_from_straced
771	cmpult	$26, $9, $9
772	mov	$sp, $17
773	lda	$18, -SWITCH_STACK_SIZE($sp)
774	lda	$sp, -SWITCH_STACK_SIZE($sp)
775	jsr	$26, do_sigreturn
776	bne	$9, 1f
777	jsr	$26, syscall_trace
7781:	br	$1, undo_switch_stack
779	br	ret_from_sys_call
780.end sys_sigreturn
781
782	.align	4
783	.globl	sys_rt_sigreturn
784	.ent	sys_rt_sigreturn
785sys_rt_sigreturn:
786	.prologue 0
787	lda	$9, ret_from_straced
788	cmpult	$26, $9, $9
789	mov	$sp, $17
790	lda	$18, -SWITCH_STACK_SIZE($sp)
791	lda	$sp, -SWITCH_STACK_SIZE($sp)
792	jsr	$26, do_rt_sigreturn
793	bne	$9, 1f
794	jsr	$26, syscall_trace
7951:	br	$1, undo_switch_stack
796	br	ret_from_sys_call
797.end sys_rt_sigreturn
798
799	.align	4
800	.globl	sys_sethae
801	.ent	sys_sethae
802sys_sethae:
803	.prologue 0
804	stq	$16, 152($sp)
805	ret
806.end sys_sethae
807
808	.align	4
809	.globl	osf_getpriority
810	.ent	osf_getpriority
811osf_getpriority:
812	lda	$sp, -16($sp)
813	stq	$26, 0($sp)
814	.prologue 0
815
816	jsr	$26, sys_getpriority
817
818	ldq	$26, 0($sp)
819	blt	$0, 1f
820
821	/* Return value is the unbiased priority, i.e. 20 - prio.
822	   This does result in negative return values, so signal
823	   no error by writing into the R0 slot.  */
824	lda	$1, 20
825	stq	$31, 16($sp)
826	subl	$1, $0, $0
827	unop
828
8291:	lda	$sp, 16($sp)
830	ret
831.end osf_getpriority
832
833	.align	4
834	.globl	sys_getxuid
835	.ent	sys_getxuid
836sys_getxuid:
837	.prologue 0
838	ldq	$2, TI_TASK($8)
839	ldq	$3, TASK_CRED($2)
840	ldl	$0, CRED_UID($3)
841	ldl	$1, CRED_EUID($3)
842	stq	$1, 80($sp)
843	ret
844.end sys_getxuid
845
846	.align	4
847	.globl	sys_getxgid
848	.ent	sys_getxgid
849sys_getxgid:
850	.prologue 0
851	ldq	$2, TI_TASK($8)
852	ldq	$3, TASK_CRED($2)
853	ldl	$0, CRED_GID($3)
854	ldl	$1, CRED_EGID($3)
855	stq	$1, 80($sp)
856	ret
857.end sys_getxgid
858
859	.align	4
860	.globl	sys_getxpid
861	.ent	sys_getxpid
862sys_getxpid:
863	.prologue 0
864	ldq	$2, TI_TASK($8)
865
866	/* See linux/kernel/timer.c sys_getppid for discussion
867	   about this loop.  */
868	ldq	$3, TASK_GROUP_LEADER($2)
869	ldq	$4, TASK_REAL_PARENT($3)
870	ldl	$0, TASK_TGID($2)
8711:	ldl	$1, TASK_TGID($4)
872#ifdef CONFIG_SMP
873	mov	$4, $5
874	mb
875	ldq	$3, TASK_GROUP_LEADER($2)
876	ldq	$4, TASK_REAL_PARENT($3)
877	cmpeq	$4, $5, $5
878	beq	$5, 1b
879#endif
880	stq	$1, 80($sp)
881	ret
882.end sys_getxpid
883
884	.align	4
885	.globl	sys_alpha_pipe
886	.ent	sys_alpha_pipe
887sys_alpha_pipe:
888	lda	$sp, -16($sp)
889	stq	$26, 0($sp)
890	.prologue 0
891
892	mov	$31, $17
893	lda	$16, 8($sp)
894	jsr	$26, do_pipe_flags
895
896	ldq	$26, 0($sp)
897	bne	$0, 1f
898
899	/* The return values are in $0 and $20.  */
900	ldl	$1, 12($sp)
901	ldl	$0, 8($sp)
902
903	stq	$1, 80+16($sp)
9041:	lda	$sp, 16($sp)
905	ret
906.end sys_alpha_pipe
907
908	.align	4
909	.globl	sys_execve
910	.ent	sys_execve
911sys_execve:
912	.prologue 0
913	mov	$sp, $19
914	jmp	$31, do_sys_execve
915.end sys_execve
916
917	.align	4
918	.globl	alpha_ni_syscall
919	.ent	alpha_ni_syscall
920alpha_ni_syscall:
921	.prologue 0
922	/* Special because it also implements overflow handling via
923	   syscall number 0.  And if you recall, zero is a special
924	   trigger for "not an error".  Store large non-zero there.  */
925	lda	$0, -ENOSYS
926	unop
927	stq	$0, 0($sp)
928	ret
929.end alpha_ni_syscall
930