projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
disable sstrip when using musl
[openwrt/openwrt.git] / target / linux / ubicom32 / files / arch / ubicom32 / kernel / ubicom32_syscall.S
1 /*
2 * arch/ubicom32/kernel/ubicom32_syscall.S
3 * <TODO: Replace with short file description>
4 *
5 * (C) Copyright 2009, Ubicom, Inc.
6 *
7 * This file is part of the Ubicom32 Linux Kernel Port.
8 *
9 * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10 * it and/or modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation, either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with the Ubicom32 Linux Kernel Port. If not,
21 * see <http://www.gnu.org/licenses/>.
22 *
23 * Ubicom32 implementation derived from (with many thanks):
24 * arch/m68knommu
25 * arch/blackfin
26 * arch/parisc
27 */
28 #include <linux/sys.h>
29 #include <linux/linkage.h>
30 #include <linux/unistd.h>
31
32 #include <asm/ubicom32-common.h>
33 #include <asm/thread_info.h>
34 #include <asm/asm-offsets.h>
35 #include <asm/range-protect.h>
36
37 /*
38 * __old_system_call()
39 */
40 .section .old_syscall_entry.text, "ax", @progbits
41 #ifdef CONFIG_OLD_40400010_SYSTEM_CALL
42 __old_system_call:
43 call a3, system_call
44 .size __old_system_call, . - __old_system_call ;
45 #else
46 /*
47 * something that will crash the userspace application, but
48 * should not take down the kernel, if protection is enabled
49 * this will never even get executed.
50 */
51 .long 0xFABBCCDE ; illegal instruction
52 bkpt #-1 ; we will never get here
53 #endif
54
55 /*
56 * system_call()
57 */
58 .section .syscall_entry.text, "ax", @progbits
59 .global system_call
60 system_call:
61 /*
62 * Regular ABI rules for function calls apply for syscall. d8 holds
63 * the syscall number. We will use that to index into the syscall table.
64 * d0 - d5 hold the parameters.
65 *
66 * First we get the current thread_info and swap to the kernel stack.
67 * This is done by reading the current thread and looking up the ksp
68 * from the sw_ksp array and storing it in a3.
69 *
70 * Then we reserve space for the syscall context a struct pt_regs and
71 * save it using a4 initially and later as sp.
72 * Once sp is set to the kernel sp we can leave the critical section.
73 *
74 * For the user case the kernel stack will have the following layout.
75 *
76 * a3 ksp[0] +-----------------------+
77 * | Thread info area |
78 * | struct thread_info |
79 * +-----------------------+
80 * : :
81 * | Kernel Stack Area |
82 * | |
83 * a4 / sp >>> +-----------------------+
84 * | Context save area |
85 * | struct pt_reg |
86 * ksp[THREAD_SIZE-8] +-----------------------+
87 * | 8 Byte Buffer Zone |
88 * ksp[THREAD_SIZE] +-----------------------+
89
90 *
91 * For kernel syscalls the layout is as follows.
92 *
93 * a3 ksp[0] +-----------------------+
94 * | Thread info area |
95 * | struct thread_info |
96 * +-----------------------+
97 * : :
98 * | Kernel Stack Area |
99 * | |
100 * a4 / sp >>> +-----------------------+
101 * | Context save area |
102 * | struct pt_reg |
103 * sp at syscall entry +-----------------------+
104 * | Callers Kernel Stack |
105 * : :
106 *
107 * Once the context is saved we optionally call syscall_trace and setup
108 * the exit routine and jump to the syscall.
109 */
110
111 /*
112 * load the base address for sw_ksp into a3
113 * Note.. we cannot access it just yet as protection is still on.
114 */
115 moveai a3, #%hi(sw_ksp)
116 lea.1 a3, %lo(sw_ksp)(a3)
117
118 /*
119 * Enter critical section .
120 *
121 * The 'critical' aspects here are the switching the to the ksp and
122 * changing the protection registers, these both use per thread
123 * information so we need to protect from a context switch. For now this
124 * is done using the global atomic lock.
125 */
126 atomic_lock_acquire
127
128 thread_get_self d15 ; Load current thread number
129 #ifdef CONFIG_PROTECT_KERNEL
130 lsl.4 d9, #1, d15 ; Convert to thread bit
131 enable_kernel_ranges d9
132 #endif
133 /*
134 * in order to reduce the size of code in the syscall section we get
135 * out of it right now
136 */
137 call a4, __system_call_bottom_half
138 .size system_call, . - system_call
139
140 .section .text.__system_call_bottom_half, "ax", @progbits
141 __system_call_bottom_half:
142
143 /*
144 * We need to Determine if this is a kernel syscall or user syscall.
145 * Start by loading the pointer for the thread_info structure for the
146 * current process in to a3.
147 */
148 move.4 a3, (a3, d15) ; a3 = sw_ksp[d15]
149
150 /*
151 * Now if this is a kernel thread the same value can be a acheived by
152 * masking off the lower bits on the current stack pointer.
153 */
154 movei d9, #(~(ASM_THREAD_SIZE-1)) ; load mask
155 and.4 d9, sp, d9 ; apply mask
156
157 /*
158 * d9 now has the masked version of the sp. If this is identical to
159 * what is in a3 then don't switch to ksp as we are already in the
160 * kernel.
161 */
162 sub.4 #0, a3, d9
163
164 /*
165 * if d9 and a3 are not equal. We are usespace and have to shift to
166 * ksp.
167 */
168 jmpne.t 1f
169
170 /*
171 * Kernel Syscall.
172 *
173 * The kernel has called this routine. We have to pdec space for pt_regs
174 * from sp.
175 */
176 pdec a4, PT_SIZE(sp) ; a4 = ksp - PT_SIZE
177 jmpt.t 2f
178
179 /*
180 * Userspace Syscall.
181 *
182 * Add THREAD_SIZE and subtract PT_SIZE to create the proper ksp
183 */
184 1: movei d15, #(ASM_THREAD_SIZE - 8 - PT_SIZE)
185 lea.1 a4, (a3, d15) ; a4 = ksp + d15
186
187 /*
188 * Replace user stack pointer with kernel stack pointer (a4)
189 * Load -1 into frame_type in save area to indicate this is system call
190 * frame.
191 */
192 2: move.4 PT_A7(a4), a7 ; Save old sp/A7 on kernel stack
193 move.4 PT_FRAME_TYPE(a4), #-1 ; Set the frame type.
194 move.4 sp, a4 ; Change to ksp.
195 /*
196 * We are now officially back in the kernel!
197 */
198
199 /*
200 * Now that we are on the ksp we can leave the critical section
201 */
202 atomic_lock_release
203
204 /*
205 * We need to save a0 because we need to be able to restore it in
206 * the event that we need to handle a signal. It's not generally
207 * a callee-saved register but is the GOT pointer.
208 */
209 move.4 PT_A0(sp), a0 ; Save A0 on kernel stack
210
211 /*
212 * We still need to save d10-d13, a1, a2, a5, a6 in the kernel frame
213 * for this process, we also save the system call params in the case of
214 * syscall restart. (note a7 was saved above)
215 */
216 move.4 PT_A1(sp), a1 ; Save A1 on kernel stack
217 move.4 PT_A2(sp), a2 ; Save A2 on kernel stack
218 move.4 PT_A5(sp), a5 ; Save A5 on kernel stack
219 move.4 PT_A6(sp), a6 ; Save A6 on kernel stack
220 move.4 PT_PC(sp), a5 ; Save A5 at the PC location
221 move.4 PT_D10(sp), d10 ; Save D10 on kernel stack
222 move.4 PT_D11(sp), d11 ; Save D11 on kernel stack
223 move.4 PT_D12(sp), d12 ; Save D12 on kernel stack
224 move.4 PT_D13(sp), d13 ; Save D13 on kernel stack
225
226 /*
227 * Now save the syscall parameters
228 */
229 move.4 PT_D0(sp), d0 ; Save d0 on kernel stack
230 move.4 PT_ORIGINAL_D0(sp), d0 ; Save d0 on kernel stack
231 move.4 PT_D1(sp), d1 ; Save d1 on kernel stack
232 move.4 PT_D2(sp), d2 ; Save d2 on kernel stack
233 move.4 PT_D3(sp), d3 ; Save d3 on kernel stack
234 move.4 PT_D4(sp), d4 ; Save d4 on kernel stack
235 move.4 PT_D5(sp), d5 ; Save d5 on kernel stack
236 move.4 PT_D8(sp), d8 ; Save d8 on kernel stack
237
238 /*
239 * Test if syscalls are being traced and if they are jump to syscall
240 * trace (it will comeback here)
241 */
242 btst TI_FLAGS(a3), #ASM_TIF_SYSCALL_TRACE
243 jmpne.f .Lsystem_call__trace
244 .Lsystem_call__trace_complete:
245 /*
246 * Check for a valid call number [ 0 <= syscall_number < NR_syscalls ]
247 */
248 cmpi d8, #0
249 jmplt.f 3f
250 cmpi d8, #NR_syscalls
251 jmplt.t 4f
252
253 /*
254 * They have passed an invalid number. Call sys_ni_syscall staring by
255 * load a4 with the base address of sys_ni_syscall
256 */
257 3: moveai a4, #%hi(sys_ni_syscall)
258 lea.1 a4, %lo(sys_ni_syscall)(a4)
259 jmpt.t 5f ; Jump to regular processing
260
261 /*
262 * Validated syscall, load the syscall table base address into a3 and
263 * read the syscall ptr out.
264 */
265 4: moveai a3, #%hi(sys_call_table)
266 lea.1 a3, %lo(sys_call_table)(a3) ; a3 = sys_call_table
267 move.4 a4, (a3, d8) ; a4 = sys_call_table[d8]
268
269 /*
270 * Before calling the syscall, setup a5 so that syscall_exit is called
271 * on return from syscall
272 */
273 5: moveai a5, #%hi(syscall_exit) ; Setup return address
274 lea.1 a5, %lo(syscall_exit)(a5) ; from system call
275
276 /*
277 * If the syscall is __NR_rt_rigreturn then we have to test d1 to
278 * figure out if we have to change change the return routine to restore
279 * all registers.
280 */
281 cmpi d8, #__NR_rt_sigreturn
282 jmpeq.f 6f
283
284 /*
285 * Launch system call (it will return through a5 - syscall_exit)
286 */
287 calli a3, 0(a4)
288
289 /*
290 * System call is rt_sigreturn. Test d1. If it is 1 we have to
291 * change the return address to restore_all_registers
292 */
293 6: cmpi d1, #1
294 jmpne.t 7f
295
296 moveai a5, #%hi(restore_all_registers) ; Setup return address
297 lea.1 a5, %lo(restore_all_registers)(a5) ; to restore_all_registers.
298
299 /*
300 * Launch system call (it will return through a5)
301 */
302 7: calli a3, 0(a4) ; Launch system call
303
304 .Lsystem_call__trace:
305 /*
306 * Syscalls are being traced.
307 * Call syscall_trace, (return here)
308 */
309 call a5, syscall_trace
310
311 /*
312 * Restore syscall state (it would have been discarded during the
313 * syscall trace)
314 */
315 move.4 d0, PT_D0(sp) ; Restore d0 from kernel stack
316 move.4 d1, PT_D1(sp) ; Restore d1 from kernel stack
317 move.4 d2, PT_D2(sp) ; Restore d2 from kernel stack
318 move.4 d3, PT_D3(sp) ; Restore d3 from kernel stack
319 move.4 d4, PT_D4(sp) ; Restore d4 from kernel stack
320 move.4 d5, PT_D5(sp) ; Restore d5 from kernel stack
321 /* add this back if we ever have a syscall with 7 args */
322 move.4 d8, PT_D8(sp) ; Restore d8 from kernel stack
323
324 /*
325 * return to syscall
326 */
327 jmpt.t .Lsystem_call__trace_complete
328 .size __system_call_bottom_half, . - __system_call_bottom_half
329
330 /*
331 * syscall_exit()
332 */
333 .section .text.syscall_exit
334 .global syscall_exit
335 syscall_exit:
336 /*
337 * d0 contains the return value. We should move that into the kernel
338 * stack d0 location. We will be transitioning from kernel to user
339 * mode. Test the flags and see if we have to call schedule. If we are
340 * going to truly exit then all that has to be done is that from the
341 * kernel stack we have to restore d0, a0, a1, a2, a5, a6 and sp (a7)bb
342 * and then return via a5.
343 */
344
345 /*
346 * Save d0 to pt_regs
347 */
348 move.4 PT_D0(sp), d0 ; Save d0 into the kernel stack
349
350 /*
351 * load the thread_info structure by masking off the THREAD_SIZE
352 * bits.
353 *
354 * Note: we used to push a1, but now we don't as we are going
355 * to eventually restore it to the userspace a1.
356 */
357 movei d9, #(~(ASM_THREAD_SIZE-1))
358 and.4 a1, sp, d9
359
360 /*
361 * Are any interesting bits set on TI flags, if there are jump
362 * aside to post_processing.
363 */
364 move.4 d9, #(_TIF_SYSCALL_TRACE | _TIF_NEED_RESCHED | _TIF_SIGPENDING)
365 and.4 #0, TI_FLAGS(a1), d9
366 jmpne.f .Lsyscall_exit__post_processing ; jump to handler
367 .Lsyscall_exit__post_processing_complete:
368
369 move.4 d0, PT_D0(sp) ; Restore D0 from kernel stack
370 move.4 d1, PT_D1(sp) ; Restore d1 from kernel stack
371 move.4 d2, PT_D2(sp) ; Restore d2 from kernel stack
372 move.4 d3, PT_D3(sp) ; Restore d3 from kernel stack
373 move.4 d4, PT_D4(sp) ; Restore d4 from kernel stack
374 move.4 d5, PT_D5(sp) ; Restore d5 from kernel stack
375 move.4 d8, PT_D8(sp) ; Restore d8 from kernel stack
376 move.4 d10, PT_D10(sp) ; Restore d10 from kernel stack
377 move.4 d11, PT_D11(sp) ; Restore d11 from kernel stack
378 move.4 d12, PT_D12(sp) ; Restore d12 from kernel stack
379 move.4 d13, PT_D13(sp) ; Restore d13 from kernel stack
380 move.4 a1, PT_A1(sp) ; Restore A1 from kernel stack
381 move.4 a2, PT_A2(sp) ; Restore A2 from kernel stack
382 move.4 a5, PT_A5(sp) ; Restore A5 from kernel stack
383 move.4 a6, PT_A6(sp) ; Restore A6 from kernel stack
384 move.4 a0, PT_A0(sp) ; Restore A6 from kernel stack
385
386 /*
387 * this is only for debug, and could be removed for production builds
388 */
389 move.4 PT_FRAME_TYPE(sp), #0 ; invalidate frame_type
390
391 #ifdef CONFIG_PROTECT_KERNEL
392
393 call a4, __syscall_exit_bottom_half
394
395 .section .kernel_unprotected, "ax", @progbits
396 __syscall_exit_bottom_half:
397 /*
398 * Enter critical section
399 */
400 atomic_lock_acquire
401 disable_kernel_ranges_for_current d15
402 #endif
403 /*
404 * Lastly restore userspace stack ptr
405 *
406 * Note: that when protection is on we need to hold the lock around the
407 * stack swap as well because otherwise the protection could get
408 * inadvertently disabled again at the end of a context switch.
409 */
410 move.4 a7, PT_A7(sp) ; Restore A7 from kernel stack
411
412 /*
413 * We are now officially back in userspace!
414 */
415
416 #ifdef CONFIG_PROTECT_KERNEL
417 /*
418 * Leave critical section and return to user space.
419 */
420 atomic_lock_release
421 #endif
422 calli a5, 0(a5) ; Back to userspace code.
423
424 bkpt #-1 ; we will never get here
425
426 /*
427 * Post syscall processing. (unlikely part of syscall_exit)
428 *
429 * Are we tracing syscalls. If TIF_SYSCALL_TRACE is set, call
430 * syscall_trace routine and return here.
431 */
432 .section .text.syscall_exit, "ax", @progbits
433 .Lsyscall_exit__post_processing:
434 btst TI_FLAGS(a1), #ASM_TIF_SYSCALL_TRACE
435 jmpeq.t 1f
436 call a5, syscall_trace
437
438 /*
439 * Do we need to resched ie call schedule. If TIF_NEED_RESCHED is set,
440 * call the scheduler, it will come back here.
441 */
442 1: btst TI_FLAGS(a1), #ASM_TIF_NEED_RESCHED
443 jmpeq.t 2f
444 call a5, schedule
445
446 /*
447 * Do we need to post a signal, if TIF_SIGPENDING is set call the
448 * do_signal.
449 */
450 2: btst TI_FLAGS(a1), #ASM_TIF_SIGPENDING
451 jmpeq.t .Lsyscall_exit__post_processing_complete
452
453 /*
454 * setup the do signal call
455 */
456 move.4 d0, #0 ; oldset pointer is NULL
457 lea.1 d1, (sp) ; d1 is the regs pointer.
458 call a5, do_signal
459
460 jmpt.t .Lsyscall_exit__post_processing_complete
461
462 /* .size syscall_exit, . - syscall_exit */
463
464 /*
465 * kernel_execve()
466 * kernel_execv is called when we the kernel is starting a
467 * userspace application.
468 */
469 .section .kernel_unprotected, "ax", @progbits
470 .global kernel_execve
471 kernel_execve:
472 move.4 -4(sp)++, a5 ; Save return address
473 /*
474 * Call execve
475 */
476 movei d8, #__NR_execve ; call execve
477 call a5, system_call
478 move.4 a5, (sp)4++
479
480 /*
481 * protection was enabled again at syscall exit, but we want
482 * to return to kernel so we enable it again.
483 */
484 #ifdef CONFIG_PROTECT_KERNEL
485 /*
486 * We are entering the kernel so we need to disable the protection.
487 * Enter critical section, disable ranges and leave critical section.
488 */
489 call a3, __enable_kernel_ranges ; and jump back to kernel
490 #else
491 ret a5 ; jump back to the kernel
492 #endif
493
494 .size kernel_execve, . - kernel_execve
495
496 /*
497 * signal_trampoline()
498 *
499 * Deals with transitioning from to userspace signal handlers and returning
500 * to userspace, only called from the kernel.
501 *
502 */
503 .section .kernel_unprotected, "ax", @progbits
504 .global signal_trampoline
505 signal_trampoline:
506 /*
507 * signal_trampoline is called when we are jumping from the kernel to
508 * the userspace signal handler.
509 *
510 * The following registers are relevant. (set setup_rt_frame)
511 * sp is the user space stack not the kernel stack
512 * d0 = signal number
513 * d1 = siginfo_t *
514 * d2 = ucontext *
515 * d3 = the user space signal handler
516 * a0 is set to the GOT if userspace application is FDPIC, otherwise 0
517 * a3 is set to the FD for the signal if userspace application is FDPIC
518 */
519 #ifdef CONFIG_PROTECT_KERNEL
520 /*
521 * We are leaving the kernel so we need to enable the protection.
522 * Enter critical section, disable ranges and leave critical section.
523 */
524 atomic_lock_acquire ; Enter critical section
525 disable_kernel_ranges_for_current d15 ; disable kernel ranges
526 atomic_lock_release ; Leave critical section
527 #endif
528 /*
529 * The signal handler pointer is in register d3 so tranfer it to a4 and
530 * call it
531 */
532 movea a4, d3 ; signal handler
533 calli a5, 0(a4)
534
535 /*
536 * Return to userspace through rt_syscall which is stored on top of the
537 * stack d1 contains ret_via_interrupt status.
538 */
539 move.4 d8, (sp) ; d8 (syscall #) = rt_syscall
540 move.4 d1, 4(sp) ; d1 = ret_via_interrupt
541 call a5, system_call ; as we are 'in' the kernel
542 ; we can call kernel_syscall
543
544 bkpt #-1 ; will never get here.
545 .size signal_trampoline, . - signal_trampoline
546
547 /*
548 * kernel_thread_helper()
549 *
550 * Entry point for kernel threads (only referenced by kernel_thread()).
551 *
552 * On execution d0 will be 0, d1 will be the argument to be passed to the
553 * kernel function.
554 * d2 contains the kernel function that needs to get called.
555 * d3 will contain address to do_exit which needs to get moved into a5.
556 *
557 * On return from fork the child thread d0 will be 0. We call this dummy
558 * function which in turn loads the argument
559 */
560 .section .kernel_unprotected, "ax", @progbits
561 .global kernel_thread_helper
562 kernel_thread_helper:
563 /*
564 * Create a kernel thread. This is called from ret_from_vfork (a
565 * userspace return routine) so we need to put it in an unprotected
566 * section and re-enable protection before calling the vector in d2.
567 */
568
569 #ifdef CONFIG_PROTECT_KERNEL
570 /*
571 * We are entering the kernel so we need to disable the protection.
572 * Enter critical section, disable ranges and leave critical section.
573 */
574 call a5, __enable_kernel_ranges
575 #endif
576 /*
577 * Move argument for kernel function into d0, and set a5 return address
578 * (a5) to do_exit and return through a2
579 */
580 move.4 d0, d1 ; d0 = arg
581 move.4 a5, d3 ; a5 = do_exit
582 ret d2 ; call function ptr in d2
583 .size kernel_thread_helper, . - kernel_thread_helper
584
585 #ifdef CONFIG_PROTECT_KERNEL
586 .section .kernel_unprotected, "ax", @progbits
587 __enable_kernel_ranges:
588 atomic_lock_acquire ; Enter critical section
589 enable_kernel_ranges_for_current d15
590 atomic_lock_release ; Leave critical section
591 calli a5, 0(a5)
592 .size __enable_kernel_ranges, . - __enable_kernel_ranges
593
594 #endif
595
596 /*
597 * The following system call intercept functions where we setup the
598 * input to the real system call. In all cases these are just taking
599 * the current sp which is pointing to pt_regs and pushing it into the
600 * last arg of the system call.
601 *
602 * i.e. the public definition of sys_execv is
603 * sys_execve( char *name,
604 * char **argv,
605 * char **envp )
606 * but process.c defines it as
607 * sys_execve( char *name,
608 * char **argv,
609 * char **envp,
610 * struct pt_regs *regs )
611 *
612 * so execve_intercept needs to populate the 4th arg with pt_regs*,
613 * which is the stack pointer as we know we must be coming out of
614 * system_call
615 *
616 * The intercept vectors are referenced by syscalltable.S
617 */
618
619 /*
620 * execve_intercept()
621 */
622 .section .text.execve_intercept, "ax", @progbits
623 .global execve_intercept
624 execve_intercept:
625 move.4 d3, sp ; Save pt_regs address
626 call a3, sys_execve
627
628 .size execve_intercept, . - execve_intercept
629
630 /*
631 * vfork_intercept()
632 */
633 .section .text.vfork_intercept, "ax", @progbits
634 .global vfork_intercept
635 vfork_intercept:
636 move.4 d0, sp ; Save pt_regs address
637 call a3, sys_vfork
638
639 .size vfork_intercept, . - vfork_intercept
640
641 /*
642 * clone_intercept()
643 */
644 .section .text.clone_intercept, "ax", @progbits
645 .global clone_intercept
646 clone_intercept:
647 move.4 d2, sp ; Save pt_regs address
648 call a3, sys_clone
649
650 .size clone_intercept, . - clone_intercept
651
652 /*
653 * sys_sigsuspend()
654 */
655 .section .text.sigclone_intercept, "ax", @progbits
656 .global sys_sigsuspend
657 sys_sigsuspend:
658 move.4 d0, sp ; Pass pointer to pt_regs in d0
659 call a3, do_sigsuspend
660
661 .size sys_sigsuspend, . - sys_sigsuspend
662
663 /*
664 * sys_rt_sigsuspend()
665 */
666 .section .text.sys_rt_sigsuspend, "ax", @progbits
667 .global sys_rt_sigsuspend
668 sys_rt_sigsuspend:
669 move.4 d0, sp ; Pass pointer to pt_regs in d0
670 call a3, do_rt_sigsuspend
671
672 .size sys_rt_sigsuspend, . - sys_rt_sigsuspend
673
674 /*
675 * sys_rt_sigreturn()
676 */
677 .section .text.sys_rt_sigreturn, "ax", @progbits
678 .global sys_rt_sigreturn
679 sys_rt_sigreturn:
680 move.4 d0, sp ; Pass pointer to pt_regs in d0
681 call a3, do_rt_sigreturn
682
683 .size sys_rt_sigreturn, . - sys_rt_sigreturn
684
685 /*
686 * sys_sigaltstack()
687 */
688 .section .text.sys_sigaltstack, "ax", @progbits
689 .global sys_sigaltstack
690 sys_sigaltstack:
691 move.4 d0, sp ; Pass pointer to pt_regs in d0
692 call a3, do_sys_sigaltstack
693
694 .size sys_sigaltstack, . - sys_sigaltstack
OpenWrt Source Repository