?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Roll src/third_party/WebKit 06cb9e9:a978ee5 (svn 202558:202559)
[chromium-blink-merge.git] / third_party / tcmalloc / vendor / src / base / linux_syscall_support.h
blobd550776efd3fb688cd05fc885ad02c6ed1b3542c
1 /* Copyright (c) 2005-2008, Google Inc.
2 * All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 * * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 * ---
31 * Author: Markus Gutschke
32 */
33
34 /* This file includes Linux-specific support functions common to the
35 * coredumper and the thread lister; primarily, this is a collection
36 * of direct system calls, and a couple of symbols missing from
37 * standard header files.
38 * There are a few options that the including file can set to control
39 * the behavior of this file:
40 *
41 * SYS_CPLUSPLUS:
42 * The entire header file will normally be wrapped in 'extern "C" { }",
43 * making it suitable for compilation as both C and C++ source. If you
44 * do not want to do this, you can set the SYS_CPLUSPLUS macro to inhibit
45 * the wrapping. N.B. doing so will suppress inclusion of all prerequisite
46 * system header files, too. It is the caller's responsibility to provide
47 * the necessary definitions.
48 *
49 * SYS_ERRNO:
50 * All system calls will update "errno" unless overriden by setting the
51 * SYS_ERRNO macro prior to including this file. SYS_ERRNO should be
52 * an l-value.
53 *
54 * SYS_INLINE:
55 * New symbols will be defined "static inline", unless overridden by
56 * the SYS_INLINE macro.
57 *
58 * SYS_LINUX_SYSCALL_SUPPORT_H
59 * This macro is used to avoid multiple inclusions of this header file.
60 * If you need to include this file more than once, make sure to
61 * unset SYS_LINUX_SYSCALL_SUPPORT_H before each inclusion.
62 *
63 * SYS_PREFIX:
64 * New system calls will have a prefix of "sys_" unless overridden by
65 * the SYS_PREFIX macro. Valid values for this macro are [0..9] which
66 * results in prefixes "sys[0..9]_". It is also possible to set this
67 * macro to -1, which avoids all prefixes.
68 *
69 * This file defines a few internal symbols that all start with "LSS_".
70 * Do not access these symbols from outside this file. They are not part
71 * of the supported API.
72 *
73 * NOTE: This is a stripped down version of the official opensource
74 * version of linux_syscall_support.h, which lives at
75 * http://code.google.com/p/linux-syscall-support/
76 * It includes only the syscalls that are used in perftools, plus a
77 * few extra. Here's the breakdown:
78 * 1) Perftools uses these: grep -rho 'sys_[a-z0-9_A-Z]* *(' src | sort -u
79 * sys__exit(
80 * sys_clone(
81 * sys_close(
82 * sys_fcntl(
83 * sys_fstat(
84 * sys_futex(
85 * sys_futex1(
86 * sys_getcpu(
87 * sys_getdents(
88 * sys_getppid(
89 * sys_gettid(
90 * sys_lseek(
91 * sys_mmap(
92 * sys_mremap(
93 * sys_munmap(
94 * sys_open(
95 * sys_pipe(
96 * sys_prctl(
97 * sys_ptrace(
98 * sys_ptrace_detach(
99 * sys_read(
100 * sys_sched_yield(
101 * sys_sigaction(
102 * sys_sigaltstack(
103 * sys_sigdelset(
104 * sys_sigfillset(
105 * sys_sigprocmask(
106 * sys_socket(
107 * sys_stat(
108 * sys_waitpid(
109 * 2) These are used as subroutines of the above:
110 * sys_getpid -- gettid
111 * sys_kill -- ptrace_detach
112 * sys_restore -- sigaction
113 * sys_restore_rt -- sigaction
114 * sys_socketcall -- socket
115 * sys_wait4 -- waitpid
116 * 3) I left these in even though they're not used. They either
117 * complement the above (write vs read) or are variants (rt_sigaction):
118 * sys_fstat64
119 * sys_getdents64
120 * sys_llseek
121 * sys_mmap2
122 * sys_openat
123 * sys_rt_sigaction
124 * sys_rt_sigprocmask
125 * sys_sigaddset
126 * sys_sigemptyset
127 * sys_stat64
128 * sys_write
129 */
130 #ifndef SYS_LINUX_SYSCALL_SUPPORT_H
131 #define SYS_LINUX_SYSCALL_SUPPORT_H
132
133 /* We currently only support x86-32, x86-64, ARM, MIPS, and PPC on Linux.
134 * Porting to other related platforms should not be difficult.
135 */
136 #if (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || \
137 defined(__mips__) || defined(__PPC__)) && defined(__linux)
138
139 #ifndef SYS_CPLUSPLUS
140 #ifdef __cplusplus
141 /* Some system header files in older versions of gcc neglect to properly
142 * handle being included from C++. As it appears to be harmless to have
143 * multiple nested 'extern "C"' blocks, just add another one here.
144 */
145 extern "C" {
146 #endif
147
148 #include <errno.h>
149 #include <signal.h>
150 #include <stdarg.h>
151 #include <string.h>
152 #include <sys/ptrace.h>
153 #include <sys/resource.h>
154 #include <sys/time.h>
155 #include <sys/types.h>
156 #include <syscall.h>
157 #include <unistd.h>
158 #include <linux/unistd.h>
159 #include <endian.h>
160
161 #ifdef __mips__
162 /* Include definitions of the ABI currently in use. */
163 #include <sgidefs.h>
164 #endif
165
166 #endif
167
168 /* As glibc often provides subtly incompatible data structures (and implicit
169 * wrapper functions that convert them), we provide our own kernel data
170 * structures for use by the system calls.
171 * These structures have been developed by using Linux 2.6.23 headers for
172 * reference. Note though, we do not care about exact API compatibility
173 * with the kernel, and in fact the kernel often does not have a single
174 * API that works across architectures. Instead, we try to mimic the glibc
175 * API where reasonable, and only guarantee ABI compatibility with the
176 * kernel headers.
177 * Most notably, here are a few changes that were made to the structures
178 * defined by kernel headers:
179 *
180 * - we only define structures, but not symbolic names for kernel data
181 * types. For the latter, we directly use the native C datatype
182 * (i.e. "unsigned" instead of "mode_t").
183 * - in a few cases, it is possible to define identical structures for
184 * both 32bit (e.g. i386) and 64bit (e.g. x86-64) platforms by
185 * standardizing on the 64bit version of the data types. In particular,
186 * this means that we use "unsigned" where the 32bit headers say
187 * "unsigned long".
188 * - overall, we try to minimize the number of cases where we need to
189 * conditionally define different structures.
190 * - the "struct kernel_sigaction" class of structures have been
191 * modified to more closely mimic glibc's API by introducing an
192 * anonymous union for the function pointer.
193 * - a small number of field names had to have an underscore appended to
194 * them, because glibc defines a global macro by the same name.
195 */
196
197 /* include/linux/dirent.h */
198 struct kernel_dirent64 {
199 unsigned long long d_ino;
200 long long d_off;
201 unsigned short d_reclen;
202 unsigned char d_type;
203 char d_name[256];
204 };
205
206 /* include/linux/dirent.h */
207 struct kernel_dirent {
208 long d_ino;
209 long d_off;
210 unsigned short d_reclen;
211 char d_name[256];
212 };
213
214 /* include/linux/time.h */
215 struct kernel_timespec {
216 long tv_sec;
217 long tv_nsec;
218 };
219
220 /* include/linux/time.h */
221 struct kernel_timeval {
222 long tv_sec;
223 long tv_usec;
224 };
225
226 /* include/linux/resource.h */
227 struct kernel_rusage {
228 struct kernel_timeval ru_utime;
229 struct kernel_timeval ru_stime;
230 long ru_maxrss;
231 long ru_ixrss;
232 long ru_idrss;
233 long ru_isrss;
234 long ru_minflt;
235 long ru_majflt;
236 long ru_nswap;
237 long ru_inblock;
238 long ru_oublock;
239 long ru_msgsnd;
240 long ru_msgrcv;
241 long ru_nsignals;
242 long ru_nvcsw;
243 long ru_nivcsw;
244 };
245
246 #if defined(__i386__) || defined(__arm__) || defined(__PPC__)
247
248 /* include/asm-{arm,i386,mips,ppc}/signal.h */
249 struct kernel_old_sigaction {
250 union {
251 void (*sa_handler_)(int);
252 void (*sa_sigaction_)(int, siginfo_t *, void *);
253 };
254 unsigned long sa_mask;
255 unsigned long sa_flags;
256 void (*sa_restorer)(void);
257 } __attribute__((packed,aligned(4)));
258 #elif (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32)
259 #define kernel_old_sigaction kernel_sigaction
260 #endif
261
262 /* Some kernel functions (e.g. sigaction() in 2.6.23) require that the
263 * exactly match the size of the signal set, even though the API was
264 * intended to be extensible. We define our own KERNEL_NSIG to deal with
265 * this.
266 * Please note that glibc provides signals [1.._NSIG-1], whereas the
267 * kernel (and this header) provides the range [1..KERNEL_NSIG]. The
268 * actual number of signals is obviously the same, but the constants
269 * differ by one.
270 */
271 #ifdef __mips__
272 #define KERNEL_NSIG 128
273 #else
274 #define KERNEL_NSIG 64
275 #endif
276
277 /* include/asm-{arm,i386,mips,x86_64}/signal.h */
278 struct kernel_sigset_t {
279 unsigned long sig[(KERNEL_NSIG + 8*sizeof(unsigned long) - 1)/
280 (8*sizeof(unsigned long))];
281 };
282
283 /* include/asm-{arm,i386,mips,x86_64,ppc}/signal.h */
284 struct kernel_sigaction {
285 #ifdef __mips__
286 unsigned long sa_flags;
287 union {
288 void (*sa_handler_)(int);
289 void (*sa_sigaction_)(int, siginfo_t *, void *);
290 };
291 struct kernel_sigset_t sa_mask;
292 #else
293 union {
294 void (*sa_handler_)(int);
295 void (*sa_sigaction_)(int, siginfo_t *, void *);
296 };
297 unsigned long sa_flags;
298 void (*sa_restorer)(void);
299 struct kernel_sigset_t sa_mask;
300 #endif
301 };
302
303 /* include/asm-{arm,i386,mips,ppc}/stat.h */
304 #ifdef __mips__
305 #if _MIPS_SIM == _MIPS_SIM_ABI64
306 struct kernel_stat {
307 #else
308 struct kernel_stat64 {
309 #endif
310 unsigned st_dev;
311 unsigned __pad0[3];
312 unsigned long long st_ino;
313 unsigned st_mode;
314 unsigned st_nlink;
315 unsigned st_uid;
316 unsigned st_gid;
317 unsigned st_rdev;
318 unsigned __pad1[3];
319 long long st_size;
320 unsigned st_atime_;
321 unsigned st_atime_nsec_;
322 unsigned st_mtime_;
323 unsigned st_mtime_nsec_;
324 unsigned st_ctime_;
325 unsigned st_ctime_nsec_;
326 unsigned st_blksize;
327 unsigned __pad2;
328 unsigned long long st_blocks;
329 };
330 #elif defined __PPC__
331 struct kernel_stat64 {
332 unsigned long long st_dev;
333 unsigned long long st_ino;
334 unsigned st_mode;
335 unsigned st_nlink;
336 unsigned st_uid;
337 unsigned st_gid;
338 unsigned long long st_rdev;
339 unsigned short int __pad2;
340 long long st_size;
341 long st_blksize;
342 long long st_blocks;
343 long st_atime_;
344 unsigned long st_atime_nsec_;
345 long st_mtime_;
346 unsigned long st_mtime_nsec_;
347 long st_ctime_;
348 unsigned long st_ctime_nsec_;
349 unsigned long __unused4;
350 unsigned long __unused5;
351 };
352 #else
353 struct kernel_stat64 {
354 unsigned long long st_dev;
355 unsigned char __pad0[4];
356 unsigned __st_ino;
357 unsigned st_mode;
358 unsigned st_nlink;
359 unsigned st_uid;
360 unsigned st_gid;
361 unsigned long long st_rdev;
362 unsigned char __pad3[4];
363 long long st_size;
364 unsigned st_blksize;
365 unsigned long long st_blocks;
366 unsigned st_atime_;
367 unsigned st_atime_nsec_;
368 unsigned st_mtime_;
369 unsigned st_mtime_nsec_;
370 unsigned st_ctime_;
371 unsigned st_ctime_nsec_;
372 unsigned long long st_ino;
373 };
374 #endif
375
376 /* include/asm-{arm,i386,mips,x86_64,ppc}/stat.h */
377 #if defined(__i386__) || defined(__arm__)
378 struct kernel_stat {
379 /* The kernel headers suggest that st_dev and st_rdev should be 32bit
380 * quantities encoding 12bit major and 20bit minor numbers in an interleaved
381 * format. In reality, we do not see useful data in the top bits. So,
382 * we'll leave the padding in here, until we find a better solution.
383 */
384 unsigned short st_dev;
385 short pad1;
386 unsigned st_ino;
387 unsigned short st_mode;
388 unsigned short st_nlink;
389 unsigned short st_uid;
390 unsigned short st_gid;
391 unsigned short st_rdev;
392 short pad2;
393 unsigned st_size;
394 unsigned st_blksize;
395 unsigned st_blocks;
396 unsigned st_atime_;
397 unsigned st_atime_nsec_;
398 unsigned st_mtime_;
399 unsigned st_mtime_nsec_;
400 unsigned st_ctime_;
401 unsigned st_ctime_nsec_;
402 unsigned __unused4;
403 unsigned __unused5;
404 };
405 #elif defined(__x86_64__)
406 struct kernel_stat {
407 unsigned long st_dev;
408 unsigned long st_ino;
409 unsigned long st_nlink;
410 unsigned st_mode;
411 unsigned st_uid;
412 unsigned st_gid;
413 unsigned __pad0;
414 unsigned long st_rdev;
415 long st_size;
416 long st_blksize;
417 long st_blocks;
418 unsigned long st_atime_;
419 unsigned long st_atime_nsec_;
420 unsigned long st_mtime_;
421 unsigned long st_mtime_nsec_;
422 unsigned long st_ctime_;
423 unsigned long st_ctime_nsec_;
424 long __unused[3];
425 };
426 #elif defined(__PPC__)
427 struct kernel_stat {
428 unsigned st_dev;
429 unsigned long st_ino; // ino_t
430 unsigned long st_mode; // mode_t
431 unsigned short st_nlink; // nlink_t
432 unsigned st_uid; // uid_t
433 unsigned st_gid; // gid_t
434 unsigned st_rdev;
435 long st_size; // off_t
436 unsigned long st_blksize;
437 unsigned long st_blocks;
438 unsigned long st_atime_;
439 unsigned long st_atime_nsec_;
440 unsigned long st_mtime_;
441 unsigned long st_mtime_nsec_;
442 unsigned long st_ctime_;
443 unsigned long st_ctime_nsec_;
444 unsigned long __unused4;
445 unsigned long __unused5;
446 };
447 #elif (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI64)
448 struct kernel_stat {
449 unsigned st_dev;
450 int st_pad1[3];
451 unsigned st_ino;
452 unsigned st_mode;
453 unsigned st_nlink;
454 unsigned st_uid;
455 unsigned st_gid;
456 unsigned st_rdev;
457 int st_pad2[2];
458 long st_size;
459 int st_pad3;
460 long st_atime_;
461 long st_atime_nsec_;
462 long st_mtime_;
463 long st_mtime_nsec_;
464 long st_ctime_;
465 long st_ctime_nsec_;
466 int st_blksize;
467 int st_blocks;
468 int st_pad4[14];
469 };
470 #endif
471
472
473 /* Definitions missing from the standard header files */
474 #ifndef O_DIRECTORY
475 #if defined(__arm__)
476 #define O_DIRECTORY 0040000
477 #else
478 #define O_DIRECTORY 0200000
479 #endif
480 #endif
481 #ifndef PR_GET_DUMPABLE
482 #define PR_GET_DUMPABLE 3
483 #endif
484 #ifndef PR_SET_DUMPABLE
485 #define PR_SET_DUMPABLE 4
486 #endif
487 #ifndef AT_FDCWD
488 #define AT_FDCWD (-100)
489 #endif
490 #ifndef AT_SYMLINK_NOFOLLOW
491 #define AT_SYMLINK_NOFOLLOW 0x100
492 #endif
493 #ifndef AT_REMOVEDIR
494 #define AT_REMOVEDIR 0x200
495 #endif
496 #ifndef MREMAP_FIXED
497 #define MREMAP_FIXED 2
498 #endif
499 #ifndef SA_RESTORER
500 #define SA_RESTORER 0x04000000
501 #endif
502
503 #if defined(__i386__)
504 #ifndef __NR_rt_sigaction
505 #define __NR_rt_sigaction 174
506 #define __NR_rt_sigprocmask 175
507 #endif
508 #ifndef __NR_stat64
509 #define __NR_stat64 195
510 #endif
511 #ifndef __NR_fstat64
512 #define __NR_fstat64 197
513 #endif
514 #ifndef __NR_getdents64
515 #define __NR_getdents64 220
516 #endif
517 #ifndef __NR_gettid
518 #define __NR_gettid 224
519 #endif
520 #ifndef __NR_futex
521 #define __NR_futex 240
522 #endif
523 #ifndef __NR_openat
524 #define __NR_openat 295
525 #endif
526 #ifndef __NR_getcpu
527 #define __NR_getcpu 318
528 #endif
529 /* End of i386 definitions */
530 #elif defined(__arm__)
531 #ifndef __syscall
532 #if defined(__thumb__) || defined(__ARM_EABI__)
533 #define __SYS_REG(name) register long __sysreg __asm__("r6") = __NR_##name;
534 #define __SYS_REG_LIST(regs...) [sysreg] "r" (__sysreg) , ##regs
535 #define __syscall(name) "swi\t0"
536 #define __syscall_safe(name) \
537 "push {r7}\n" \
538 "mov r7,%[sysreg]\n" \
539 __syscall(name)"\n" \
540 "pop {r7}"
541 #else
542 #define __SYS_REG(name)
543 #define __SYS_REG_LIST(regs...) regs
544 #define __syscall(name) "swi\t" __sys1(__NR_##name) ""
545 #define __syscall_safe(name) __syscall(name)
546 #endif
547 #endif
548 #ifndef __NR_rt_sigaction
549 #define __NR_rt_sigaction (__NR_SYSCALL_BASE + 174)
550 #define __NR_rt_sigprocmask (__NR_SYSCALL_BASE + 175)
551 #endif
552 #ifndef __NR_stat64
553 #define __NR_stat64 (__NR_SYSCALL_BASE + 195)
554 #endif
555 #ifndef __NR_fstat64
556 #define __NR_fstat64 (__NR_SYSCALL_BASE + 197)
557 #endif
558 #ifndef __NR_getdents64
559 #define __NR_getdents64 (__NR_SYSCALL_BASE + 217)
560 #endif
561 #ifndef __NR_gettid
562 #define __NR_gettid (__NR_SYSCALL_BASE + 224)
563 #endif
564 #ifndef __NR_futex
565 #define __NR_futex (__NR_SYSCALL_BASE + 240)
566 #endif
567 /* End of ARM definitions */
568 #elif defined(__x86_64__)
569 #ifndef __NR_gettid
570 #define __NR_gettid 186
571 #endif
572 #ifndef __NR_futex
573 #define __NR_futex 202
574 #endif
575 #ifndef __NR_getdents64
576 #define __NR_getdents64 217
577 #endif
578 #ifndef __NR_openat
579 #define __NR_openat 257
580 #endif
581 /* End of x86-64 definitions */
582 #elif defined(__mips__)
583 #if _MIPS_SIM == _MIPS_SIM_ABI32
584 #ifndef __NR_rt_sigaction
585 #define __NR_rt_sigaction (__NR_Linux + 194)
586 #define __NR_rt_sigprocmask (__NR_Linux + 195)
587 #endif
588 #ifndef __NR_stat64
589 #define __NR_stat64 (__NR_Linux + 213)
590 #endif
591 #ifndef __NR_fstat64
592 #define __NR_fstat64 (__NR_Linux + 215)
593 #endif
594 #ifndef __NR_getdents64
595 #define __NR_getdents64 (__NR_Linux + 219)
596 #endif
597 #ifndef __NR_gettid
598 #define __NR_gettid (__NR_Linux + 222)
599 #endif
600 #ifndef __NR_futex
601 #define __NR_futex (__NR_Linux + 238)
602 #endif
603 #ifndef __NR_openat
604 #define __NR_openat (__NR_Linux + 288)
605 #endif
606 #ifndef __NR_fstatat
607 #define __NR_fstatat (__NR_Linux + 293)
608 #endif
609 #ifndef __NR_getcpu
610 #define __NR_getcpu (__NR_Linux + 312)
611 #endif
612 /* End of MIPS (old 32bit API) definitions */
613 #elif _MIPS_SIM == _MIPS_SIM_ABI64
614 #ifndef __NR_gettid
615 #define __NR_gettid (__NR_Linux + 178)
616 #endif
617 #ifndef __NR_futex
618 #define __NR_futex (__NR_Linux + 194)
619 #endif
620 #ifndef __NR_openat
621 #define __NR_openat (__NR_Linux + 247)
622 #endif
623 #ifndef __NR_fstatat
624 #define __NR_fstatat (__NR_Linux + 252)
625 #endif
626 #ifndef __NR_getcpu
627 #define __NR_getcpu (__NR_Linux + 271)
628 #endif
629 /* End of MIPS (64bit API) definitions */
630 #else
631 #ifndef __NR_gettid
632 #define __NR_gettid (__NR_Linux + 178)
633 #endif
634 #ifndef __NR_futex
635 #define __NR_futex (__NR_Linux + 194)
636 #endif
637 #ifndef __NR_openat
638 #define __NR_openat (__NR_Linux + 251)
639 #endif
640 #ifndef __NR_fstatat
641 #define __NR_fstatat (__NR_Linux + 256)
642 #endif
643 #ifndef __NR_getcpu
644 #define __NR_getcpu (__NR_Linux + 275)
645 #endif
646 /* End of MIPS (new 32bit API) definitions */
647 #endif
648 /* End of MIPS definitions */
649 #elif defined(__PPC__)
650 #ifndef __NR_rt_sigaction
651 #define __NR_rt_sigaction 173
652 #define __NR_rt_sigprocmask 174
653 #endif
654 #ifndef __NR_stat64
655 #define __NR_stat64 195
656 #endif
657 #ifndef __NR_fstat64
658 #define __NR_fstat64 197
659 #endif
660 #ifndef __NR_getdents64
661 #define __NR_getdents64 202
662 #endif
663 #ifndef __NR_gettid
664 #define __NR_gettid 207
665 #endif
666 #ifndef __NR_futex
667 #define __NR_futex 221
668 #endif
669 #ifndef __NR_openat
670 #define __NR_openat 286
671 #endif
672 #ifndef __NR_getcpu
673 #define __NR_getcpu 302
674 #endif
675 /* End of powerpc defininitions */
676 #endif
677
678
679 /* After forking, we must make sure to only call system calls. */
680 #if __BOUNDED_POINTERS__
681 #error "Need to port invocations of syscalls for bounded ptrs"
682 #else
683 /* The core dumper and the thread lister get executed after threads
684 * have been suspended. As a consequence, we cannot call any functions
685 * that acquire locks. Unfortunately, libc wraps most system calls
686 * (e.g. in order to implement pthread_atfork, and to make calls
687 * cancellable), which means we cannot call these functions. Instead,
688 * we have to call syscall() directly.
689 */
690 #undef LSS_ERRNO
691 #ifdef SYS_ERRNO
692 /* Allow the including file to override the location of errno. This can
693 * be useful when using clone() with the CLONE_VM option.
694 */
695 #define LSS_ERRNO SYS_ERRNO
696 #else
697 #define LSS_ERRNO errno
698 #endif
699
700 #undef LSS_INLINE
701 #ifdef SYS_INLINE
702 #define LSS_INLINE SYS_INLINE
703 #else
704 #define LSS_INLINE static inline
705 #endif
706
707 /* Allow the including file to override the prefix used for all new
708 * system calls. By default, it will be set to "sys_".
709 */
710 #undef LSS_NAME
711 #ifndef SYS_PREFIX
712 #define LSS_NAME(name) sys_##name
713 #elif SYS_PREFIX < 0
714 #define LSS_NAME(name) name
715 #elif SYS_PREFIX == 0
716 #define LSS_NAME(name) sys0_##name
717 #elif SYS_PREFIX == 1
718 #define LSS_NAME(name) sys1_##name
719 #elif SYS_PREFIX == 2
720 #define LSS_NAME(name) sys2_##name
721 #elif SYS_PREFIX == 3
722 #define LSS_NAME(name) sys3_##name
723 #elif SYS_PREFIX == 4
724 #define LSS_NAME(name) sys4_##name
725 #elif SYS_PREFIX == 5
726 #define LSS_NAME(name) sys5_##name
727 #elif SYS_PREFIX == 6
728 #define LSS_NAME(name) sys6_##name
729 #elif SYS_PREFIX == 7
730 #define LSS_NAME(name) sys7_##name
731 #elif SYS_PREFIX == 8
732 #define LSS_NAME(name) sys8_##name
733 #elif SYS_PREFIX == 9
734 #define LSS_NAME(name) sys9_##name
735 #endif
736
737 #undef LSS_RETURN
738 #if (defined(__i386__) || defined(__x86_64__) || defined(__arm__))
739 /* Failing system calls return a negative result in the range of
740 * -1..-4095. These are "errno" values with the sign inverted.
741 */
742 #define LSS_RETURN(type, res) \
743 do { \
744 if ((unsigned long)(res) >= (unsigned long)(-4095)) { \
745 LSS_ERRNO = -(res); \
746 res = -1; \
747 } \
748 return (type) (res); \
749 } while (0)
750 #elif defined(__mips__)
751 /* On MIPS, failing system calls return -1, and set errno in a
752 * separate CPU register.
753 */
754 #define LSS_RETURN(type, res, err) \
755 do { \
756 if (err) { \
757 LSS_ERRNO = (res); \
758 res = -1; \
759 } \
760 return (type) (res); \
761 } while (0)
762 #elif defined(__PPC__)
763 /* On PPC, failing system calls return -1, and set errno in a
764 * separate CPU register. See linux/unistd.h.
765 */
766 #define LSS_RETURN(type, res, err) \
767 do { \
768 if (err & 0x10000000 ) { \
769 LSS_ERRNO = (res); \
770 res = -1; \
771 } \
772 return (type) (res); \
773 } while (0)
774 #endif
775 #if defined(__i386__)
776 #if defined(NO_FRAME_POINTER) && (100 * __GNUC__ + __GNUC_MINOR__ >= 404)
777 /* This only works for GCC-4.4 and above -- the first version to use
778 .cfi directives for dwarf unwind info. */
779 #define CFI_ADJUST_CFA_OFFSET(adjust) \
780 ".cfi_adjust_cfa_offset " #adjust "\n"
781 #else
782 #define CFI_ADJUST_CFA_OFFSET(adjust) /**/
783 #endif
784
785 /* In PIC mode (e.g. when building shared libraries), gcc for i386
786 * reserves ebx. Unfortunately, most distribution ship with implementations
787 * of _syscallX() which clobber ebx.
788 * Also, most definitions of _syscallX() neglect to mark "memory" as being
789 * clobbered. This causes problems with compilers, that do a better job
790 * at optimizing across __asm__ calls.
791 * So, we just have to redefine all of the _syscallX() macros.
792 */
793 #undef LSS_BODY
794 #define LSS_BODY(type,args...) \
795 long __res; \
796 __asm__ __volatile__("push %%ebx\n" \
797 CFI_ADJUST_CFA_OFFSET(4) \
798 "movl %2,%%ebx\n" \
799 "int $0x80\n" \
800 "pop %%ebx\n" \
801 CFI_ADJUST_CFA_OFFSET(-4) \
802 args \
803 : "esp", "memory"); \
804 LSS_RETURN(type,__res)
805 #undef _syscall0
806 #define _syscall0(type,name) \
807 type LSS_NAME(name)(void) { \
808 long __res; \
809 __asm__ volatile("int $0x80" \
810 : "=a" (__res) \
811 : "0" (__NR_##name) \
812 : "memory"); \
813 LSS_RETURN(type,__res); \
814 }
815 #undef _syscall1
816 #define _syscall1(type,name,type1,arg1) \
817 type LSS_NAME(name)(type1 arg1) { \
818 LSS_BODY(type, \
819 : "=a" (__res) \
820 : "0" (__NR_##name), "ri" ((long)(arg1))); \
821 }
822 #undef _syscall2
823 #define _syscall2(type,name,type1,arg1,type2,arg2) \
824 type LSS_NAME(name)(type1 arg1,type2 arg2) { \
825 LSS_BODY(type, \
826 : "=a" (__res) \
827 : "0" (__NR_##name),"ri" ((long)(arg1)), "c" ((long)(arg2))); \
828 }
829 #undef _syscall3
830 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
831 type LSS_NAME(name)(type1 arg1,type2 arg2,type3 arg3) { \
832 LSS_BODY(type, \
833 : "=a" (__res) \
834 : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)), \
835 "d" ((long)(arg3))); \
836 }
837 #undef _syscall4
838 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
839 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
840 LSS_BODY(type, \
841 : "=a" (__res) \
842 : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)), \
843 "d" ((long)(arg3)),"S" ((long)(arg4))); \
844 }
845 #undef _syscall5
846 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
847 type5,arg5) \
848 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
849 type5 arg5) { \
850 long __res; \
851 __asm__ __volatile__("push %%ebx\n" \
852 "movl %2,%%ebx\n" \
853 "movl %1,%%eax\n" \
854 "int $0x80\n" \
855 "pop %%ebx" \
856 : "=a" (__res) \
857 : "i" (__NR_##name), "ri" ((long)(arg1)), \
858 "c" ((long)(arg2)), "d" ((long)(arg3)), \
859 "S" ((long)(arg4)), "D" ((long)(arg5)) \
860 : "esp", "memory"); \
861 LSS_RETURN(type,__res); \
862 }
863 #undef _syscall6
864 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
865 type5,arg5,type6,arg6) \
866 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
867 type5 arg5, type6 arg6) { \
868 long __res; \
869 struct { long __a1; long __a6; } __s = { (long)arg1, (long) arg6 }; \
870 __asm__ __volatile__("push %%ebp\n" \
871 "push %%ebx\n" \
872 "movl 4(%2),%%ebp\n" \
873 "movl 0(%2), %%ebx\n" \
874 "movl %1,%%eax\n" \
875 "int $0x80\n" \
876 "pop %%ebx\n" \
877 "pop %%ebp" \
878 : "=a" (__res) \
879 : "i" (__NR_##name), "0" ((long)(&__s)), \
880 "c" ((long)(arg2)), "d" ((long)(arg3)), \
881 "S" ((long)(arg4)), "D" ((long)(arg5)) \
882 : "esp", "memory"); \
883 LSS_RETURN(type,__res); \
884 }
885 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
886 int flags, void *arg, int *parent_tidptr,
887 void *newtls, int *child_tidptr) {
888 long __res;
889 __asm__ __volatile__(/* if (fn == NULL)
890 * return -EINVAL;
891 */
892 "movl %3,%%ecx\n"
893 "jecxz 1f\n"
894
895 /* if (child_stack == NULL)
896 * return -EINVAL;
897 */
898 "movl %4,%%ecx\n"
899 "jecxz 1f\n"
900
901 /* Set up alignment of the child stack:
902 * child_stack = (child_stack & ~0xF) - 20;
903 */
904 "andl $-16,%%ecx\n"
905 "subl $20,%%ecx\n"
906
907 /* Push "arg" and "fn" onto the stack that will be
908 * used by the child.
909 */
910 "movl %6,%%eax\n"
911 "movl %%eax,4(%%ecx)\n"
912 "movl %3,%%eax\n"
913 "movl %%eax,(%%ecx)\n"
914
915 /* %eax = syscall(%eax = __NR_clone,
916 * %ebx = flags,
917 * %ecx = child_stack,
918 * %edx = parent_tidptr,
919 * %esi = newtls,
920 * %edi = child_tidptr)
921 * Also, make sure that %ebx gets preserved as it is
922 * used in PIC mode.
923 */
924 "movl %8,%%esi\n"
925 "movl %7,%%edx\n"
926 "movl %5,%%eax\n"
927 "movl %9,%%edi\n"
928 "pushl %%ebx\n"
929 "movl %%eax,%%ebx\n"
930 "movl %2,%%eax\n"
931 "int $0x80\n"
932
933 /* In the parent: restore %ebx
934 * In the child: move "fn" into %ebx
935 */
936 "popl %%ebx\n"
937
938 /* if (%eax != 0)
939 * return %eax;
940 */
941 "test %%eax,%%eax\n"
942 "jnz 1f\n"
943
944 /* In the child, now. Terminate frame pointer chain.
945 */
946 "movl $0,%%ebp\n"
947
948 /* Call "fn". "arg" is already on the stack.
949 */
950 "call *%%ebx\n"
951
952 /* Call _exit(%ebx). Unfortunately older versions
953 * of gcc restrict the number of arguments that can
954 * be passed to asm(). So, we need to hard-code the
955 * system call number.
956 */
957 "movl %%eax,%%ebx\n"
958 "movl $1,%%eax\n"
959 "int $0x80\n"
960
961 /* Return to parent.
962 */
963 "1:\n"
964 : "=a" (__res)
965 : "0"(-EINVAL), "i"(__NR_clone),
966 "m"(fn), "m"(child_stack), "m"(flags), "m"(arg),
967 "m"(parent_tidptr), "m"(newtls), "m"(child_tidptr)
968 : "esp", "memory", "ecx", "edx", "esi", "edi");
969 LSS_RETURN(int, __res);
970 }
971
972 LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) {
973 /* On i386, the kernel does not know how to return from a signal
974 * handler. Instead, it relies on user space to provide a
975 * restorer function that calls the {rt_,}sigreturn() system call.
976 * Unfortunately, we cannot just reference the glibc version of this
977 * function, as glibc goes out of its way to make it inaccessible.
978 */
979 void (*res)(void);
980 __asm__ __volatile__("call 2f\n"
981 "0:.align 16\n"
982 "1:movl %1,%%eax\n"
983 "int $0x80\n"
984 "2:popl %0\n"
985 "addl $(1b-0b),%0\n"
986 : "=a" (res)
987 : "i" (__NR_rt_sigreturn));
988 return res;
989 }
990 LSS_INLINE void (*LSS_NAME(restore)(void))(void) {
991 /* On i386, the kernel does not know how to return from a signal
992 * handler. Instead, it relies on user space to provide a
993 * restorer function that calls the {rt_,}sigreturn() system call.
994 * Unfortunately, we cannot just reference the glibc version of this
995 * function, as glibc goes out of its way to make it inaccessible.
996 */
997 void (*res)(void);
998 __asm__ __volatile__("call 2f\n"
999 "0:.align 16\n"
1000 "1:pop %%eax\n"
1001 "movl %1,%%eax\n"
1002 "int $0x80\n"
1003 "2:popl %0\n"
1004 "addl $(1b-0b),%0\n"
1005 : "=a" (res)
1006 : "i" (__NR_sigreturn));
1007 return res;
1008 }
1009 #elif defined(__x86_64__)
1010 /* There are no known problems with any of the _syscallX() macros
1011 * currently shipping for x86_64, but we still need to be able to define
1012 * our own version so that we can override the location of the errno
1013 * location (e.g. when using the clone() system call with the CLONE_VM
1014 * option).
1015 */
1016 #undef LSS_BODY
1017 #define LSS_BODY(type,name, ...) \
1018 long __res; \
1019 __asm__ __volatile__("syscall" : "=a" (__res) : "0" (__NR_##name), \
1020 ##__VA_ARGS__ : "r11", "rcx", "memory"); \
1021 LSS_RETURN(type, __res)
1022 #undef _syscall0
1023 #define _syscall0(type,name) \
1024 type LSS_NAME(name)() { \
1025 LSS_BODY(type, name); \
1026 }
1027 #undef _syscall1
1028 #define _syscall1(type,name,type1,arg1) \
1029 type LSS_NAME(name)(type1 arg1) { \
1030 LSS_BODY(type, name, "D" ((long)(arg1))); \
1031 }
1032 #undef _syscall2
1033 #define _syscall2(type,name,type1,arg1,type2,arg2) \
1034 type LSS_NAME(name)(type1 arg1, type2 arg2) { \
1035 LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2))); \
1036 }
1037 #undef _syscall3
1038 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
1039 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \
1040 LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)), \
1041 "d" ((long)(arg3))); \
1042 }
1043 #undef _syscall4
1044 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
1045 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
1046 long __res; \
1047 __asm__ __volatile__("movq %5,%%r10; syscall" : \
1048 "=a" (__res) : "0" (__NR_##name), \
1049 "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)), \
1050 "r" ((long)(arg4)) : "r10", "r11", "rcx", "memory"); \
1051 LSS_RETURN(type, __res); \
1052 }
1053 #undef _syscall5
1054 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
1055 type5,arg5) \
1056 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1057 type5 arg5) { \
1058 long __res; \
1059 __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8; syscall" : \
1060 "=a" (__res) : "0" (__NR_##name), \
1061 "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)), \
1062 "r" ((long)(arg4)), "r" ((long)(arg5)) : \
1063 "r8", "r10", "r11", "rcx", "memory"); \
1064 LSS_RETURN(type, __res); \
1065 }
1066 #undef _syscall6
1067 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
1068 type5,arg5,type6,arg6) \
1069 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1070 type5 arg5, type6 arg6) { \
1071 long __res; \
1072 __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8; movq %7,%%r9;" \
1073 "syscall" : \
1074 "=a" (__res) : "0" (__NR_##name), \
1075 "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)), \
1076 "r" ((long)(arg4)), "r" ((long)(arg5)), "r" ((long)(arg6)) : \
1077 "r8", "r9", "r10", "r11", "rcx", "memory"); \
1078 LSS_RETURN(type, __res); \
1079 }
1080 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
1081 int flags, void *arg, int *parent_tidptr,
1082 void *newtls, int *child_tidptr) {
1083 long __res;
1084 {
1085 __asm__ __volatile__(/* if (fn == NULL)
1086 * return -EINVAL;
1087 */
1088 "testq %4,%4\n"
1089 "jz 1f\n"
1090
1091 /* if (child_stack == NULL)
1092 * return -EINVAL;
1093 */
1094 "testq %5,%5\n"
1095 "jz 1f\n"
1096
1097 /* Set up alignment of the child stack:
1098 * child_stack = (child_stack & ~0xF) - 16;
1099 */
1100 "andq $-16,%5\n"
1101 "subq $16,%5\n"
1102
1103 /* Push "arg" and "fn" onto the stack that will be
1104 * used by the child.
1105 */
1106 "movq %7,8(%5)\n"
1107 "movq %4,0(%5)\n"
1108
1109 /* %rax = syscall(%rax = __NR_clone,
1110 * %rdi = flags,
1111 * %rsi = child_stack,
1112 * %rdx = parent_tidptr,
1113 * %r8 = new_tls,
1114 * %r10 = child_tidptr)
1115 */
1116 "movq %2,%%rax\n"
1117 "movq %9,%%r8\n"
1118 "movq %10,%%r10\n"
1119 "syscall\n"
1120
1121 /* if (%rax != 0)
1122 * return;
1123 */
1124 "testq %%rax,%%rax\n"
1125 "jnz 1f\n"
1126
1127 /* In the child. Terminate frame pointer chain.
1128 */
1129 "xorq %%rbp,%%rbp\n"
1130
1131 /* Call "fn(arg)".
1132 */
1133 "popq %%rax\n"
1134 "popq %%rdi\n"
1135 "call *%%rax\n"
1136
1137 /* Call _exit(%ebx).
1138 */
1139 "movq %%rax,%%rdi\n"
1140 "movq %3,%%rax\n"
1141 "syscall\n"
1142
1143 /* Return to parent.
1144 */
1145 "1:\n"
1146 : "=a" (__res)
1147 : "0"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit),
1148 "r"(fn), "S"(child_stack), "D"(flags), "r"(arg),
1149 "d"(parent_tidptr), "g"(newtls), "g"(child_tidptr)
1150 : "rsp", "memory", "r8", "r10", "r11", "rcx");
1151 }
1152 LSS_RETURN(int, __res);
1153 }
1154
1155 LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) {
1156 /* On x86-64, the kernel does not know how to return from
1157 * a signal handler. Instead, it relies on user space to provide a
1158 * restorer function that calls the rt_sigreturn() system call.
1159 * Unfortunately, we cannot just reference the glibc version of this
1160 * function, as glibc goes out of its way to make it inaccessible.
1161 */
1162 void (*res)(void);
1163 __asm__ __volatile__("call 2f\n"
1164 "0:.align 16\n"
1165 "1:movq %1,%%rax\n"
1166 "syscall\n"
1167 "2:popq %0\n"
1168 "addq $(1b-0b),%0\n"
1169 : "=a" (res)
1170 : "i" (__NR_rt_sigreturn));
1171 return res;
1172 }
1173 #elif defined(__arm__)
1174 /* Most definitions of _syscallX() neglect to mark "memory" as being
1175 * clobbered. This causes problems with compilers, that do a better job
1176 * at optimizing across __asm__ calls.
1177 * So, we just have to redefine all fo the _syscallX() macros.
1178 */
1179 #undef LSS_REG
1180 #define LSS_REG(r,a) register long __r##r __asm__("r"#r) = (long)a
1181
1182 /* r0..r3 are scratch registers and not preserved across function
1183 * calls. We need to first evaluate the first 4 syscall arguments
1184 * and store them on stack. They must be loaded into r0..r3 after
1185 * all function calls to avoid r0..r3 being clobbered.
1186 */
1187 #undef LSS_SAVE_ARG
1188 #define LSS_SAVE_ARG(r,a) long __tmp##r = (long)a
1189 #undef LSS_LOAD_ARG
1190 #define LSS_LOAD_ARG(r) register long __r##r __asm__("r"#r) = __tmp##r
1191
1192 #undef LSS_BODY
1193 #define LSS_BODY(type, name, args...) \
1194 register long __res_r0 __asm__("r0"); \
1195 long __res; \
1196 __SYS_REG(name) \
1197 __asm__ __volatile__ (__syscall_safe(name) \
1198 : "=r"(__res_r0) \
1199 : __SYS_REG_LIST(args) \
1200 : "lr", "memory"); \
1201 __res = __res_r0; \
1202 LSS_RETURN(type, __res)
1203 #undef _syscall0
1204 #define _syscall0(type, name) \
1205 type LSS_NAME(name)() { \
1206 LSS_BODY(type, name); \
1207 }
1208 #undef _syscall1
1209 #define _syscall1(type, name, type1, arg1) \
1210 type LSS_NAME(name)(type1 arg1) { \
1211 /* There is no need for using a volatile temp. */ \
1212 LSS_REG(0, arg1); \
1213 LSS_BODY(type, name, "r"(__r0)); \
1214 }
1215 #undef _syscall2
1216 #define _syscall2(type, name, type1, arg1, type2, arg2) \
1217 type LSS_NAME(name)(type1 arg1, type2 arg2) { \
1218 LSS_SAVE_ARG(0, arg1); \
1219 LSS_SAVE_ARG(1, arg2); \
1220 LSS_LOAD_ARG(0); \
1221 LSS_LOAD_ARG(1); \
1222 LSS_BODY(type, name, "r"(__r0), "r"(__r1)); \
1223 }
1224 #undef _syscall3
1225 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
1226 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \
1227 LSS_SAVE_ARG(0, arg1); \
1228 LSS_SAVE_ARG(1, arg2); \
1229 LSS_SAVE_ARG(2, arg3); \
1230 LSS_LOAD_ARG(0); \
1231 LSS_LOAD_ARG(1); \
1232 LSS_LOAD_ARG(2); \
1233 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2)); \
1234 }
1235 #undef _syscall4
1236 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
1237 type4, arg4) \
1238 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
1239 LSS_SAVE_ARG(0, arg1); \
1240 LSS_SAVE_ARG(1, arg2); \
1241 LSS_SAVE_ARG(2, arg3); \
1242 LSS_SAVE_ARG(3, arg4); \
1243 LSS_LOAD_ARG(0); \
1244 LSS_LOAD_ARG(1); \
1245 LSS_LOAD_ARG(2); \
1246 LSS_LOAD_ARG(3); \
1247 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3)); \
1248 }
1249 #undef _syscall5
1250 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
1251 type4, arg4, type5, arg5) \
1252 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1253 type5 arg5) { \
1254 LSS_SAVE_ARG(0, arg1); \
1255 LSS_SAVE_ARG(1, arg2); \
1256 LSS_SAVE_ARG(2, arg3); \
1257 LSS_SAVE_ARG(3, arg4); \
1258 LSS_REG(4, arg5); \
1259 LSS_LOAD_ARG(0); \
1260 LSS_LOAD_ARG(1); \
1261 LSS_LOAD_ARG(2); \
1262 LSS_LOAD_ARG(3); \
1263 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \
1264 "r"(__r4)); \
1265 }
1266 #undef _syscall6
1267 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
1268 type4, arg4, type5, arg5, type6, arg6) \
1269 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1270 type5 arg5, type6 arg6) { \
1271 LSS_SAVE_ARG(0, arg1); \
1272 LSS_SAVE_ARG(1, arg2); \
1273 LSS_SAVE_ARG(2, arg3); \
1274 LSS_SAVE_ARG(3, arg4); \
1275 LSS_REG(4, arg5); \
1276 LSS_REG(5, arg6); \
1277 LSS_LOAD_ARG(0); \
1278 LSS_LOAD_ARG(1); \
1279 LSS_LOAD_ARG(2); \
1280 LSS_LOAD_ARG(3); \
1281 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \
1282 "r"(__r4), "r"(__r5)); \
1283 }
1284 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
1285 int flags, void *arg, int *parent_tidptr,
1286 void *newtls, int *child_tidptr) {
1287 register long __res __asm__("r5");
1288 {
1289 if (fn == NULL || child_stack == NULL) {
1290 __res = -EINVAL;
1291 goto clone_exit;
1292 }
1293
1294 /* stash first 4 arguments on stack first because we can only load
1295 * them after all function calls.
1296 */
1297 int tmp_flags = flags;
1298 int * tmp_stack = (int*) child_stack;
1299 void * tmp_ptid = parent_tidptr;
1300 void * tmp_tls = newtls;
1301
1302 register int *__ctid __asm__("r4") = child_tidptr;
1303
1304 /* Push "arg" and "fn" onto the stack that will be
1305 * used by the child.
1306 */
1307 *(--tmp_stack) = (int) arg;
1308 *(--tmp_stack) = (int) fn;
1309
1310 /* We must load r0..r3 last after all possible function calls. */
1311 register int __flags __asm__("r0") = tmp_flags;
1312 register void *__stack __asm__("r1") = tmp_stack;
1313 register void *__ptid __asm__("r2") = tmp_ptid;
1314 register void *__tls __asm__("r3") = tmp_tls;
1315
1316 /* %r0 = syscall(%r0 = flags,
1317 * %r1 = child_stack,
1318 * %r2 = parent_tidptr,
1319 * %r3 = newtls,
1320 * %r4 = child_tidptr)
1321 */
1322 __SYS_REG(clone)
1323 __asm__ __volatile__(/* %r0 = syscall(%r0 = flags,
1324 * %r1 = child_stack,
1325 * %r2 = parent_tidptr,
1326 * %r3 = newtls,
1327 * %r4 = child_tidptr)
1328 */
1329 "push {r7}\n"
1330 "mov r7,%1\n"
1331 __syscall(clone)"\n"
1332
1333 /* if (%r0 != 0)
1334 * return %r0;
1335 */
1336 "movs %0,r0\n"
1337 "bne 1f\n"
1338
1339 /* In the child, now. Call "fn(arg)".
1340 */
1341 "ldr r0,[sp, #4]\n"
1342 "mov lr,pc\n"
1343 "ldr pc,[sp]\n"
1344
1345 /* Call _exit(%r0), which never returns. We only
1346 * need to set r7 for EABI syscall ABI but we do
1347 * this always to simplify code sharing between
1348 * old and new syscall ABIs.
1349 */
1350 "mov r7,%2\n"
1351 __syscall(exit)"\n"
1352
1353 /* Pop r7 from the stack only in the parent.
1354 */
1355 "1: pop {r7}\n"
1356 : "=r" (__res)
1357 : "r"(__sysreg),
1358 "i"(__NR_exit), "r"(__stack), "r"(__flags),
1359 "r"(__ptid), "r"(__tls), "r"(__ctid)
1360 : "cc", "lr", "memory");
1361 }
1362 clone_exit:
1363 LSS_RETURN(int, __res);
1364 }
1365 #elif defined(__mips__)
1366 #undef LSS_REG
1367 #define LSS_REG(r,a) register unsigned long __r##r __asm__("$"#r) = \
1368 (unsigned long)(a)
1369
1370 #if _MIPS_SIM == _MIPS_SIM_ABI32
1371 // See http://sources.redhat.com/ml/libc-alpha/2004-10/msg00050.html
1372 // or http://www.linux-mips.org/archives/linux-mips/2004-10/msg00142.html
1373 #define MIPS_SYSCALL_CLOBBERS "$1", "$3", "$8", "$9", "$10", "$11", "$12",\
1374 "$13", "$14", "$15", "$24", "$25", "memory"
1375 #else
1376 #define MIPS_SYSCALL_CLOBBERS "$1", "$3", "$10", "$11", "$12", "$13", \
1377 "$14", "$15", "$24", "$25", "memory"
1378 #endif
1379
1380 #undef LSS_BODY
1381 #define LSS_BODY(type,name,r7,...) \
1382 register unsigned long __v0 __asm__("$2") = __NR_##name; \
1383 __asm__ __volatile__ ("syscall\n" \
1384 : "=&r"(__v0), r7 (__r7) \
1385 : "0"(__v0), ##__VA_ARGS__ \
1386 : MIPS_SYSCALL_CLOBBERS); \
1387 LSS_RETURN(type, __v0, __r7)
1388 #undef _syscall0
1389 #define _syscall0(type, name) \
1390 type LSS_NAME(name)() { \
1391 register unsigned long __r7 __asm__("$7"); \
1392 LSS_BODY(type, name, "=r"); \
1393 }
1394 #undef _syscall1
1395 #define _syscall1(type, name, type1, arg1) \
1396 type LSS_NAME(name)(type1 arg1) { \
1397 register unsigned long __r7 __asm__("$7"); \
1398 LSS_REG(4, arg1); LSS_BODY(type, name, "=r", "r"(__r4)); \
1399 }
1400 #undef _syscall2
1401 #define _syscall2(type, name, type1, arg1, type2, arg2) \
1402 type LSS_NAME(name)(type1 arg1, type2 arg2) { \
1403 register unsigned long __r7 __asm__("$7"); \
1404 LSS_REG(4, arg1); LSS_REG(5, arg2); \
1405 LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5)); \
1406 }
1407 #undef _syscall3
1408 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
1409 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \
1410 register unsigned long __r7 __asm__("$7"); \
1411 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \
1412 LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5), "r"(__r6)); \
1413 }
1414 #undef _syscall4
1415 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
1416 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
1417 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \
1418 LSS_REG(7, arg4); \
1419 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6)); \
1420 }
1421 #undef _syscall5
1422 #if _MIPS_SIM == _MIPS_SIM_ABI32
1423 /* The old 32bit MIPS system call API passes the fifth and sixth argument
1424 * on the stack, whereas the new APIs use registers "r8" and "r9".
1425 */
1426 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
1427 type5,arg5) \
1428 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1429 type5 arg5) { \
1430 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \
1431 LSS_REG(7, arg4); \
1432 register unsigned long __v0 __asm__("$2"); \
1433 __asm__ __volatile__ (".set noreorder\n" \
1434 "lw $2, %6\n" \
1435 "subu $29, 32\n" \
1436 "sw $2, 16($29)\n" \
1437 "li $2, %2\n" \
1438 "syscall\n" \
1439 "addiu $29, 32\n" \
1440 ".set reorder\n" \
1441 : "=&r"(__v0), "+r" (__r7) \
1442 : "i" (__NR_##name), "r"(__r4), "r"(__r5), \
1443 "r"(__r6), "m" ((unsigned long)arg5) \
1444 : MIPS_SYSCALL_CLOBBERS); \
1445 LSS_RETURN(type, __v0, __r7); \
1446 }
1447 #else
1448 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
1449 type5,arg5) \
1450 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1451 type5 arg5) { \
1452 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \
1453 LSS_REG(7, arg4); LSS_REG(8, arg5); \
1454 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6), \
1455 "r"(__r8)); \
1456 }
1457 #endif
1458 #undef _syscall6
1459 #if _MIPS_SIM == _MIPS_SIM_ABI32
1460 /* The old 32bit MIPS system call API passes the fifth and sixth argument
1461 * on the stack, whereas the new APIs use registers "r8" and "r9".
1462 */
1463 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
1464 type5,arg5,type6,arg6) \
1465 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1466 type5 arg5, type6 arg6) { \
1467 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \
1468 LSS_REG(7, arg4); \
1469 register unsigned long __v0 __asm__("$2"); \
1470 __asm__ __volatile__ (".set noreorder\n" \
1471 "lw $2, %6\n" \
1472 "lw $8, %7\n" \
1473 "subu $29, 32\n" \
1474 "sw $2, 16($29)\n" \
1475 "sw $8, 20($29)\n" \
1476 "li $2, %2\n" \
1477 "syscall\n" \
1478 "addiu $29, 32\n" \
1479 ".set reorder\n" \
1480 : "=&r"(__v0), "+r" (__r7) \
1481 : "i" (__NR_##name), "r"(__r4), "r"(__r5), \
1482 "r"(__r6), "r" ((unsigned long)arg5), \
1483 "r" ((unsigned long)arg6) \
1484 : MIPS_SYSCALL_CLOBBERS); \
1485 LSS_RETURN(type, __v0, __r7); \
1486 }
1487 #else
1488 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
1489 type5,arg5,type6,arg6) \
1490 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1491 type5 arg5,type6 arg6) { \
1492 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \
1493 LSS_REG(7, arg4); LSS_REG(8, arg5); LSS_REG(9, arg6); \
1494 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6), \
1495 "r"(__r8), "r"(__r9)); \
1496 }
1497 #endif
1498 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
1499 int flags, void *arg, int *parent_tidptr,
1500 void *newtls, int *child_tidptr) {
1501 register unsigned long __v0 __asm__("$2");
1502 register unsigned long __r7 __asm__("$7") = (unsigned long)newtls;
1503 {
1504 register int __flags __asm__("$4") = flags;
1505 register void *__stack __asm__("$5") = child_stack;
1506 register void *__ptid __asm__("$6") = parent_tidptr;
1507 register int *__ctid __asm__("$8") = child_tidptr;
1508 __asm__ __volatile__(
1509 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32
1510 "subu $29,24\n"
1511 #elif _MIPS_SIM == _MIPS_SIM_NABI32
1512 "sub $29,16\n"
1513 #else
1514 "dsubu $29,16\n"
1515 #endif
1516
1517 /* if (fn == NULL || child_stack == NULL)
1518 * return -EINVAL;
1519 */
1520 "li %0,%2\n"
1521 "beqz %5,1f\n"
1522 "beqz %6,1f\n"
1523
1524 /* Push "arg" and "fn" onto the stack that will be
1525 * used by the child.
1526 */
1527 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32
1528 "subu %6,32\n"
1529 "sw %5,0(%6)\n"
1530 "sw %8,4(%6)\n"
1531 #elif _MIPS_SIM == _MIPS_SIM_NABI32
1532 "sub %6,32\n"
1533 "sw %5,0(%6)\n"
1534 "sw %8,8(%6)\n"
1535 #else
1536 "dsubu %6,32\n"
1537 "sd %5,0(%6)\n"
1538 "sd %8,8(%6)\n"
1539 #endif
1540
1541 /* $7 = syscall($4 = flags,
1542 * $5 = child_stack,
1543 * $6 = parent_tidptr,
1544 * $7 = newtls,
1545 * $8 = child_tidptr)
1546 */
1547 "li $2,%3\n"
1548 "syscall\n"
1549
1550 /* if ($7 != 0)
1551 * return $2;
1552 */
1553 "bnez $7,1f\n"
1554 "bnez $2,1f\n"
1555
1556 /* In the child, now. Call "fn(arg)".
1557 */
1558 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32
1559 "lw $25,0($29)\n"
1560 "lw $4,4($29)\n"
1561 #elif _MIPS_SIM == _MIPS_SIM_NABI32
1562 "lw $25,0($29)\n"
1563 "lw $4,8($29)\n"
1564 #else
1565 "ld $25,0($29)\n"
1566 "ld $4,8($29)\n"
1567 #endif
1568 "jalr $25\n"
1569
1570 /* Call _exit($2)
1571 */
1572 "move $4,$2\n"
1573 "li $2,%4\n"
1574 "syscall\n"
1575
1576 "1:\n"
1577 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32
1578 "addu $29, 24\n"
1579 #elif _MIPS_SIM == _MIPS_SIM_NABI32
1580 "add $29, 16\n"
1581 #else
1582 "daddu $29,16\n"
1583 #endif
1584 : "=&r" (__v0), "=r" (__r7)
1585 : "i"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit),
1586 "r"(fn), "r"(__stack), "r"(__flags), "r"(arg),
1587 "r"(__ptid), "r"(__r7), "r"(__ctid)
1588 : "$9", "$10", "$11", "$12", "$13", "$14", "$15",
1589 "$24", "memory");
1590 }
1591 LSS_RETURN(int, __v0, __r7);
1592 }
1593 #elif defined (__PPC__)
1594 #undef LSS_LOADARGS_0
1595 #define LSS_LOADARGS_0(name, dummy...) \
1596 __sc_0 = __NR_##name
1597 #undef LSS_LOADARGS_1
1598 #define LSS_LOADARGS_1(name, arg1) \
1599 LSS_LOADARGS_0(name); \
1600 __sc_3 = (unsigned long) (arg1)
1601 #undef LSS_LOADARGS_2
1602 #define LSS_LOADARGS_2(name, arg1, arg2) \
1603 LSS_LOADARGS_1(name, arg1); \
1604 __sc_4 = (unsigned long) (arg2)
1605 #undef LSS_LOADARGS_3
1606 #define LSS_LOADARGS_3(name, arg1, arg2, arg3) \
1607 LSS_LOADARGS_2(name, arg1, arg2); \
1608 __sc_5 = (unsigned long) (arg3)
1609 #undef LSS_LOADARGS_4
1610 #define LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4) \
1611 LSS_LOADARGS_3(name, arg1, arg2, arg3); \
1612 __sc_6 = (unsigned long) (arg4)
1613 #undef LSS_LOADARGS_5
1614 #define LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5) \
1615 LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4); \
1616 __sc_7 = (unsigned long) (arg5)
1617 #undef LSS_LOADARGS_6
1618 #define LSS_LOADARGS_6(name, arg1, arg2, arg3, arg4, arg5, arg6) \
1619 LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5); \
1620 __sc_8 = (unsigned long) (arg6)
1621 #undef LSS_ASMINPUT_0
1622 #define LSS_ASMINPUT_0 "0" (__sc_0)
1623 #undef LSS_ASMINPUT_1
1624 #define LSS_ASMINPUT_1 LSS_ASMINPUT_0, "1" (__sc_3)
1625 #undef LSS_ASMINPUT_2
1626 #define LSS_ASMINPUT_2 LSS_ASMINPUT_1, "2" (__sc_4)
1627 #undef LSS_ASMINPUT_3
1628 #define LSS_ASMINPUT_3 LSS_ASMINPUT_2, "3" (__sc_5)
1629 #undef LSS_ASMINPUT_4
1630 #define LSS_ASMINPUT_4 LSS_ASMINPUT_3, "4" (__sc_6)
1631 #undef LSS_ASMINPUT_5
1632 #define LSS_ASMINPUT_5 LSS_ASMINPUT_4, "5" (__sc_7)
1633 #undef LSS_ASMINPUT_6
1634 #define LSS_ASMINPUT_6 LSS_ASMINPUT_5, "6" (__sc_8)
1635 #undef LSS_BODY
1636 #define LSS_BODY(nr, type, name, args...) \
1637 long __sc_ret, __sc_err; \
1638 { \
1639 register unsigned long __sc_0 __asm__ ("r0"); \
1640 register unsigned long __sc_3 __asm__ ("r3"); \
1641 register unsigned long __sc_4 __asm__ ("r4"); \
1642 register unsigned long __sc_5 __asm__ ("r5"); \
1643 register unsigned long __sc_6 __asm__ ("r6"); \
1644 register unsigned long __sc_7 __asm__ ("r7"); \
1645 register unsigned long __sc_8 __asm__ ("r8"); \
1646 \
1647 LSS_LOADARGS_##nr(name, args); \
1648 __asm__ __volatile__ \
1649 ("sc\n\t" \
1650 "mfcr %0" \
1651 : "=&r" (__sc_0), \
1652 "=&r" (__sc_3), "=&r" (__sc_4), \
1653 "=&r" (__sc_5), "=&r" (__sc_6), \
1654 "=&r" (__sc_7), "=&r" (__sc_8) \
1655 : LSS_ASMINPUT_##nr \
1656 : "cr0", "ctr", "memory", \
1657 "r9", "r10", "r11", "r12"); \
1658 __sc_ret = __sc_3; \
1659 __sc_err = __sc_0; \
1660 } \
1661 LSS_RETURN(type, __sc_ret, __sc_err)
1662 #undef _syscall0
1663 #define _syscall0(type, name) \
1664 type LSS_NAME(name)(void) { \
1665 LSS_BODY(0, type, name); \
1666 }
1667 #undef _syscall1
1668 #define _syscall1(type, name, type1, arg1) \
1669 type LSS_NAME(name)(type1 arg1) { \
1670 LSS_BODY(1, type, name, arg1); \
1671 }
1672 #undef _syscall2
1673 #define _syscall2(type, name, type1, arg1, type2, arg2) \
1674 type LSS_NAME(name)(type1 arg1, type2 arg2) { \
1675 LSS_BODY(2, type, name, arg1, arg2); \
1676 }
1677 #undef _syscall3
1678 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
1679 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \
1680 LSS_BODY(3, type, name, arg1, arg2, arg3); \
1681 }
1682 #undef _syscall4
1683 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
1684 type4, arg4) \
1685 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
1686 LSS_BODY(4, type, name, arg1, arg2, arg3, arg4); \
1687 }
1688 #undef _syscall5
1689 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
1690 type4, arg4, type5, arg5) \
1691 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1692 type5 arg5) { \
1693 LSS_BODY(5, type, name, arg1, arg2, arg3, arg4, arg5); \
1694 }
1695 #undef _syscall6
1696 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
1697 type4, arg4, type5, arg5, type6, arg6) \
1698 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
1699 type5 arg5, type6 arg6) { \
1700 LSS_BODY(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6); \
1701 }
1702 /* clone function adapted from glibc 2.3.6 clone.S */
1703 /* TODO(csilvers): consider wrapping some args up in a struct, like we
1704 * do for i386's _syscall6, so we can compile successfully on gcc 2.95
1705 */
1706 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
1707 int flags, void *arg, int *parent_tidptr,
1708 void *newtls, int *child_tidptr) {
1709 long __ret, __err;
1710 {
1711 register int (*__fn)(void *) __asm__ ("r8") = fn;
1712 register void *__cstack __asm__ ("r4") = child_stack;
1713 register int __flags __asm__ ("r3") = flags;
1714 register void * __arg __asm__ ("r9") = arg;
1715 register int * __ptidptr __asm__ ("r5") = parent_tidptr;
1716 register void * __newtls __asm__ ("r6") = newtls;
1717 register int * __ctidptr __asm__ ("r7") = child_tidptr;
1718 __asm__ __volatile__(
1719 /* check for fn == NULL
1720 * and child_stack == NULL
1721 */
1722 "cmpwi cr0, %6, 0\n\t"
1723 "cmpwi cr1, %7, 0\n\t"
1724 "cror cr0*4+eq, cr1*4+eq, cr0*4+eq\n\t"
1725 "beq- cr0, 1f\n\t"
1726
1727 /* set up stack frame for child */
1728 "clrrwi %7, %7, 4\n\t"
1729 "li 0, 0\n\t"
1730 "stwu 0, -16(%7)\n\t"
1731
1732 /* fn, arg, child_stack are saved across the syscall: r28-30 */
1733 "mr 28, %6\n\t"
1734 "mr 29, %7\n\t"
1735 "mr 27, %9\n\t"
1736
1737 /* syscall */
1738 "li 0, %4\n\t"
1739 /* flags already in r3
1740 * child_stack already in r4
1741 * ptidptr already in r5
1742 * newtls already in r6
1743 * ctidptr already in r7
1744 */
1745 "sc\n\t"
1746
1747 /* Test if syscall was successful */
1748 "cmpwi cr1, 3, 0\n\t"
1749 "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t"
1750 "bne- cr1, 1f\n\t"
1751
1752 /* Do the function call */
1753 "mtctr 28\n\t"
1754 "mr 3, 27\n\t"
1755 "bctrl\n\t"
1756
1757 /* Call _exit(r3) */
1758 "li 0, %5\n\t"
1759 "sc\n\t"
1760
1761 /* Return to parent */
1762 "1:\n"
1763 "mfcr %1\n\t"
1764 "mr %0, 3\n\t"
1765 : "=r" (__ret), "=r" (__err)
1766 : "0" (-1), "1" (EINVAL),
1767 "i" (__NR_clone), "i" (__NR_exit),
1768 "r" (__fn), "r" (__cstack), "r" (__flags),
1769 "r" (__arg), "r" (__ptidptr), "r" (__newtls),
1770 "r" (__ctidptr)
1771 : "cr0", "cr1", "memory", "ctr",
1772 "r0", "r29", "r27", "r28");
1773 }
1774 LSS_RETURN(int, __ret, __err);
1775 }
1776 #endif
1777 #define __NR__exit __NR_exit
1778 #define __NR__gettid __NR_gettid
1779 #define __NR__mremap __NR_mremap
1780 LSS_INLINE _syscall1(int, close, int, f)
1781 LSS_INLINE _syscall1(int, _exit, int, e)
1782 LSS_INLINE _syscall3(int, fcntl, int, f,
1783 int, c, long, a)
1784 LSS_INLINE _syscall2(int, fstat, int, f,
1785 struct kernel_stat*, b)
1786 LSS_INLINE _syscall4(int, futex, int*, a,
1787 int, o, int, v,
1788 struct kernel_timespec*, t)
1789 LSS_INLINE _syscall3(int, getdents, int, f,
1790 struct kernel_dirent*, d, int, c)
1791 #ifdef __NR_getdents64
1792 LSS_INLINE _syscall3(int, getdents64, int, f,
1793 struct kernel_dirent64*, d, int, c)
1794 #endif
1795 LSS_INLINE _syscall0(pid_t, getpid)
1796 LSS_INLINE _syscall0(pid_t, getppid)
1797 LSS_INLINE _syscall0(pid_t, _gettid)
1798 LSS_INLINE _syscall2(int, kill, pid_t, p,
1799 int, s)
1800 LSS_INLINE _syscall3(off_t, lseek, int, f,
1801 off_t, o, int, w)
1802 LSS_INLINE _syscall2(int, munmap, void*, s,
1803 size_t, l)
1804 LSS_INLINE _syscall5(void*, _mremap, void*, o,
1805 size_t, os, size_t, ns,
1806 unsigned long, f, void *, a)
1807 LSS_INLINE _syscall3(int, open, const char*, p,
1808 int, f, int, m)
1809 LSS_INLINE _syscall2(int, prctl, int, o,
1810 long, a)
1811 LSS_INLINE _syscall4(long, ptrace, int, r,
1812 pid_t, p, void *, a, void *, d)
1813 LSS_INLINE _syscall3(ssize_t, read, int, f,
1814 void *, b, size_t, c)
1815 LSS_INLINE _syscall4(int, rt_sigaction, int, s,
1816 const struct kernel_sigaction*, a,
1817 struct kernel_sigaction*, o, size_t, c)
1818 LSS_INLINE _syscall4(int, rt_sigprocmask, int, h,
1819 const struct kernel_sigset_t*, s,
1820 struct kernel_sigset_t*, o, size_t, c);
1821 LSS_INLINE _syscall0(int, sched_yield)
1822 LSS_INLINE _syscall2(int, sigaltstack, const stack_t*, s,
1823 const stack_t*, o)
1824 LSS_INLINE _syscall2(int, stat, const char*, f,
1825 struct kernel_stat*, b)
1826 LSS_INLINE _syscall3(ssize_t, write, int, f,
1827 const void *, b, size_t, c)
1828 #if defined(__NR_getcpu)
1829 LSS_INLINE _syscall3(long, getcpu, unsigned *, cpu,
1830 unsigned *, node, void *, unused);
1831 #endif
1832 #if defined(__x86_64__) || \
1833 (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32)
1834 LSS_INLINE _syscall3(int, socket, int, d,
1835 int, t, int, p)
1836 #endif
1837 #if defined(__x86_64__)
1838 LSS_INLINE _syscall6(void*, mmap, void*, s,
1839 size_t, l, int, p,
1840 int, f, int, d,
1841 __off64_t, o)
1842
1843 LSS_INLINE int LSS_NAME(sigaction)(int signum,
1844 const struct kernel_sigaction *act,
1845 struct kernel_sigaction *oldact) {
1846 /* On x86_64, the kernel requires us to always set our own
1847 * SA_RESTORER in order to be able to return from a signal handler.
1848 * This function must have a "magic" signature that the "gdb"
1849 * (and maybe the kernel?) can recognize.
1850 */
1851 if (act != NULL && !(act->sa_flags & SA_RESTORER)) {
1852 struct kernel_sigaction a = *act;
1853 a.sa_flags |= SA_RESTORER;
1854 a.sa_restorer = LSS_NAME(restore_rt)();
1855 return LSS_NAME(rt_sigaction)(signum, &a, oldact,
1856 (KERNEL_NSIG+7)/8);
1857 } else {
1858 return LSS_NAME(rt_sigaction)(signum, act, oldact,
1859 (KERNEL_NSIG+7)/8);
1860 }
1861 }
1862
1863 LSS_INLINE int LSS_NAME(sigprocmask)(int how,
1864 const struct kernel_sigset_t *set,
1865 struct kernel_sigset_t *oldset) {
1866 return LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8);
1867 }
1868 #endif
1869 #if defined(__x86_64__) || \
1870 defined(__arm__) || \
1871 (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32)
1872 LSS_INLINE _syscall4(pid_t, wait4, pid_t, p,
1873 int*, s, int, o,
1874 struct kernel_rusage*, r)
1875 LSS_INLINE pid_t LSS_NAME(waitpid)(pid_t pid, int *status, int options){
1876 return LSS_NAME(wait4)(pid, status, options, 0);
1877 }
1878 #endif
1879 #if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
1880 LSS_INLINE _syscall4(int, openat, int, d, const char *, p, int, f, int, m)
1881 #endif
1882 LSS_INLINE int LSS_NAME(sigemptyset)(struct kernel_sigset_t *set) {
1883 memset(&set->sig, 0, sizeof(set->sig));
1884 return 0;
1885 }
1886
1887 LSS_INLINE int LSS_NAME(sigfillset)(struct kernel_sigset_t *set) {
1888 memset(&set->sig, -1, sizeof(set->sig));
1889 return 0;
1890 }
1891
1892 LSS_INLINE int LSS_NAME(sigaddset)(struct kernel_sigset_t *set,
1893 int signum) {
1894 if (signum < 1 || signum > (int)(8*sizeof(set->sig))) {
1895 LSS_ERRNO = EINVAL;
1896 return -1;
1897 } else {
1898 set->sig[(signum - 1)/(8*sizeof(set->sig[0]))]
1899 |= 1UL << ((signum - 1) % (8*sizeof(set->sig[0])));
1900 return 0;
1901 }
1902 }
1903
1904 LSS_INLINE int LSS_NAME(sigdelset)(struct kernel_sigset_t *set,
1905 int signum) {
1906 if (signum < 1 || signum > (int)(8*sizeof(set->sig))) {
1907 LSS_ERRNO = EINVAL;
1908 return -1;
1909 } else {
1910 set->sig[(signum - 1)/(8*sizeof(set->sig[0]))]
1911 &= ~(1UL << ((signum - 1) % (8*sizeof(set->sig[0]))));
1912 return 0;
1913 }
1914 }
1915
1916 #if defined(__i386__) || \
1917 defined(__arm__) || \
1918 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || defined(__PPC__)
1919 #define __NR__sigaction __NR_sigaction
1920 #define __NR__sigprocmask __NR_sigprocmask
1921 LSS_INLINE _syscall2(int, fstat64, int, f,
1922 struct kernel_stat64 *, b)
1923 LSS_INLINE _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
1924 loff_t *, res, uint, wh)
1925 #ifdef __PPC64__
1926 LSS_INLINE _syscall6(void*, mmap, void*, s,
1927 size_t, l, int, p,
1928 int, f, int, d,
1929 off_t, o)
1930 #else
1931 #ifndef __ARM_EABI__
1932 /* Not available on ARM EABI Linux. */
1933 LSS_INLINE _syscall1(void*, mmap, void*, a)
1934 #endif
1935 LSS_INLINE _syscall6(void*, mmap2, void*, s,
1936 size_t, l, int, p,
1937 int, f, int, d,
1938 off_t, o)
1939 #endif
1940 LSS_INLINE _syscall3(int, _sigaction, int, s,
1941 const struct kernel_old_sigaction*, a,
1942 struct kernel_old_sigaction*, o)
1943 LSS_INLINE _syscall3(int, _sigprocmask, int, h,
1944 const unsigned long*, s,
1945 unsigned long*, o)
1946 LSS_INLINE _syscall2(int, stat64, const char *, p,
1947 struct kernel_stat64 *, b)
1948
1949 LSS_INLINE int LSS_NAME(sigaction)(int signum,
1950 const struct kernel_sigaction *act,
1951 struct kernel_sigaction *oldact) {
1952 int old_errno = LSS_ERRNO;
1953 int rc;
1954 struct kernel_sigaction a;
1955 if (act != NULL) {
1956 a = *act;
1957 #ifdef __i386__
1958 /* On i386, the kernel requires us to always set our own
1959 * SA_RESTORER when using realtime signals. Otherwise, it does not
1960 * know how to return from a signal handler. This function must have
1961 * a "magic" signature that the "gdb" (and maybe the kernel?) can
1962 * recognize.
1963 * Apparently, a SA_RESTORER is implicitly set by the kernel, when
1964 * using non-realtime signals.
1965 *
1966 * TODO: Test whether ARM needs a restorer
1967 */
1968 if (!(a.sa_flags & SA_RESTORER)) {
1969 a.sa_flags |= SA_RESTORER;
1970 a.sa_restorer = (a.sa_flags & SA_SIGINFO)
1971 ? LSS_NAME(restore_rt)() : LSS_NAME(restore)();
1972 }
1973 #endif
1974 }
1975 rc = LSS_NAME(rt_sigaction)(signum, act ? &a : act, oldact,
1976 (KERNEL_NSIG+7)/8);
1977 if (rc < 0 && LSS_ERRNO == ENOSYS) {
1978 struct kernel_old_sigaction oa, ooa, *ptr_a = &oa, *ptr_oa = &ooa;
1979 if (!act) {
1980 ptr_a = NULL;
1981 } else {
1982 oa.sa_handler_ = act->sa_handler_;
1983 memcpy(&oa.sa_mask, &act->sa_mask, sizeof(oa.sa_mask));
1984 #ifndef __mips__
1985 oa.sa_restorer = act->sa_restorer;
1986 #endif
1987 oa.sa_flags = act->sa_flags;
1988 }
1989 if (!oldact) {
1990 ptr_oa = NULL;
1991 }
1992 LSS_ERRNO = old_errno;
1993 rc = LSS_NAME(_sigaction)(signum, ptr_a, ptr_oa);
1994 if (rc == 0 && oldact) {
1995 if (act) {
1996 memcpy(oldact, act, sizeof(*act));
1997 } else {
1998 memset(oldact, 0, sizeof(*oldact));
1999 }
2000 oldact->sa_handler_ = ptr_oa->sa_handler_;
2001 oldact->sa_flags = ptr_oa->sa_flags;
2002 memcpy(&oldact->sa_mask, &ptr_oa->sa_mask, sizeof(ptr_oa->sa_mask));
2003 #ifndef __mips__
2004 oldact->sa_restorer = ptr_oa->sa_restorer;
2005 #endif
2006 }
2007 }
2008 return rc;
2009 }
2010
2011 LSS_INLINE int LSS_NAME(sigprocmask)(int how,
2012 const struct kernel_sigset_t *set,
2013 struct kernel_sigset_t *oldset) {
2014 int olderrno = LSS_ERRNO;
2015 int rc = LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8);
2016 if (rc < 0 && LSS_ERRNO == ENOSYS) {
2017 LSS_ERRNO = olderrno;
2018 if (oldset) {
2019 LSS_NAME(sigemptyset)(oldset);
2020 }
2021 rc = LSS_NAME(_sigprocmask)(how,
2022 set ? &set->sig[0] : NULL,
2023 oldset ? &oldset->sig[0] : NULL);
2024 }
2025 return rc;
2026 }
2027 #endif
2028 #if defined(__PPC__)
2029 #undef LSS_SC_LOADARGS_0
2030 #define LSS_SC_LOADARGS_0(dummy...)
2031 #undef LSS_SC_LOADARGS_1
2032 #define LSS_SC_LOADARGS_1(arg1) \
2033 __sc_4 = (unsigned long) (arg1)
2034 #undef LSS_SC_LOADARGS_2
2035 #define LSS_SC_LOADARGS_2(arg1, arg2) \
2036 LSS_SC_LOADARGS_1(arg1); \
2037 __sc_5 = (unsigned long) (arg2)
2038 #undef LSS_SC_LOADARGS_3
2039 #define LSS_SC_LOADARGS_3(arg1, arg2, arg3) \
2040 LSS_SC_LOADARGS_2(arg1, arg2); \
2041 __sc_6 = (unsigned long) (arg3)
2042 #undef LSS_SC_LOADARGS_4
2043 #define LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4) \
2044 LSS_SC_LOADARGS_3(arg1, arg2, arg3); \
2045 __sc_7 = (unsigned long) (arg4)
2046 #undef LSS_SC_LOADARGS_5
2047 #define LSS_SC_LOADARGS_5(arg1, arg2, arg3, arg4, arg5) \
2048 LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4); \
2049 __sc_8 = (unsigned long) (arg5)
2050 #undef LSS_SC_BODY
2051 #define LSS_SC_BODY(nr, type, opt, args...) \
2052 long __sc_ret, __sc_err; \
2053 { \
2054 register unsigned long __sc_0 __asm__ ("r0") = __NR_socketcall; \
2055 register unsigned long __sc_3 __asm__ ("r3") = opt; \
2056 register unsigned long __sc_4 __asm__ ("r4"); \
2057 register unsigned long __sc_5 __asm__ ("r5"); \
2058 register unsigned long __sc_6 __asm__ ("r6"); \
2059 register unsigned long __sc_7 __asm__ ("r7"); \
2060 register unsigned long __sc_8 __asm__ ("r8"); \
2061 LSS_SC_LOADARGS_##nr(args); \
2062 __asm__ __volatile__ \
2063 ("stwu 1, -48(1)\n\t" \
2064 "stw 4, 20(1)\n\t" \
2065 "stw 5, 24(1)\n\t" \
2066 "stw 6, 28(1)\n\t" \
2067 "stw 7, 32(1)\n\t" \
2068 "stw 8, 36(1)\n\t" \
2069 "addi 4, 1, 20\n\t" \
2070 "sc\n\t" \
2071 "mfcr %0" \
2072 : "=&r" (__sc_0), \
2073 "=&r" (__sc_3), "=&r" (__sc_4), \
2074 "=&r" (__sc_5), "=&r" (__sc_6), \
2075 "=&r" (__sc_7), "=&r" (__sc_8) \
2076 : LSS_ASMINPUT_##nr \
2077 : "cr0", "ctr", "memory"); \
2078 __sc_ret = __sc_3; \
2079 __sc_err = __sc_0; \
2080 } \
2081 LSS_RETURN(type, __sc_ret, __sc_err)
2082
2083 LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) {
2084 LSS_SC_BODY(3, int, 1, domain, type, protocol);
2085 }
2086 #endif
2087 #if defined(__i386__) || \
2088 (defined(__arm__) && !defined(__ARM_EABI__)) || \
2089 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32)
2090
2091 /* See sys_socketcall in net/socket.c in kernel source.
2092 * It de-multiplexes on its first arg and unpacks the arglist
2093 * array in its second arg.
2094 */
2095 LSS_INLINE _syscall2(long, socketcall, int, c, unsigned long*, a)
2096
2097 LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) {
2098 unsigned long args[3] = {
2099 (unsigned long) domain,
2100 (unsigned long) type,
2101 (unsigned long) protocol
2102 };
2103 return LSS_NAME(socketcall)(1, args);
2104 }
2105 #elif defined(__ARM_EABI__)
2106 LSS_INLINE _syscall3(int, socket, int, d,
2107 int, t, int, p)
2108 #endif
2109 #if defined(__i386__) || defined(__PPC__) || \
2110 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32)
2111 LSS_INLINE _syscall3(pid_t, waitpid, pid_t, p,
2112 int*, s, int, o)
2113 #endif
2114 #if defined(__mips__)
2115 /* sys_pipe() on MIPS has non-standard calling conventions, as it returns
2116 * both file handles through CPU registers.
2117 */
2118 LSS_INLINE int LSS_NAME(pipe)(int *p) {
2119 register unsigned long __v0 __asm__("$2") = __NR_pipe;
2120 register unsigned long __v1 __asm__("$3");
2121 register unsigned long __r7 __asm__("$7");
2122 __asm__ __volatile__ ("syscall\n"
2123 : "=&r"(__v0), "=&r"(__v1), "+r" (__r7)
2124 : "0"(__v0)
2125 : "$8", "$9", "$10", "$11", "$12",
2126 "$13", "$14", "$15", "$24", "memory");
2127 if (__r7) {
2128 LSS_ERRNO = __v0;
2129 return -1;
2130 } else {
2131 p[0] = __v0;
2132 p[1] = __v1;
2133 return 0;
2134 }
2135 }
2136 #else
2137 LSS_INLINE _syscall1(int, pipe, int *, p)
2138 #endif
2139
2140 LSS_INLINE pid_t LSS_NAME(gettid)() {
2141 pid_t tid = LSS_NAME(_gettid)();
2142 if (tid != -1) {
2143 return tid;
2144 }
2145 return LSS_NAME(getpid)();
2146 }
2147
2148 LSS_INLINE void *LSS_NAME(mremap)(void *old_address, size_t old_size,
2149 size_t new_size, int flags, ...) {
2150 va_list ap;
2151 void *new_address, *rc;
2152 va_start(ap, flags);
2153 new_address = va_arg(ap, void *);
2154 rc = LSS_NAME(_mremap)(old_address, old_size, new_size,
2155 flags, new_address);
2156 va_end(ap);
2157 return rc;
2158 }
2159
2160 LSS_INLINE int LSS_NAME(ptrace_detach)(pid_t pid) {
2161 /* PTRACE_DETACH can sometimes forget to wake up the tracee and it
2162 * then sends job control signals to the real parent, rather than to
2163 * the tracer. We reduce the risk of this happening by starting a
2164 * whole new time slice, and then quickly sending a SIGCONT signal
2165 * right after detaching from the tracee.
2166 */
2167 int rc, err;
2168 LSS_NAME(sched_yield)();
2169 rc = LSS_NAME(ptrace)(PTRACE_DETACH, pid, (void *)0, (void *)0);
2170 err = LSS_ERRNO;
2171 LSS_NAME(kill)(pid, SIGCONT);
2172 LSS_ERRNO = err;
2173 return rc;
2174 }
2175 #endif
2176
2177 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS)
2178 }
2179 #endif
2180
2181 #endif
2182 #endif