URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [include/] [asm-m68knommu/] [unistd.h] - Blame information for rev 1765

Details | Compare with Previous | View Log


#ifndef _ASM_M68K_UNISTD_H_
#define _ASM_M68K_UNISTD_H_
 
/*
 * This file contains the system call numbers.
 */
 
#define __NR_setup                0     /* used only by init, to get system going */
#define __NR_exit                 1
#define __NR_fork                 2
#define __NR_read                 3
#define __NR_write                4
#define __NR_open                 5
#define __NR_close                6
#define __NR_waitpid              7
#define __NR_creat                8
#define __NR_link                 9
#define __NR_unlink              10
#define __NR_execve              11
#define __NR_chdir               12
#define __NR_time                13
#define __NR_mknod               14
#define __NR_chmod               15
#define __NR_chown               16
#define __NR_break               17
#define __NR_oldstat             18
#define __NR_lseek               19
#define __NR_getpid              20
#define __NR_mount               21
#define __NR_umount              22
#define __NR_setuid              23
#define __NR_getuid              24
#define __NR_stime               25
#define __NR_ptrace              26
#define __NR_alarm               27
#define __NR_oldfstat            28
#define __NR_pause               29
#define __NR_utime               30
#define __NR_stty                31
#define __NR_gtty                32
#define __NR_access              33
#define __NR_nice                34
#define __NR_ftime               35
#define __NR_sync                36
#define __NR_kill                37
#define __NR_rename              38
#define __NR_mkdir               39
#define __NR_rmdir               40
#define __NR_dup                 41
#define __NR_pipe                42
#define __NR_times               43
#define __NR_prof                44
#define __NR_brk                 45
#define __NR_setgid              46
#define __NR_getgid              47
#define __NR_signal              48
#define __NR_geteuid             49
#define __NR_getegid             50
#define __NR_acct                51
#define __NR_phys                52
#define __NR_lock                53
#define __NR_ioctl               54
#define __NR_fcntl               55
#define __NR_mpx                 56
#define __NR_setpgid             57
#define __NR_ulimit              58
#define __NR_oldolduname         59
#define __NR_umask               60
#define __NR_chroot              61
#define __NR_ustat               62
#define __NR_dup2                63
#define __NR_getppid             64
#define __NR_getpgrp             65
#define __NR_setsid              66
#define __NR_sigaction           67
#define __NR_sgetmask            68
#define __NR_ssetmask            69
#define __NR_setreuid            70
#define __NR_setregid            71
#define __NR_sigsuspend          72
#define __NR_sigpending          73
#define __NR_sethostname         74
#define __NR_setrlimit           75
#define __NR_getrlimit           76
#define __NR_getrusage           77
#define __NR_gettimeofday        78
#define __NR_settimeofday        79
#define __NR_getgroups           80
#define __NR_setgroups           81
#define __NR_select              82
#define __NR_symlink             83
#define __NR_oldlstat            84
#define __NR_readlink            85
#define __NR_uselib              86
#define __NR_swapon              87
#define __NR_reboot              88
#define __NR_readdir             89
#define __NR_mmap                90
#define __NR_munmap              91
#define __NR_truncate            92
#define __NR_ftruncate           93
#define __NR_fchmod              94
#define __NR_fchown              95
#define __NR_getpriority         96
#define __NR_setpriority         97
#define __NR_profil              98
#define __NR_statfs              99
#define __NR_fstatfs            100
#define __NR_ioperm             101
#define __NR_socketcall         102
#define __NR_syslog             103
#define __NR_setitimer          104
#define __NR_getitimer          105
#define __NR_stat               106
#define __NR_lstat              107
#define __NR_fstat              108
#define __NR_olduname           109
#define __NR_iopl               /* 110 */ not supported
#define __NR_vhangup            111
#define __NR_idle               112
#define __NR_vm86               /* 113 */ not supported
#define __NR_wait4              114
#define __NR_swapoff            115
#define __NR_sysinfo            116
#define __NR_ipc                117
#define __NR_fsync              118
#define __NR_sigreturn          119
#define __NR_clone              120
#define __NR_setdomainname      121
#define __NR_uname              122
#define __NR_cacheflush         123
#define __NR_adjtimex           124
#define __NR_mprotect           125
#define __NR_sigprocmask        126
#define __NR_create_module      127
#define __NR_init_module        128
#define __NR_delete_module      129
#define __NR_get_kernel_syms    130
#define __NR_quotactl           131
#define __NR_getpgid            132
#define __NR_fchdir             133
#define __NR_bdflush            134
#define __NR_sysfs              135
#define __NR_personality        136
#define __NR_afs_syscall        137 /* Syscall for Andrew File System */
#define __NR_setfsuid           138
#define __NR_setfsgid           139
#define __NR__llseek            140
#define __NR_getdents           141
#define __NR__newselect         142
#define __NR_flock              143
#define __NR_msync              144
#define __NR_readv              145
#define __NR_writev             146
#define __NR_getsid             147
#define __NR_fdatasync          148
#define __NR__sysctl            149
#define __NR_mlock              150
#define __NR_munlock            151
#define __NR_mlockall           152
#define __NR_munlockall         153
#define __NR_sched_setparam             154
#define __NR_sched_getparam             155
#define __NR_sched_setscheduler         156
#define __NR_sched_getscheduler         157
#define __NR_sched_yield                158
#define __NR_sched_get_priority_max     159
#define __NR_sched_get_priority_min     160
#define __NR_sched_rr_get_interval      161
#define __NR_nanosleep          162
#define __NR_mremap             163
 
/* user-visible error numbers are in the range -1 - -122: see
   <asm-m68k/errno.h> */
 
#define __syscall_return(type, res) \
do { \
        if ((unsigned long)(res) >= (unsigned long)(-125)) { \
        /* avoid using res which is declared to be in register d0; \
           errno might expand to a function call and clobber it.  */ \
                int __err = -(res); \
                errno = __err; \
                res = -1; \
        } \
        return (type) (res); \
} while (0)
 
#define _syscall0(type,name) \
type name(void) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
__asm__ __volatile__ ("trap  #0" \
                      : "=g" (__res) \
                      : "0" (__res) \
                      : "%d0"); \
__syscall_return(type,__res); \
}
 
#define _syscall1(type,name,atype,a) \
type name(atype a) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
register long __a __asm__ ("%d1") = (long)(a); \
__asm__ __volatile__ ("trap  #0" \
                      : "=d" (__res) \
                      : "0" (__res), "d" (__a) \
                      : "%d0"); \
__syscall_return(type,__res); \
}
 
#define _syscall2(type,name,atype,a,btype,b) \
type name(atype a,btype b) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
register long __a __asm__ ("%d1") = (long)(a); \
register long __b __asm__ ("%d2") = (long)(b); \
__asm__ __volatile__ ("trap  #0" \
                      : "=d" (__res) \
                      : "0" (__res), "d" (__a), "d" (__b) \
                      : "%d0"); \
__syscall_return(type,__res); \
}
 
#define _syscall3(type,name,atype,a,btype,b,ctype,c) \
type name(atype a,btype b,ctype c) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
register long __a __asm__ ("%d1") = (long)(a); \
register long __b __asm__ ("%d2") = (long)(b); \
register long __c __asm__ ("%d3") = (long)(c); \
__asm__ __volatile__ ("trap  #0" \
                      : "=d" (__res) \
                      : "0" (__res), "d" (__a), "d" (__b), \
                        "d" (__c) \
                      : "%d0"); \
__syscall_return(type,__res); \
}
 
#define _syscall4(type,name,atype,a,btype,b,ctype,c,dtype,d) \
type name (atype a, btype b, ctype c, dtype d) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
register long __a __asm__ ("%d1") = (long)(a); \
register long __b __asm__ ("%d2") = (long)(b); \
register long __c __asm__ ("%d3") = (long)(c); \
register long __d __asm__ ("%d4") = (long)(d); \
__asm__ __volatile__ ("trap  #0" \
                      : "=d" (__res) \
                      : "0" (__res), "d" (__a), "d" (__b), \
                        "d" (__c), "d" (__d)  \
                      : "%d0"); \
__syscall_return(type,__res); \
}
 
#define _syscall5(type,name,atype,a,btype,b,ctype,c,dtype,d,etype,e) \
type name (atype a,btype b,ctype c,dtype d,etype e) \
{ \
register long __res __asm__ ("%d0") = __NR_##name; \
register long __a __asm__ ("%d1") = (long)(a); \
register long __b __asm__ ("%d2") = (long)(b); \
register long __c __asm__ ("%d3") = (long)(c); \
register long __d __asm__ ("%d4") = (long)(d); \
register long __e __asm__ ("%d5") = (long)(e); \
__asm__ __volatile__ ("trap  #0" \
                      : "=d" (__res) \
                      : "0" (__res), "d" (__a), "d" (__b), \
                        "d" (__c), "d" (__d), "d" (__e)  \
                      : "%d0"); \
__syscall_return(type,__res); \
}
 
#ifdef __KERNEL_SYSCALLS__
 
/*
 * we need this inline - forking from kernel space will result
 * in NO COPY ON WRITE (!!!), until an execve is executed. This
 * is no problem, but for the stack. This is handled by not letting
 * main() use the stack at all after fork(). Thus, no function
 * calls - which means inline code for fork too, as otherwise we
 * would use the stack upon exit from 'fork()'.
 *
 * Actually only pause and fork are needed inline, so that there
 * won't be any messing with the stack from main(), but we define
 * some others too.
 */
#define __NR__exit __NR_exit
static inline _syscall0(int,idle)
static inline _syscall0(int,fork)
static inline _syscall2(int,clone,unsigned long,flags,char *,usp)
static inline _syscall0(int,pause)
static inline _syscall0(int,setup)
static inline _syscall0(int,sync)
static inline _syscall0(pid_t,setsid)
static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
static inline _syscall1(int,dup,int,fd)
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
static inline _syscall1(int,close,int,fd)
static inline _syscall1(int,_exit,int,exitcode)
static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
 
/*
 * This is the mechanism for creating a new kernel thread.
 *
 * NOTE! Only a kernel-only process(ie the swapper or direct descendants
 * who haven't done an "execve()") should use this: it will work within
 * a system call from a "real" process, but the process memory space will
 * not be free'd until both the parent and the child have exited.
 */
static inline pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
{
        register long retval __asm__ ("d0") = __NR_clone;
        register long clone_arg __asm__ ("d1") = flags | CLONE_VM;
        unsigned long fs;
 
        fs = get_fs();
        set_fs (KERNEL_DS);
 
        __asm__ __volatile__
          ("movel %%sp,%%d2\n\t"
           "trap #0\n\t"                /* Linux/m68k system call */
           "cmpl %%sp,%%d2\n\t"         /* child or parent */
           "jeq 1f\n\t"                 /* parent - jump */
           "movel %3,%%sp@-\n\t"        /* push argument */
           "jsr %4@\n\t"                /* call fn */
           "movel %2,%0\n\t"            /* exit */
           "trap #0\n"
           "1:"
           : "=d" (retval)
           : "0" (__NR_clone), "i" (__NR_exit),
             "r" (arg), "a" (fn), "d" (clone_arg)
           : "d0", "d2");
 
        set_fs (fs);
        return retval;
}
 
static inline pid_t wait(int * wait_stat)
{
        return waitpid(-1,wait_stat,0);
}
 
#endif
 
#endif /* _ASM_M68K_UNISTD_H_ */

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [include/] [asm-m68knommu/] [unistd.h] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1633	jcastillo	`#ifndef _ASM_M68K_UNISTD_H_`
2			`#define _ASM_M68K_UNISTD_H_`
3
4			`/*`
5			`* This file contains the system call numbers.`
6			`*/`
7
8			`#define __NR_setup 0 /* used only by init, to get system going */`
9			`#define __NR_exit 1`
10			`#define __NR_fork 2`
11			`#define __NR_read 3`
12			`#define __NR_write 4`
13			`#define __NR_open 5`
14			`#define __NR_close 6`
15			`#define __NR_waitpid 7`
16			`#define __NR_creat 8`
17			`#define __NR_link 9`
18			`#define __NR_unlink 10`
19			`#define __NR_execve 11`
20			`#define __NR_chdir 12`
21			`#define __NR_time 13`
22			`#define __NR_mknod 14`
23			`#define __NR_chmod 15`
24			`#define __NR_chown 16`
25			`#define __NR_break 17`
26			`#define __NR_oldstat 18`
27			`#define __NR_lseek 19`
28			`#define __NR_getpid 20`
29			`#define __NR_mount 21`
30			`#define __NR_umount 22`
31			`#define __NR_setuid 23`
32			`#define __NR_getuid 24`
33			`#define __NR_stime 25`
34			`#define __NR_ptrace 26`
35			`#define __NR_alarm 27`
36			`#define __NR_oldfstat 28`
37			`#define __NR_pause 29`
38			`#define __NR_utime 30`
39			`#define __NR_stty 31`
40			`#define __NR_gtty 32`
41			`#define __NR_access 33`
42			`#define __NR_nice 34`
43			`#define __NR_ftime 35`
44			`#define __NR_sync 36`
45			`#define __NR_kill 37`
46			`#define __NR_rename 38`
47			`#define __NR_mkdir 39`
48			`#define __NR_rmdir 40`
49			`#define __NR_dup 41`
50			`#define __NR_pipe 42`
51			`#define __NR_times 43`
52			`#define __NR_prof 44`
53			`#define __NR_brk 45`
54			`#define __NR_setgid 46`
55			`#define __NR_getgid 47`
56			`#define __NR_signal 48`
57			`#define __NR_geteuid 49`
58			`#define __NR_getegid 50`
59			`#define __NR_acct 51`
60			`#define __NR_phys 52`
61			`#define __NR_lock 53`
62			`#define __NR_ioctl 54`
63			`#define __NR_fcntl 55`
64			`#define __NR_mpx 56`
65			`#define __NR_setpgid 57`
66			`#define __NR_ulimit 58`
67			`#define __NR_oldolduname 59`
68			`#define __NR_umask 60`
69			`#define __NR_chroot 61`
70			`#define __NR_ustat 62`
71			`#define __NR_dup2 63`
72			`#define __NR_getppid 64`
73			`#define __NR_getpgrp 65`
74			`#define __NR_setsid 66`
75			`#define __NR_sigaction 67`
76			`#define __NR_sgetmask 68`
77			`#define __NR_ssetmask 69`
78			`#define __NR_setreuid 70`
79			`#define __NR_setregid 71`
80			`#define __NR_sigsuspend 72`
81			`#define __NR_sigpending 73`
82			`#define __NR_sethostname 74`
83			`#define __NR_setrlimit 75`
84			`#define __NR_getrlimit 76`
85			`#define __NR_getrusage 77`
86			`#define __NR_gettimeofday 78`
87			`#define __NR_settimeofday 79`
88			`#define __NR_getgroups 80`
89			`#define __NR_setgroups 81`
90			`#define __NR_select 82`
91			`#define __NR_symlink 83`
92			`#define __NR_oldlstat 84`
93			`#define __NR_readlink 85`
94			`#define __NR_uselib 86`
95			`#define __NR_swapon 87`
96			`#define __NR_reboot 88`
97			`#define __NR_readdir 89`
98			`#define __NR_mmap 90`
99			`#define __NR_munmap 91`
100			`#define __NR_truncate 92`
101			`#define __NR_ftruncate 93`
102			`#define __NR_fchmod 94`
103			`#define __NR_fchown 95`
104			`#define __NR_getpriority 96`
105			`#define __NR_setpriority 97`
106			`#define __NR_profil 98`
107			`#define __NR_statfs 99`
108			`#define __NR_fstatfs 100`
109			`#define __NR_ioperm 101`
110			`#define __NR_socketcall 102`
111			`#define __NR_syslog 103`
112			`#define __NR_setitimer 104`
113			`#define __NR_getitimer 105`
114			`#define __NR_stat 106`
115			`#define __NR_lstat 107`
116			`#define __NR_fstat 108`
117			`#define __NR_olduname 109`
118			`#define __NR_iopl /* 110 */ not supported`
119			`#define __NR_vhangup 111`
120			`#define __NR_idle 112`
121			`#define __NR_vm86 /* 113 */ not supported`
122			`#define __NR_wait4 114`
123			`#define __NR_swapoff 115`
124			`#define __NR_sysinfo 116`
125			`#define __NR_ipc 117`
126			`#define __NR_fsync 118`
127			`#define __NR_sigreturn 119`
128			`#define __NR_clone 120`
129			`#define __NR_setdomainname 121`
130			`#define __NR_uname 122`
131			`#define __NR_cacheflush 123`
132			`#define __NR_adjtimex 124`
133			`#define __NR_mprotect 125`
134			`#define __NR_sigprocmask 126`
135			`#define __NR_create_module 127`
136			`#define __NR_init_module 128`
137			`#define __NR_delete_module 129`
138			`#define __NR_get_kernel_syms 130`
139			`#define __NR_quotactl 131`
140			`#define __NR_getpgid 132`
141			`#define __NR_fchdir 133`
142			`#define __NR_bdflush 134`
143			`#define __NR_sysfs 135`
144			`#define __NR_personality 136`
145			`#define __NR_afs_syscall 137 /* Syscall for Andrew File System */`
146			`#define __NR_setfsuid 138`
147			`#define __NR_setfsgid 139`
148			`#define __NR__llseek 140`
149			`#define __NR_getdents 141`
150			`#define __NR__newselect 142`
151			`#define __NR_flock 143`
152			`#define __NR_msync 144`
153			`#define __NR_readv 145`
154			`#define __NR_writev 146`
155			`#define __NR_getsid 147`
156			`#define __NR_fdatasync 148`
157			`#define __NR__sysctl 149`
158			`#define __NR_mlock 150`
159			`#define __NR_munlock 151`
160			`#define __NR_mlockall 152`
161			`#define __NR_munlockall 153`
162			`#define __NR_sched_setparam 154`
163			`#define __NR_sched_getparam 155`
164			`#define __NR_sched_setscheduler 156`
165			`#define __NR_sched_getscheduler 157`
166			`#define __NR_sched_yield 158`
167			`#define __NR_sched_get_priority_max 159`
168			`#define __NR_sched_get_priority_min 160`
169			`#define __NR_sched_rr_get_interval 161`
170			`#define __NR_nanosleep 162`
171			`#define __NR_mremap 163`
172
173			`/* user-visible error numbers are in the range -1 - -122: see`
174			`<asm-m68k/errno.h> */`
175
176			`#define __syscall_return(type, res) \`
177			`do { \`
178			`if ((unsigned long)(res) >= (unsigned long)(-125)) { \`
179			`/* avoid using res which is declared to be in register d0; \`
180			`errno might expand to a function call and clobber it. */ \`
181			`int __err = -(res); \`
182			`errno = __err; \`
183			`res = -1; \`
184			`} \`
185			`return (type) (res); \`
186			`} while (0)`
187
188			`#define _syscall0(type,name) \`
189			`type name(void) \`
190			`{ \`
191			`register long __res __asm__ ("%d0") = __NR_##name; \`
192			`__asm__ __volatile__ ("trap #0" \`
193			`: "=g" (__res) \`
194			`: "0" (__res) \`
195			`: "%d0"); \`
196			`__syscall_return(type,__res); \`
197			`}`
198
199			`#define _syscall1(type,name,atype,a) \`
200			`type name(atype a) \`
201			`{ \`
202			`register long __res __asm__ ("%d0") = __NR_##name; \`
203			`register long __a __asm__ ("%d1") = (long)(a); \`
204			`__asm__ __volatile__ ("trap #0" \`
205			`: "=d" (__res) \`
206			`: "0" (__res), "d" (__a) \`
207			`: "%d0"); \`
208			`__syscall_return(type,__res); \`
209			`}`
210
211			`#define _syscall2(type,name,atype,a,btype,b) \`
212			`type name(atype a,btype b) \`
213			`{ \`
214			`register long __res __asm__ ("%d0") = __NR_##name; \`
215			`register long __a __asm__ ("%d1") = (long)(a); \`
216			`register long __b __asm__ ("%d2") = (long)(b); \`
217			`__asm__ __volatile__ ("trap #0" \`
218			`: "=d" (__res) \`
219			`: "0" (__res), "d" (__a), "d" (__b) \`
220			`: "%d0"); \`
221			`__syscall_return(type,__res); \`
222			`}`
223
224			`#define _syscall3(type,name,atype,a,btype,b,ctype,c) \`
225			`type name(atype a,btype b,ctype c) \`
226			`{ \`
227			`register long __res __asm__ ("%d0") = __NR_##name; \`
228			`register long __a __asm__ ("%d1") = (long)(a); \`
229			`register long __b __asm__ ("%d2") = (long)(b); \`
230			`register long __c __asm__ ("%d3") = (long)(c); \`
231			`__asm__ __volatile__ ("trap #0" \`
232			`: "=d" (__res) \`
233			`: "0" (__res), "d" (__a), "d" (__b), \`
234			`"d" (__c) \`
235			`: "%d0"); \`
236			`__syscall_return(type,__res); \`
237			`}`
238
239			`#define _syscall4(type,name,atype,a,btype,b,ctype,c,dtype,d) \`
240			`type name (atype a, btype b, ctype c, dtype d) \`
241			`{ \`
242			`register long __res __asm__ ("%d0") = __NR_##name; \`
243			`register long __a __asm__ ("%d1") = (long)(a); \`
244			`register long __b __asm__ ("%d2") = (long)(b); \`
245			`register long __c __asm__ ("%d3") = (long)(c); \`
246			`register long __d __asm__ ("%d4") = (long)(d); \`
247			`__asm__ __volatile__ ("trap #0" \`
248			`: "=d" (__res) \`
249			`: "0" (__res), "d" (__a), "d" (__b), \`
250			`"d" (__c), "d" (__d) \`
251			`: "%d0"); \`
252			`__syscall_return(type,__res); \`
253			`}`
254
255			`#define _syscall5(type,name,atype,a,btype,b,ctype,c,dtype,d,etype,e) \`
256			`type name (atype a,btype b,ctype c,dtype d,etype e) \`
257			`{ \`
258			`register long __res __asm__ ("%d0") = __NR_##name; \`
259			`register long __a __asm__ ("%d1") = (long)(a); \`
260			`register long __b __asm__ ("%d2") = (long)(b); \`
261			`register long __c __asm__ ("%d3") = (long)(c); \`
262			`register long __d __asm__ ("%d4") = (long)(d); \`
263			`register long __e __asm__ ("%d5") = (long)(e); \`
264			`__asm__ __volatile__ ("trap #0" \`
265			`: "=d" (__res) \`
266			`: "0" (__res), "d" (__a), "d" (__b), \`
267			`"d" (__c), "d" (__d), "d" (__e) \`
268			`: "%d0"); \`
269			`__syscall_return(type,__res); \`
270			`}`
271
272			`#ifdef __KERNEL_SYSCALLS__`
273
274			`/*`
275			`* we need this inline - forking from kernel space will result`
276			`* in NO COPY ON WRITE (!!!), until an execve is executed. This`
277			`* is no problem, but for the stack. This is handled by not letting`
278			`* main() use the stack at all after fork(). Thus, no function`
279			`* calls - which means inline code for fork too, as otherwise we`
280			`* would use the stack upon exit from 'fork()'.`
281			`*`
282			`* Actually only pause and fork are needed inline, so that there`
283			`* won't be any messing with the stack from main(), but we define`
284			`* some others too.`
285			`*/`
286			`#define __NR__exit __NR_exit`
287			`static inline _syscall0(int,idle)`
288			`static inline _syscall0(int,fork)`
289			`static inline _syscall2(int,clone,unsigned long,flags,char *,usp)`
290			`static inline _syscall0(int,pause)`
291			`static inline _syscall0(int,setup)`
292			`static inline _syscall0(int,sync)`
293			`static inline _syscall0(pid_t,setsid)`
294			`static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)`
295			`static inline _syscall1(int,dup,int,fd)`
296			`static inline _syscall3(int,execve,const char ,file,char ,argv,char *,envp)`
297			`static inline _syscall3(int,open,const char *,file,int,flag,int,mode)`
298			`static inline _syscall1(int,close,int,fd)`
299			`static inline _syscall1(int,_exit,int,exitcode)`
300			`static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)`
301
302			`/*`
303			`* This is the mechanism for creating a new kernel thread.`
304			`*`
305			`* NOTE! Only a kernel-only process(ie the swapper or direct descendants`
306			`* who haven't done an "execve()") should use this: it will work within`
307			`* a system call from a "real" process, but the process memory space will`
308			`* not be free'd until both the parent and the child have exited.`
309			`*/`
310			`static inline pid_t kernel_thread(int (fn)(void ), void * arg, unsigned long flags)`
311			`{`
312			`register long retval __asm__ ("d0") = __NR_clone;`
313			`register long clone_arg __asm__ ("d1") = flags \| CLONE_VM;`
314			`unsigned long fs;`
315
316			`fs = get_fs();`
317			`set_fs (KERNEL_DS);`
318
319			`__asm__ __volatile__`
320			`("movel %%sp,%%d2\n\t"`
321			`"trap #0\n\t" /* Linux/m68k system call */`
322			`"cmpl %%sp,%%d2\n\t" /* child or parent */`
323			`"jeq 1f\n\t" /* parent - jump */`
324			`"movel %3,%%sp@-\n\t" /* push argument */`
325			`"jsr %4@\n\t" /* call fn */`
326			`"movel %2,%0\n\t" /* exit */`
327			`"trap #0\n"`
328			`"1:"`
329			`: "=d" (retval)`
330			`: "0" (__NR_clone), "i" (__NR_exit),`
331			`"r" (arg), "a" (fn), "d" (clone_arg)`
332			`: "d0", "d2");`
333
334			`set_fs (fs);`
335			`return retval;`
336			`}`
337
338			`static inline pid_t wait(int * wait_stat)`
339			`{`
340			`return waitpid(-1,wait_stat,0);`
341			`}`
342
343			`#endif`
344
345			`#endif /* _ASM_M68K_UNISTD_H_ */`