blob: 8644a0b5fd2d43da1baa1b851fd271808b4aba26 [file] [log] [blame]
Rob Pike8e82a672008-06-30 11:50:36 -07001// Copyright 2009 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5//
6// System calls and other sys.stuff for AMD64, Linux
7//
8
Russ Cox15ced2d2014-11-11 17:06:22 -05009#include "go_asm.h"
10#include "go_tls.h"
Russ Coxcb040d52014-09-04 23:05:18 -040011#include "textflag.h"
Russ Cox7343e032009-06-17 15:12:16 -070012
Russ Cox25f6b022014-08-27 11:32:17 -040013TEXT runtime·exit(SB),NOSPLIT,$0-4
14 MOVL code+0(FP), DI
Christopher Wedgwoodd166d162010-03-29 22:51:39 -070015 MOVL $231, AX // exitgroup - force all os threads to exit
Russ Coxd28acc42008-08-04 16:43:49 -070016 SYSCALL
17 RET
18
Russ Cox25f6b022014-08-27 11:32:17 -040019TEXT runtime·exit1(SB),NOSPLIT,$0-4
20 MOVL code+0(FP), DI
Russ Cox96824002008-08-05 14:18:47 -070021 MOVL $60, AX // exit - exit the current os thread
Rob Pike8e82a672008-06-30 11:50:36 -070022 SYSCALL
23 RET
24
Russ Cox25f6b022014-08-27 11:32:17 -040025TEXT runtime·open(SB),NOSPLIT,$0-20
26 MOVQ name+0(FP), DI
27 MOVL mode+8(FP), SI
28 MOVL perm+12(FP), DX
Rob Pike8e82a672008-06-30 11:50:36 -070029 MOVL $2, AX // syscall entry
30 SYSCALL
Keith Randallf584c052015-03-02 20:16:48 -080031 CMPQ AX, $0xfffffffffffff001
32 JLS 2(PC)
33 MOVL $-1, AX
Russ Cox25f6b022014-08-27 11:32:17 -040034 MOVL AX, ret+16(FP)
Rob Pike8e82a672008-06-30 11:50:36 -070035 RET
36
David Crawshawcea272d2015-04-13 19:37:04 -040037TEXT runtime·closefd(SB),NOSPLIT,$0-12
Russ Cox25f6b022014-08-27 11:32:17 -040038 MOVL fd+0(FP), DI
Dmitriy Vyukov4e5086b2011-07-29 12:44:06 -040039 MOVL $3, AX // syscall entry
40 SYSCALL
Keith Randallf584c052015-03-02 20:16:48 -080041 CMPQ AX, $0xfffffffffffff001
42 JLS 2(PC)
43 MOVL $-1, AX
Russ Cox25f6b022014-08-27 11:32:17 -040044 MOVL AX, ret+8(FP)
Dmitriy Vyukov4e5086b2011-07-29 12:44:06 -040045 RET
46
Russ Cox25f6b022014-08-27 11:32:17 -040047TEXT runtime·write(SB),NOSPLIT,$0-28
48 MOVQ fd+0(FP), DI
49 MOVQ p+8(FP), SI
50 MOVL n+16(FP), DX
Rob Pikecbdaa102008-07-15 08:27:50 -070051 MOVL $1, AX // syscall entry
52 SYSCALL
Keith Randallf584c052015-03-02 20:16:48 -080053 CMPQ AX, $0xfffffffffffff001
54 JLS 2(PC)
55 MOVL $-1, AX
Russ Cox25f6b022014-08-27 11:32:17 -040056 MOVL AX, ret+24(FP)
Rob Pikecbdaa102008-07-15 08:27:50 -070057 RET
58
Russ Cox25f6b022014-08-27 11:32:17 -040059TEXT runtime·read(SB),NOSPLIT,$0-28
60 MOVL fd+0(FP), DI
61 MOVQ p+8(FP), SI
62 MOVL n+16(FP), DX
Dmitriy Vyukov4e5086b2011-07-29 12:44:06 -040063 MOVL $0, AX // syscall entry
64 SYSCALL
Keith Randallf584c052015-03-02 20:16:48 -080065 CMPQ AX, $0xfffffffffffff001
66 JLS 2(PC)
67 MOVL $-1, AX
Russ Cox25f6b022014-08-27 11:32:17 -040068 MOVL AX, ret+24(FP)
Dmitriy Vyukov4e5086b2011-07-29 12:44:06 -040069 RET
70
Russ Cox25f6b022014-08-27 11:32:17 -040071TEXT runtime·getrlimit(SB),NOSPLIT,$0-20
72 MOVL kind+0(FP), DI
73 MOVQ limit+8(FP), SI
Russ Cox102274a2012-02-24 15:28:51 -050074 MOVL $97, AX // syscall entry
75 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -040076 MOVL AX, ret+16(FP)
Russ Cox102274a2012-02-24 15:28:51 -050077 RET
78
Keith Randall0273dc12013-08-07 12:20:05 -070079TEXT runtime·usleep(SB),NOSPLIT,$16
Russ Coxd324f212011-09-30 09:40:01 -040080 MOVL $0, DX
81 MOVL usec+0(FP), AX
82 MOVL $1000000, CX
83 DIVL CX
84 MOVQ AX, 0(SP)
85 MOVQ DX, 8(SP)
86
87 // select(0, 0, 0, 0, &tv)
88 MOVL $0, DI
89 MOVL $0, SI
90 MOVL $0, DX
91 MOVL $0, R10
92 MOVQ SP, R8
93 MOVL $23, AX
94 SYSCALL
95 RET
96
Russ Coxa9e53642015-06-22 12:32:05 -040097TEXT runtime·gettid(SB),NOSPLIT,$0-4
98 MOVL $186, AX // syscall - gettid
99 SYSCALL
100 MOVL AX, ret+0(FP)
101 RET
102
Russ Cox4a000b92014-02-25 17:00:08 -0500103TEXT runtime·raise(SB),NOSPLIT,$0
Russ Cox8698bb62011-04-25 16:58:00 -0400104 MOVL $186, AX // syscall - gettid
105 SYSCALL
106 MOVL AX, DI // arg 1 tid
Russ Cox5146a932013-03-15 01:11:03 -0400107 MOVL sig+0(FP), SI // arg 2
Russ Cox8698bb62011-04-25 16:58:00 -0400108 MOVL $200, AX // syscall - tkill
109 SYSCALL
110 RET
111
Russ Cox5bfed7c2015-01-14 11:18:24 -0500112TEXT runtime·raiseproc(SB),NOSPLIT,$0
113 MOVL $39, AX // syscall - getpid
114 SYSCALL
115 MOVL AX, DI // arg 1 pid
116 MOVL sig+0(FP), SI // arg 2
117 MOVL $62, AX // syscall - kill
118 SYSCALL
119 RET
120
Keith Randall0273dc12013-08-07 12:20:05 -0700121TEXT runtime·setitimer(SB),NOSPLIT,$0-24
Russ Cox25f6b022014-08-27 11:32:17 -0400122 MOVL mode+0(FP), DI
123 MOVQ new+8(FP), SI
124 MOVQ old+16(FP), DX
Russ Cox8dee8722011-03-23 11:31:42 -0400125 MOVL $38, AX // syscall entry
126 SYSCALL
127 RET
128
Russ Cox25f6b022014-08-27 11:32:17 -0400129TEXT runtime·mincore(SB),NOSPLIT,$0-28
130 MOVQ addr+0(FP), DI
131 MOVQ n+8(FP), SI
132 MOVQ dst+16(FP), DX
Jonathan Markddde52a2011-06-07 21:50:10 -0700133 MOVL $27, AX // syscall entry
134 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -0400135 MOVL AX, ret+24(FP)
Jonathan Markddde52a2011-06-07 21:50:10 -0700136 RET
137
Russ Coxefe3d352011-11-30 11:59:44 -0500138// func now() (sec int64, nsec int32)
Keith Randall0273dc12013-08-07 12:20:05 -0700139TEXT time·now(SB),NOSPLIT,$16
Shenghou Ma26377772012-11-27 01:42:01 +0800140 // Be careful. We're calling a function with gcc calling convention here.
141 // We're guaranteed 128 bytes on entry, and we've taken 16, and the
142 // call uses another 8.
143 // That leaves 104 for the gettime code to use. Hope that's enough!
Shenghou Ma4022fc42012-11-09 14:19:07 +0800144 MOVQ runtime·__vdso_clock_gettime_sym(SB), AX
145 CMPQ AX, $0
Russ Coxb55791e2014-10-28 21:50:16 -0400146 JEQ fallback
Shenghou Ma4022fc42012-11-09 14:19:07 +0800147 MOVL $0, DI // CLOCK_REALTIME
Shenghou Ma26377772012-11-27 01:42:01 +0800148 LEAQ 0(SP), SI
Shenghou Ma4022fc42012-11-09 14:19:07 +0800149 CALL AX
Shenghou Ma26377772012-11-27 01:42:01 +0800150 MOVQ 0(SP), AX // sec
151 MOVQ 8(SP), DX // nsec
Shenghou Ma4022fc42012-11-09 14:19:07 +0800152 MOVQ AX, sec+0(FP)
153 MOVL DX, nsec+8(FP)
154 RET
Russ Coxb55791e2014-10-28 21:50:16 -0400155fallback:
Shenghou Ma26377772012-11-27 01:42:01 +0800156 LEAQ 0(SP), DI
Russ Coxefe3d352011-11-30 11:59:44 -0500157 MOVQ $0, SI
Anthony Martin024a92c2012-11-07 18:29:31 -0800158 MOVQ runtime·__vdso_gettimeofday_sym(SB), AX
Russ Coxefe3d352011-11-30 11:59:44 -0500159 CALL AX
Shenghou Ma26377772012-11-27 01:42:01 +0800160 MOVQ 0(SP), AX // sec
161 MOVL 8(SP), DX // usec
Russ Coxefe3d352011-11-30 11:59:44 -0500162 IMULQ $1000, DX
Shenghou Ma4022fc42012-11-09 14:19:07 +0800163 MOVQ AX, sec+0(FP)
Russ Coxefe3d352011-11-30 11:59:44 -0500164 MOVL DX, nsec+8(FP)
165 RET
166
Keith Randall0273dc12013-08-07 12:20:05 -0700167TEXT runtime·nanotime(SB),NOSPLIT,$16
Shenghou Ma26377772012-11-27 01:42:01 +0800168 // Duplicate time.now here to avoid using up precious stack space.
169 // See comment above in time.now.
170 MOVQ runtime·__vdso_clock_gettime_sym(SB), AX
171 CMPQ AX, $0
Russ Coxb55791e2014-10-28 21:50:16 -0400172 JEQ fallback
Jay Weisskopf86c976f2014-02-24 10:57:46 -0500173 MOVL $1, DI // CLOCK_MONOTONIC
Shenghou Ma26377772012-11-27 01:42:01 +0800174 LEAQ 0(SP), SI
175 CALL AX
Shenghou Ma4022fc42012-11-09 14:19:07 +0800176 MOVQ 0(SP), AX // sec
Shenghou Ma26377772012-11-27 01:42:01 +0800177 MOVQ 8(SP), DX // nsec
178 // sec is in AX, nsec in DX
179 // return nsec in AX
180 IMULQ $1000000000, AX
181 ADDQ DX, AX
Russ Cox25f6b022014-08-27 11:32:17 -0400182 MOVQ AX, ret+0(FP)
Shenghou Ma26377772012-11-27 01:42:01 +0800183 RET
Russ Coxb55791e2014-10-28 21:50:16 -0400184fallback:
Shenghou Ma26377772012-11-27 01:42:01 +0800185 LEAQ 0(SP), DI
186 MOVQ $0, SI
187 MOVQ runtime·__vdso_gettimeofday_sym(SB), AX
188 CALL AX
189 MOVQ 0(SP), AX // sec
190 MOVL 8(SP), DX // usec
191 IMULQ $1000, DX
192 // sec is in AX, nsec in DX
Russ Coxf4373312011-11-03 17:35:28 -0400193 // return nsec in AX
194 IMULQ $1000000000, AX
Russ Coxf4373312011-11-03 17:35:28 -0400195 ADDQ DX, AX
Russ Cox25f6b022014-08-27 11:32:17 -0400196 MOVQ AX, ret+0(FP)
Russ Coxe4f06812010-02-08 14:32:22 -0800197 RET
198
Russ Cox25f6b022014-08-27 11:32:17 -0400199TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-28
200 MOVL sig+0(FP), DI
201 MOVQ new+8(FP), SI
202 MOVQ old+16(FP), DX
203 MOVL size+24(FP), R10
Russ Cox240b1d52012-02-23 14:43:58 -0500204 MOVL $14, AX // syscall entry
205 SYSCALL
206 CMPQ AX, $0xfffffffffffff001
207 JLS 2(PC)
Russ Cox36aa7d42012-03-08 14:03:56 -0500208 MOVL $0xf1, 0xf1 // crash
Russ Cox240b1d52012-02-23 14:43:58 -0500209 RET
210
Russ Cox25f6b022014-08-27 11:32:17 -0400211TEXT runtime·rt_sigaction(SB),NOSPLIT,$0-36
212 MOVQ sig+0(FP), DI
213 MOVQ new+8(FP), SI
214 MOVQ old+16(FP), DX
215 MOVQ size+24(FP), R10
Rob Pike8e82a672008-06-30 11:50:36 -0700216 MOVL $13, AX // syscall entry
217 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -0400218 MOVL AX, ret+32(FP)
Rob Pike8e82a672008-06-30 11:50:36 -0700219 RET
220
Srdjan Petrovic5c8fbc62015-04-09 11:12:12 -0700221TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
222 MOVQ sig+8(FP), DI
223 MOVQ info+16(FP), SI
224 MOVQ ctx+24(FP), DX
225 MOVQ fn+0(FP), AX
Shenghou Ma2f1ead72013-07-12 04:39:39 +0800226 CALL AX
Alan Donovan532dee32012-09-04 14:40:49 -0400227 RET
Russ Coxb2369112012-03-12 15:55:18 -0400228
Srdjan Petrovic5c8fbc62015-04-09 11:12:12 -0700229TEXT runtime·sigtramp(SB),NOSPLIT,$24
230 MOVQ DI, 0(SP) // signum
231 MOVQ SI, 8(SP) // info
232 MOVQ DX, 16(SP) // ctx
233 MOVQ $runtime·sigtrampgo(SB), AX
234 CALL AX
Rob Pike8e82a672008-06-30 11:50:36 -0700235 RET
236
Keith Randall0273dc12013-08-07 12:20:05 -0700237TEXT runtime·sigreturn(SB),NOSPLIT,$0
Russ Coxdfa58932008-12-03 14:21:28 -0800238 MOVL $15, AX // rt_sigreturn
239 SYSCALL
240 INT $3 // not reached
241
Keith Randall0273dc12013-08-07 12:20:05 -0700242TEXT runtime·mmap(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400243 MOVQ addr+0(FP), DI
244 MOVQ n+8(FP), SI
245 MOVL prot+16(FP), DX
246 MOVL flags+20(FP), R10
247 MOVL fd+24(FP), R8
248 MOVL off+28(FP), R9
Rob Pike8e82a672008-06-30 11:50:36 -0700249
Russ Coxd4cc5572010-09-07 09:57:22 -0400250 MOVL $9, AX // mmap
Rob Pike8e82a672008-06-30 11:50:36 -0700251 SYSCALL
252 CMPQ AX, $0xfffffffffffff001
Adam Langley3f7a3242009-11-13 10:08:51 -0800253 JLS 3(PC)
254 NOTQ AX
255 INCQ AX
Russ Cox25f6b022014-08-27 11:32:17 -0400256 MOVQ AX, ret+32(FP)
Rob Pike8e82a672008-06-30 11:50:36 -0700257 RET
258
Keith Randall0273dc12013-08-07 12:20:05 -0700259TEXT runtime·munmap(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400260 MOVQ addr+0(FP), DI
261 MOVQ n+8(FP), SI
Russ Coxd4cc5572010-09-07 09:57:22 -0400262 MOVQ $11, AX // munmap
263 SYSCALL
264 CMPQ AX, $0xfffffffffffff001
265 JLS 2(PC)
Russ Cox36aa7d42012-03-08 14:03:56 -0500266 MOVL $0xf1, 0xf1 // crash
Russ Coxd4cc5572010-09-07 09:57:22 -0400267 RET
268
Keith Randall0273dc12013-08-07 12:20:05 -0700269TEXT runtime·madvise(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400270 MOVQ addr+0(FP), DI
271 MOVQ n+8(FP), SI
272 MOVL flags+16(FP), DX
Sébastien Paolaccie6f5a902011-12-12 16:33:13 -0500273 MOVQ $28, AX // madvise
274 SYSCALL
Russ Cox295a4d82012-12-22 15:06:28 -0500275 // ignore failure - maybe pages are locked
Rob Pike8e82a672008-06-30 11:50:36 -0700276 RET
277
Russ Cox96824002008-08-05 14:18:47 -0700278// int64 futex(int32 *uaddr, int32 op, int32 val,
Russ Coxd28acc42008-08-04 16:43:49 -0700279// struct timespec *timeout, int32 *uaddr2, int32 val2);
Keith Randall0273dc12013-08-07 12:20:05 -0700280TEXT runtime·futex(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400281 MOVQ addr+0(FP), DI
282 MOVL op+8(FP), SI
283 MOVL val+12(FP), DX
284 MOVQ ts+16(FP), R10
285 MOVQ addr2+24(FP), R8
286 MOVL val3+32(FP), R9
Russ Coxd28acc42008-08-04 16:43:49 -0700287 MOVL $202, AX
288 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -0400289 MOVL AX, ret+40(FP)
Russ Coxd28acc42008-08-04 16:43:49 -0700290 RET
291
Russ Cox25f6b022014-08-27 11:32:17 -0400292// int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
Keith Randall0273dc12013-08-07 12:20:05 -0700293TEXT runtime·clone(SB),NOSPLIT,$0
Srdjan Petrovicca9128f2015-04-17 17:27:07 -0700294 MOVL flags+0(FP), DI
295 MOVQ stack+8(FP), SI
296 MOVQ $0, DX
297 MOVQ $0, R10
Russ Coxf7f63292008-08-05 14:21:42 -0700298
Jingcheng Zhang70e967b2012-12-19 00:30:29 +0800299 // Copy mp, gp, fn off parent stack for use by child.
Russ Coxd28acc42008-08-04 16:43:49 -0700300 // Careful: Linux system call clobbers CX and R11.
Srdjan Petrovicca9128f2015-04-17 17:27:07 -0700301 MOVQ mp+16(FP), R8
302 MOVQ gp+24(FP), R9
303 MOVQ fn+32(FP), R12
Russ Coxd28acc42008-08-04 16:43:49 -0700304
305 MOVL $56, AX
306 SYSCALL
307
308 // In parent, return.
309 CMPQ AX, $0
Russ Cox25f6b022014-08-27 11:32:17 -0400310 JEQ 3(PC)
311 MOVL AX, ret+40(FP)
Russ Coxd28acc42008-08-04 16:43:49 -0700312 RET
Russ Coxd324f212011-09-30 09:40:01 -0400313
Russ Coxe473f422010-08-04 17:50:22 -0700314 // In child, on new stack.
Russ Coxd28acc42008-08-04 16:43:49 -0700315 MOVQ SI, SP
Russ Coxd324f212011-09-30 09:40:01 -0400316
Srdjan Petrovicca9128f2015-04-17 17:27:07 -0700317 // If g or m are nil, skip Go-related setup.
318 CMPQ R8, $0 // m
319 JEQ nog
320 CMPQ R9, $0 // g
321 JEQ nog
322
Russ Cox376898c2008-09-09 11:50:14 -0700323 // Initialize m->procid to Linux tid
324 MOVL $186, AX // gettid
325 SYSCALL
Russ Coxe473f422010-08-04 17:50:22 -0700326 MOVQ AX, m_procid(R8)
327
328 // Set FS to point at m->tls.
329 LEAQ m_tls(R8), DI
Russ Cox68b42552010-11-04 14:00:19 -0400330 CALL runtime·settls(SB)
Russ Coxe473f422010-08-04 17:50:22 -0700331
332 // In child, set up new stack
333 get_tls(CX)
Russ Cox89f185f2014-06-26 11:54:39 -0400334 MOVQ R8, g_m(R9)
Russ Coxe473f422010-08-04 17:50:22 -0700335 MOVQ R9, g(CX)
Russ Cox68b42552010-11-04 14:00:19 -0400336 CALL runtime·stackcheck(SB)
Russ Cox36096242009-01-16 14:58:14 -0800337
Srdjan Petrovicca9128f2015-04-17 17:27:07 -0700338nog:
Russ Cox376898c2008-09-09 11:50:14 -0700339 // Call fn
Russ Coxd28acc42008-08-04 16:43:49 -0700340 CALL R12
Russ Coxf7f63292008-08-05 14:21:42 -0700341
Shenghou Maedc53e1f2015-04-22 18:03:18 -0400342 // It shouldn't return. If it does, exit that thread.
Russ Coxd28acc42008-08-04 16:43:49 -0700343 MOVL $111, DI
344 MOVL $60, AX
345 SYSCALL
346 JMP -3(PC) // keep exiting
347
Keith Randall0273dc12013-08-07 12:20:05 -0700348TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
Russ Coxa67258f2008-09-18 15:56:46 -0700349 MOVQ new+8(SP), DI
350 MOVQ old+16(SP), SI
351 MOVQ $131, AX
352 SYSCALL
353 CMPQ AX, $0xfffffffffffff001
354 JLS 2(PC)
Russ Cox36aa7d42012-03-08 14:03:56 -0500355 MOVL $0xf1, 0xf1 // crash
Russ Coxa67258f2008-09-18 15:56:46 -0700356 RET
Russ Coxe473f422010-08-04 17:50:22 -0700357
358// set tls base to DI
Keith Randall0273dc12013-08-07 12:20:05 -0700359TEXT runtime·settls(SB),NOSPLIT,$32
Michael Hudson-Doyle658a3382015-03-04 16:28:45 +1300360 ADDQ $8, DI // ELF wants to use -8(FS)
Russ Coxe473f422010-08-04 17:50:22 -0700361
362 MOVQ DI, SI
363 MOVQ $0x1002, DI // ARCH_SET_FS
364 MOVQ $158, AX // arch_prctl
365 SYSCALL
366 CMPQ AX, $0xfffffffffffff001
367 JLS 2(PC)
Russ Cox36aa7d42012-03-08 14:03:56 -0500368 MOVL $0xf1, 0xf1 // crash
Russ Coxe473f422010-08-04 17:50:22 -0700369 RET
370
Keith Randall0273dc12013-08-07 12:20:05 -0700371TEXT runtime·osyield(SB),NOSPLIT,$0
Dmitriy Vyukov4e5086b2011-07-29 12:44:06 -0400372 MOVL $24, AX
373 SYSCALL
374 RET
Shenghou Ma4f308ed2012-08-10 10:05:26 +0800375
Keith Randall0273dc12013-08-07 12:20:05 -0700376TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400377 MOVQ pid+0(FP), DI
378 MOVQ len+8(FP), SI
379 MOVQ buf+16(FP), DX
Shenghou Ma4f308ed2012-08-10 10:05:26 +0800380 MOVL $204, AX // syscall entry
381 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -0400382 MOVL AX, ret+24(FP)
Shenghou Ma4f308ed2012-08-10 10:05:26 +0800383 RET
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400384
385// int32 runtime·epollcreate(int32 size);
Keith Randall0273dc12013-08-07 12:20:05 -0700386TEXT runtime·epollcreate(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400387 MOVL size+0(FP), DI
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400388 MOVL $213, AX // syscall entry
389 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -0400390 MOVL AX, ret+8(FP)
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400391 RET
392
393// int32 runtime·epollcreate1(int32 flags);
Keith Randall0273dc12013-08-07 12:20:05 -0700394TEXT runtime·epollcreate1(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400395 MOVL flags+0(FP), DI
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400396 MOVL $291, AX // syscall entry
397 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -0400398 MOVL AX, ret+8(FP)
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400399 RET
400
Dmitriy Vyukov91a670d2014-09-04 10:04:04 +0400401// func epollctl(epfd, op, fd int32, ev *epollEvent) int
Keith Randall0273dc12013-08-07 12:20:05 -0700402TEXT runtime·epollctl(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400403 MOVL epfd+0(FP), DI
404 MOVL op+4(FP), SI
405 MOVL fd+8(FP), DX
406 MOVQ ev+16(FP), R10
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400407 MOVL $233, AX // syscall entry
408 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -0400409 MOVL AX, ret+24(FP)
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400410 RET
411
412// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
Keith Randall0273dc12013-08-07 12:20:05 -0700413TEXT runtime·epollwait(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400414 MOVL epfd+0(FP), DI
415 MOVQ ev+8(FP), SI
416 MOVL nev+16(FP), DX
417 MOVL timeout+20(FP), R10
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400418 MOVL $232, AX // syscall entry
419 SYSCALL
Russ Cox25f6b022014-08-27 11:32:17 -0400420 MOVL AX, ret+24(FP)
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400421 RET
422
423// void runtime·closeonexec(int32 fd);
Keith Randall0273dc12013-08-07 12:20:05 -0700424TEXT runtime·closeonexec(SB),NOSPLIT,$0
Russ Cox25f6b022014-08-27 11:32:17 -0400425 MOVL fd+0(FP), DI // fd
Dmitriy Vyukov49e03002013-03-14 19:06:35 +0400426 MOVQ $2, SI // F_SETFD
427 MOVQ $1, DX // FD_CLOEXEC
428 MOVL $72, AX // fcntl
429 SYSCALL
430 RET