← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/gabriel-samfira/sys/unix/zsyscall_darwin_amd64.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/gabriel-samfira/sys/unix/zsyscall_darwin_amd64.go
 
1
// mksyscall.pl syscall_bsd.go syscall_darwin.go syscall_darwin_amd64.go
 
2
// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
 
3
 
 
4
// +build amd64,darwin
 
5
 
 
6
package unix
 
7
 
 
8
import (
 
9
        "syscall"
 
10
        "unsafe"
 
11
)
 
12
 
 
13
var _ syscall.Errno
 
14
 
 
15
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
16
 
 
17
func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 
18
        r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 
19
        n = int(r0)
 
20
        if e1 != 0 {
 
21
                err = errnoErr(e1)
 
22
        }
 
23
        return
 
24
}
 
25
 
 
26
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
27
 
 
28
func setgroups(ngid int, gid *_Gid_t) (err error) {
 
29
        _, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 
30
        if e1 != 0 {
 
31
                err = errnoErr(e1)
 
32
        }
 
33
        return
 
34
}
 
35
 
 
36
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
37
 
 
38
func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
 
39
        r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 
40
        wpid = int(r0)
 
41
        if e1 != 0 {
 
42
                err = errnoErr(e1)
 
43
        }
 
44
        return
 
45
}
 
46
 
 
47
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
48
 
 
49
func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 
50
        r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 
51
        fd = int(r0)
 
52
        if e1 != 0 {
 
53
                err = errnoErr(e1)
 
54
        }
 
55
        return
 
56
}
 
57
 
 
58
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
59
 
 
60
func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
61
        _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
 
62
        if e1 != 0 {
 
63
                err = errnoErr(e1)
 
64
        }
 
65
        return
 
66
}
 
67
 
 
68
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
69
 
 
70
func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
71
        _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
 
72
        if e1 != 0 {
 
73
                err = errnoErr(e1)
 
74
        }
 
75
        return
 
76
}
 
77
 
 
78
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
79
 
 
80
func socket(domain int, typ int, proto int) (fd int, err error) {
 
81
        r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
 
82
        fd = int(r0)
 
83
        if e1 != 0 {
 
84
                err = errnoErr(e1)
 
85
        }
 
86
        return
 
87
}
 
88
 
 
89
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
90
 
 
91
func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
 
92
        _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 
93
        if e1 != 0 {
 
94
                err = errnoErr(e1)
 
95
        }
 
96
        return
 
97
}
 
98
 
 
99
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
100
 
 
101
func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
 
102
        _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 
103
        if e1 != 0 {
 
104
                err = errnoErr(e1)
 
105
        }
 
106
        return
 
107
}
 
108
 
 
109
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
110
 
 
111
func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
112
        _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 
113
        if e1 != 0 {
 
114
                err = errnoErr(e1)
 
115
        }
 
116
        return
 
117
}
 
118
 
 
119
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
120
 
 
121
func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
122
        _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 
123
        if e1 != 0 {
 
124
                err = errnoErr(e1)
 
125
        }
 
126
        return
 
127
}
 
128
 
 
129
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
130
 
 
131
func Shutdown(s int, how int) (err error) {
 
132
        _, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
 
133
        if e1 != 0 {
 
134
                err = errnoErr(e1)
 
135
        }
 
136
        return
 
137
}
 
138
 
 
139
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
140
 
 
141
func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
 
142
        _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 
143
        if e1 != 0 {
 
144
                err = errnoErr(e1)
 
145
        }
 
146
        return
 
147
}
 
148
 
 
149
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
150
 
 
151
func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
 
152
        var _p0 unsafe.Pointer
 
153
        if len(p) > 0 {
 
154
                _p0 = unsafe.Pointer(&p[0])
 
155
        } else {
 
156
                _p0 = unsafe.Pointer(&_zero)
 
157
        }
 
158
        r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 
159
        n = int(r0)
 
160
        if e1 != 0 {
 
161
                err = errnoErr(e1)
 
162
        }
 
163
        return
 
164
}
 
165
 
 
166
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
167
 
 
168
func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
 
169
        var _p0 unsafe.Pointer
 
170
        if len(buf) > 0 {
 
171
                _p0 = unsafe.Pointer(&buf[0])
 
172
        } else {
 
173
                _p0 = unsafe.Pointer(&_zero)
 
174
        }
 
175
        _, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 
176
        if e1 != 0 {
 
177
                err = errnoErr(e1)
 
178
        }
 
179
        return
 
180
}
 
181
 
 
182
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
183
 
 
184
func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
185
        r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 
186
        n = int(r0)
 
187
        if e1 != 0 {
 
188
                err = errnoErr(e1)
 
189
        }
 
190
        return
 
191
}
 
192
 
 
193
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
194
 
 
195
func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
196
        r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 
197
        n = int(r0)
 
198
        if e1 != 0 {
 
199
                err = errnoErr(e1)
 
200
        }
 
201
        return
 
202
}
 
203
 
 
204
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
205
 
 
206
func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
 
207
        r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 
208
        n = int(r0)
 
209
        if e1 != 0 {
 
210
                err = errnoErr(e1)
 
211
        }
 
212
        return
 
213
}
 
214
 
 
215
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
216
 
 
217
func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
 
218
        var _p0 unsafe.Pointer
 
219
        if len(mib) > 0 {
 
220
                _p0 = unsafe.Pointer(&mib[0])
 
221
        } else {
 
222
                _p0 = unsafe.Pointer(&_zero)
 
223
        }
 
224
        _, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
 
225
        if e1 != 0 {
 
226
                err = errnoErr(e1)
 
227
        }
 
228
        return
 
229
}
 
230
 
 
231
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
232
 
 
233
func utimes(path string, timeval *[2]Timeval) (err error) {
 
234
        var _p0 *byte
 
235
        _p0, err = BytePtrFromString(path)
 
236
        if err != nil {
 
237
                return
 
238
        }
 
239
        _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 
240
        use(unsafe.Pointer(_p0))
 
241
        if e1 != 0 {
 
242
                err = errnoErr(e1)
 
243
        }
 
244
        return
 
245
}
 
246
 
 
247
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
248
 
 
249
func futimes(fd int, timeval *[2]Timeval) (err error) {
 
250
        _, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 
251
        if e1 != 0 {
 
252
                err = errnoErr(e1)
 
253
        }
 
254
        return
 
255
}
 
256
 
 
257
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
258
 
 
259
func fcntl(fd int, cmd int, arg int) (val int, err error) {
 
260
        r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
 
261
        val = int(r0)
 
262
        if e1 != 0 {
 
263
                err = errnoErr(e1)
 
264
        }
 
265
        return
 
266
}
 
267
 
 
268
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
269
 
 
270
func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
 
271
        _, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 
272
        if e1 != 0 {
 
273
                err = errnoErr(e1)
 
274
        }
 
275
        return
 
276
}
 
277
 
 
278
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
279
 
 
280
func pipe() (r int, w int, err error) {
 
281
        r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
 
282
        r = int(r0)
 
283
        w = int(r1)
 
284
        if e1 != 0 {
 
285
                err = errnoErr(e1)
 
286
        }
 
287
        return
 
288
}
 
289
 
 
290
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
291
 
 
292
func kill(pid int, signum int, posix int) (err error) {
 
293
        _, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
 
294
        if e1 != 0 {
 
295
                err = errnoErr(e1)
 
296
        }
 
297
        return
 
298
}
 
299
 
 
300
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
301
 
 
302
func Access(path string, mode uint32) (err error) {
 
303
        var _p0 *byte
 
304
        _p0, err = BytePtrFromString(path)
 
305
        if err != nil {
 
306
                return
 
307
        }
 
308
        _, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 
309
        use(unsafe.Pointer(_p0))
 
310
        if e1 != 0 {
 
311
                err = errnoErr(e1)
 
312
        }
 
313
        return
 
314
}
 
315
 
 
316
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
317
 
 
318
func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
 
319
        _, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 
320
        if e1 != 0 {
 
321
                err = errnoErr(e1)
 
322
        }
 
323
        return
 
324
}
 
325
 
 
326
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
327
 
 
328
func Chdir(path string) (err error) {
 
329
        var _p0 *byte
 
330
        _p0, err = BytePtrFromString(path)
 
331
        if err != nil {
 
332
                return
 
333
        }
 
334
        _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
335
        use(unsafe.Pointer(_p0))
 
336
        if e1 != 0 {
 
337
                err = errnoErr(e1)
 
338
        }
 
339
        return
 
340
}
 
341
 
 
342
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
343
 
 
344
func Chflags(path string, flags int) (err error) {
 
345
        var _p0 *byte
 
346
        _p0, err = BytePtrFromString(path)
 
347
        if err != nil {
 
348
                return
 
349
        }
 
350
        _, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 
351
        use(unsafe.Pointer(_p0))
 
352
        if e1 != 0 {
 
353
                err = errnoErr(e1)
 
354
        }
 
355
        return
 
356
}
 
357
 
 
358
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
359
 
 
360
func Chmod(path string, mode uint32) (err error) {
 
361
        var _p0 *byte
 
362
        _p0, err = BytePtrFromString(path)
 
363
        if err != nil {
 
364
                return
 
365
        }
 
366
        _, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 
367
        use(unsafe.Pointer(_p0))
 
368
        if e1 != 0 {
 
369
                err = errnoErr(e1)
 
370
        }
 
371
        return
 
372
}
 
373
 
 
374
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
375
 
 
376
func Chown(path string, uid int, gid int) (err error) {
 
377
        var _p0 *byte
 
378
        _p0, err = BytePtrFromString(path)
 
379
        if err != nil {
 
380
                return
 
381
        }
 
382
        _, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 
383
        use(unsafe.Pointer(_p0))
 
384
        if e1 != 0 {
 
385
                err = errnoErr(e1)
 
386
        }
 
387
        return
 
388
}
 
389
 
 
390
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
391
 
 
392
func Chroot(path string) (err error) {
 
393
        var _p0 *byte
 
394
        _p0, err = BytePtrFromString(path)
 
395
        if err != nil {
 
396
                return
 
397
        }
 
398
        _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
399
        use(unsafe.Pointer(_p0))
 
400
        if e1 != 0 {
 
401
                err = errnoErr(e1)
 
402
        }
 
403
        return
 
404
}
 
405
 
 
406
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
407
 
 
408
func Close(fd int) (err error) {
 
409
        _, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
 
410
        if e1 != 0 {
 
411
                err = errnoErr(e1)
 
412
        }
 
413
        return
 
414
}
 
415
 
 
416
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
417
 
 
418
func Dup(fd int) (nfd int, err error) {
 
419
        r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
 
420
        nfd = int(r0)
 
421
        if e1 != 0 {
 
422
                err = errnoErr(e1)
 
423
        }
 
424
        return
 
425
}
 
426
 
 
427
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
428
 
 
429
func Dup2(from int, to int) (err error) {
 
430
        _, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
 
431
        if e1 != 0 {
 
432
                err = errnoErr(e1)
 
433
        }
 
434
        return
 
435
}
 
436
 
 
437
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
438
 
 
439
func Exchangedata(path1 string, path2 string, options int) (err error) {
 
440
        var _p0 *byte
 
441
        _p0, err = BytePtrFromString(path1)
 
442
        if err != nil {
 
443
                return
 
444
        }
 
445
        var _p1 *byte
 
446
        _p1, err = BytePtrFromString(path2)
 
447
        if err != nil {
 
448
                return
 
449
        }
 
450
        _, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 
451
        use(unsafe.Pointer(_p0))
 
452
        use(unsafe.Pointer(_p1))
 
453
        if e1 != 0 {
 
454
                err = errnoErr(e1)
 
455
        }
 
456
        return
 
457
}
 
458
 
 
459
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
460
 
 
461
func Exit(code int) {
 
462
        Syscall(SYS_EXIT, uintptr(code), 0, 0)
 
463
        return
 
464
}
 
465
 
 
466
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
467
 
 
468
func Fchdir(fd int) (err error) {
 
469
        _, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
 
470
        if e1 != 0 {
 
471
                err = errnoErr(e1)
 
472
        }
 
473
        return
 
474
}
 
475
 
 
476
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
477
 
 
478
func Fchflags(fd int, flags int) (err error) {
 
479
        _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
 
480
        if e1 != 0 {
 
481
                err = errnoErr(e1)
 
482
        }
 
483
        return
 
484
}
 
485
 
 
486
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
487
 
 
488
func Fchmod(fd int, mode uint32) (err error) {
 
489
        _, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
 
490
        if e1 != 0 {
 
491
                err = errnoErr(e1)
 
492
        }
 
493
        return
 
494
}
 
495
 
 
496
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
497
 
 
498
func Fchown(fd int, uid int, gid int) (err error) {
 
499
        _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
 
500
        if e1 != 0 {
 
501
                err = errnoErr(e1)
 
502
        }
 
503
        return
 
504
}
 
505
 
 
506
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
507
 
 
508
func Flock(fd int, how int) (err error) {
 
509
        _, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
 
510
        if e1 != 0 {
 
511
                err = errnoErr(e1)
 
512
        }
 
513
        return
 
514
}
 
515
 
 
516
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
517
 
 
518
func Fpathconf(fd int, name int) (val int, err error) {
 
519
        r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
 
520
        val = int(r0)
 
521
        if e1 != 0 {
 
522
                err = errnoErr(e1)
 
523
        }
 
524
        return
 
525
}
 
526
 
 
527
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
528
 
 
529
func Fstat(fd int, stat *Stat_t) (err error) {
 
530
        _, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 
531
        if e1 != 0 {
 
532
                err = errnoErr(e1)
 
533
        }
 
534
        return
 
535
}
 
536
 
 
537
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
538
 
 
539
func Fstatfs(fd int, stat *Statfs_t) (err error) {
 
540
        _, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 
541
        if e1 != 0 {
 
542
                err = errnoErr(e1)
 
543
        }
 
544
        return
 
545
}
 
546
 
 
547
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
548
 
 
549
func Fsync(fd int) (err error) {
 
550
        _, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
 
551
        if e1 != 0 {
 
552
                err = errnoErr(e1)
 
553
        }
 
554
        return
 
555
}
 
556
 
 
557
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
558
 
 
559
func Ftruncate(fd int, length int64) (err error) {
 
560
        _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0)
 
561
        if e1 != 0 {
 
562
                err = errnoErr(e1)
 
563
        }
 
564
        return
 
565
}
 
566
 
 
567
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
568
 
 
569
func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
 
570
        var _p0 unsafe.Pointer
 
571
        if len(buf) > 0 {
 
572
                _p0 = unsafe.Pointer(&buf[0])
 
573
        } else {
 
574
                _p0 = unsafe.Pointer(&_zero)
 
575
        }
 
576
        r0, _, e1 := Syscall6(SYS_GETDIRENTRIES64, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
 
577
        n = int(r0)
 
578
        if e1 != 0 {
 
579
                err = errnoErr(e1)
 
580
        }
 
581
        return
 
582
}
 
583
 
 
584
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
585
 
 
586
func Getdtablesize() (size int) {
 
587
        r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
 
588
        size = int(r0)
 
589
        return
 
590
}
 
591
 
 
592
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
593
 
 
594
func Getegid() (egid int) {
 
595
        r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
 
596
        egid = int(r0)
 
597
        return
 
598
}
 
599
 
 
600
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
601
 
 
602
func Geteuid() (uid int) {
 
603
        r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
 
604
        uid = int(r0)
 
605
        return
 
606
}
 
607
 
 
608
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
609
 
 
610
func Getgid() (gid int) {
 
611
        r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
 
612
        gid = int(r0)
 
613
        return
 
614
}
 
615
 
 
616
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
617
 
 
618
func Getpgid(pid int) (pgid int, err error) {
 
619
        r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
 
620
        pgid = int(r0)
 
621
        if e1 != 0 {
 
622
                err = errnoErr(e1)
 
623
        }
 
624
        return
 
625
}
 
626
 
 
627
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
628
 
 
629
func Getpgrp() (pgrp int) {
 
630
        r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
 
631
        pgrp = int(r0)
 
632
        return
 
633
}
 
634
 
 
635
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
636
 
 
637
func Getpid() (pid int) {
 
638
        r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
 
639
        pid = int(r0)
 
640
        return
 
641
}
 
642
 
 
643
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
644
 
 
645
func Getppid() (ppid int) {
 
646
        r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
 
647
        ppid = int(r0)
 
648
        return
 
649
}
 
650
 
 
651
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
652
 
 
653
func Getpriority(which int, who int) (prio int, err error) {
 
654
        r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
 
655
        prio = int(r0)
 
656
        if e1 != 0 {
 
657
                err = errnoErr(e1)
 
658
        }
 
659
        return
 
660
}
 
661
 
 
662
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
663
 
 
664
func Getrlimit(which int, lim *Rlimit) (err error) {
 
665
        _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 
666
        if e1 != 0 {
 
667
                err = errnoErr(e1)
 
668
        }
 
669
        return
 
670
}
 
671
 
 
672
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
673
 
 
674
func Getrusage(who int, rusage *Rusage) (err error) {
 
675
        _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 
676
        if e1 != 0 {
 
677
                err = errnoErr(e1)
 
678
        }
 
679
        return
 
680
}
 
681
 
 
682
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
683
 
 
684
func Getsid(pid int) (sid int, err error) {
 
685
        r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
 
686
        sid = int(r0)
 
687
        if e1 != 0 {
 
688
                err = errnoErr(e1)
 
689
        }
 
690
        return
 
691
}
 
692
 
 
693
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
694
 
 
695
func Getuid() (uid int) {
 
696
        r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
 
697
        uid = int(r0)
 
698
        return
 
699
}
 
700
 
 
701
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
702
 
 
703
func Issetugid() (tainted bool) {
 
704
        r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
 
705
        tainted = bool(r0 != 0)
 
706
        return
 
707
}
 
708
 
 
709
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
710
 
 
711
func Kqueue() (fd int, err error) {
 
712
        r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
 
713
        fd = int(r0)
 
714
        if e1 != 0 {
 
715
                err = errnoErr(e1)
 
716
        }
 
717
        return
 
718
}
 
719
 
 
720
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
721
 
 
722
func Lchown(path string, uid int, gid int) (err error) {
 
723
        var _p0 *byte
 
724
        _p0, err = BytePtrFromString(path)
 
725
        if err != nil {
 
726
                return
 
727
        }
 
728
        _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 
729
        use(unsafe.Pointer(_p0))
 
730
        if e1 != 0 {
 
731
                err = errnoErr(e1)
 
732
        }
 
733
        return
 
734
}
 
735
 
 
736
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
737
 
 
738
func Link(path string, link string) (err error) {
 
739
        var _p0 *byte
 
740
        _p0, err = BytePtrFromString(path)
 
741
        if err != nil {
 
742
                return
 
743
        }
 
744
        var _p1 *byte
 
745
        _p1, err = BytePtrFromString(link)
 
746
        if err != nil {
 
747
                return
 
748
        }
 
749
        _, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
750
        use(unsafe.Pointer(_p0))
 
751
        use(unsafe.Pointer(_p1))
 
752
        if e1 != 0 {
 
753
                err = errnoErr(e1)
 
754
        }
 
755
        return
 
756
}
 
757
 
 
758
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
759
 
 
760
func Listen(s int, backlog int) (err error) {
 
761
        _, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
 
762
        if e1 != 0 {
 
763
                err = errnoErr(e1)
 
764
        }
 
765
        return
 
766
}
 
767
 
 
768
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
769
 
 
770
func Lstat(path string, stat *Stat_t) (err error) {
 
771
        var _p0 *byte
 
772
        _p0, err = BytePtrFromString(path)
 
773
        if err != nil {
 
774
                return
 
775
        }
 
776
        _, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 
777
        use(unsafe.Pointer(_p0))
 
778
        if e1 != 0 {
 
779
                err = errnoErr(e1)
 
780
        }
 
781
        return
 
782
}
 
783
 
 
784
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
785
 
 
786
func Mkdir(path string, mode uint32) (err error) {
 
787
        var _p0 *byte
 
788
        _p0, err = BytePtrFromString(path)
 
789
        if err != nil {
 
790
                return
 
791
        }
 
792
        _, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 
793
        use(unsafe.Pointer(_p0))
 
794
        if e1 != 0 {
 
795
                err = errnoErr(e1)
 
796
        }
 
797
        return
 
798
}
 
799
 
 
800
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
801
 
 
802
func Mkfifo(path string, mode uint32) (err error) {
 
803
        var _p0 *byte
 
804
        _p0, err = BytePtrFromString(path)
 
805
        if err != nil {
 
806
                return
 
807
        }
 
808
        _, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 
809
        use(unsafe.Pointer(_p0))
 
810
        if e1 != 0 {
 
811
                err = errnoErr(e1)
 
812
        }
 
813
        return
 
814
}
 
815
 
 
816
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
817
 
 
818
func Mknod(path string, mode uint32, dev int) (err error) {
 
819
        var _p0 *byte
 
820
        _p0, err = BytePtrFromString(path)
 
821
        if err != nil {
 
822
                return
 
823
        }
 
824
        _, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 
825
        use(unsafe.Pointer(_p0))
 
826
        if e1 != 0 {
 
827
                err = errnoErr(e1)
 
828
        }
 
829
        return
 
830
}
 
831
 
 
832
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
833
 
 
834
func Mlock(b []byte) (err error) {
 
835
        var _p0 unsafe.Pointer
 
836
        if len(b) > 0 {
 
837
                _p0 = unsafe.Pointer(&b[0])
 
838
        } else {
 
839
                _p0 = unsafe.Pointer(&_zero)
 
840
        }
 
841
        _, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
 
842
        if e1 != 0 {
 
843
                err = errnoErr(e1)
 
844
        }
 
845
        return
 
846
}
 
847
 
 
848
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
849
 
 
850
func Mlockall(flags int) (err error) {
 
851
        _, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
 
852
        if e1 != 0 {
 
853
                err = errnoErr(e1)
 
854
        }
 
855
        return
 
856
}
 
857
 
 
858
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
859
 
 
860
func Mprotect(b []byte, prot int) (err error) {
 
861
        var _p0 unsafe.Pointer
 
862
        if len(b) > 0 {
 
863
                _p0 = unsafe.Pointer(&b[0])
 
864
        } else {
 
865
                _p0 = unsafe.Pointer(&_zero)
 
866
        }
 
867
        _, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
 
868
        if e1 != 0 {
 
869
                err = errnoErr(e1)
 
870
        }
 
871
        return
 
872
}
 
873
 
 
874
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
875
 
 
876
func Munlock(b []byte) (err error) {
 
877
        var _p0 unsafe.Pointer
 
878
        if len(b) > 0 {
 
879
                _p0 = unsafe.Pointer(&b[0])
 
880
        } else {
 
881
                _p0 = unsafe.Pointer(&_zero)
 
882
        }
 
883
        _, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
 
884
        if e1 != 0 {
 
885
                err = errnoErr(e1)
 
886
        }
 
887
        return
 
888
}
 
889
 
 
890
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
891
 
 
892
func Munlockall() (err error) {
 
893
        _, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
 
894
        if e1 != 0 {
 
895
                err = errnoErr(e1)
 
896
        }
 
897
        return
 
898
}
 
899
 
 
900
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
901
 
 
902
func Open(path string, mode int, perm uint32) (fd int, err error) {
 
903
        var _p0 *byte
 
904
        _p0, err = BytePtrFromString(path)
 
905
        if err != nil {
 
906
                return
 
907
        }
 
908
        r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 
909
        use(unsafe.Pointer(_p0))
 
910
        fd = int(r0)
 
911
        if e1 != 0 {
 
912
                err = errnoErr(e1)
 
913
        }
 
914
        return
 
915
}
 
916
 
 
917
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
918
 
 
919
func Pathconf(path string, name int) (val int, err error) {
 
920
        var _p0 *byte
 
921
        _p0, err = BytePtrFromString(path)
 
922
        if err != nil {
 
923
                return
 
924
        }
 
925
        r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 
926
        use(unsafe.Pointer(_p0))
 
927
        val = int(r0)
 
928
        if e1 != 0 {
 
929
                err = errnoErr(e1)
 
930
        }
 
931
        return
 
932
}
 
933
 
 
934
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
935
 
 
936
func Pread(fd int, p []byte, offset int64) (n int, err error) {
 
937
        var _p0 unsafe.Pointer
 
938
        if len(p) > 0 {
 
939
                _p0 = unsafe.Pointer(&p[0])
 
940
        } else {
 
941
                _p0 = unsafe.Pointer(&_zero)
 
942
        }
 
943
        r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 
944
        n = int(r0)
 
945
        if e1 != 0 {
 
946
                err = errnoErr(e1)
 
947
        }
 
948
        return
 
949
}
 
950
 
 
951
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
952
 
 
953
func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 
954
        var _p0 unsafe.Pointer
 
955
        if len(p) > 0 {
 
956
                _p0 = unsafe.Pointer(&p[0])
 
957
        } else {
 
958
                _p0 = unsafe.Pointer(&_zero)
 
959
        }
 
960
        r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 
961
        n = int(r0)
 
962
        if e1 != 0 {
 
963
                err = errnoErr(e1)
 
964
        }
 
965
        return
 
966
}
 
967
 
 
968
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
969
 
 
970
func read(fd int, p []byte) (n int, err error) {
 
971
        var _p0 unsafe.Pointer
 
972
        if len(p) > 0 {
 
973
                _p0 = unsafe.Pointer(&p[0])
 
974
        } else {
 
975
                _p0 = unsafe.Pointer(&_zero)
 
976
        }
 
977
        r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 
978
        n = int(r0)
 
979
        if e1 != 0 {
 
980
                err = errnoErr(e1)
 
981
        }
 
982
        return
 
983
}
 
984
 
 
985
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
986
 
 
987
func Readlink(path string, buf []byte) (n int, err error) {
 
988
        var _p0 *byte
 
989
        _p0, err = BytePtrFromString(path)
 
990
        if err != nil {
 
991
                return
 
992
        }
 
993
        var _p1 unsafe.Pointer
 
994
        if len(buf) > 0 {
 
995
                _p1 = unsafe.Pointer(&buf[0])
 
996
        } else {
 
997
                _p1 = unsafe.Pointer(&_zero)
 
998
        }
 
999
        r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 
1000
        use(unsafe.Pointer(_p0))
 
1001
        n = int(r0)
 
1002
        if e1 != 0 {
 
1003
                err = errnoErr(e1)
 
1004
        }
 
1005
        return
 
1006
}
 
1007
 
 
1008
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1009
 
 
1010
func Rename(from string, to string) (err error) {
 
1011
        var _p0 *byte
 
1012
        _p0, err = BytePtrFromString(from)
 
1013
        if err != nil {
 
1014
                return
 
1015
        }
 
1016
        var _p1 *byte
 
1017
        _p1, err = BytePtrFromString(to)
 
1018
        if err != nil {
 
1019
                return
 
1020
        }
 
1021
        _, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
1022
        use(unsafe.Pointer(_p0))
 
1023
        use(unsafe.Pointer(_p1))
 
1024
        if e1 != 0 {
 
1025
                err = errnoErr(e1)
 
1026
        }
 
1027
        return
 
1028
}
 
1029
 
 
1030
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1031
 
 
1032
func Revoke(path string) (err error) {
 
1033
        var _p0 *byte
 
1034
        _p0, err = BytePtrFromString(path)
 
1035
        if err != nil {
 
1036
                return
 
1037
        }
 
1038
        _, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
1039
        use(unsafe.Pointer(_p0))
 
1040
        if e1 != 0 {
 
1041
                err = errnoErr(e1)
 
1042
        }
 
1043
        return
 
1044
}
 
1045
 
 
1046
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1047
 
 
1048
func Rmdir(path string) (err error) {
 
1049
        var _p0 *byte
 
1050
        _p0, err = BytePtrFromString(path)
 
1051
        if err != nil {
 
1052
                return
 
1053
        }
 
1054
        _, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
1055
        use(unsafe.Pointer(_p0))
 
1056
        if e1 != 0 {
 
1057
                err = errnoErr(e1)
 
1058
        }
 
1059
        return
 
1060
}
 
1061
 
 
1062
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1063
 
 
1064
func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
1065
        r0, _, e1 := Syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence))
 
1066
        newoffset = int64(r0)
 
1067
        if e1 != 0 {
 
1068
                err = errnoErr(e1)
 
1069
        }
 
1070
        return
 
1071
}
 
1072
 
 
1073
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1074
 
 
1075
func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
 
1076
        _, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 
1077
        if e1 != 0 {
 
1078
                err = errnoErr(e1)
 
1079
        }
 
1080
        return
 
1081
}
 
1082
 
 
1083
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1084
 
 
1085
func Setegid(egid int) (err error) {
 
1086
        _, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
 
1087
        if e1 != 0 {
 
1088
                err = errnoErr(e1)
 
1089
        }
 
1090
        return
 
1091
}
 
1092
 
 
1093
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1094
 
 
1095
func Seteuid(euid int) (err error) {
 
1096
        _, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
 
1097
        if e1 != 0 {
 
1098
                err = errnoErr(e1)
 
1099
        }
 
1100
        return
 
1101
}
 
1102
 
 
1103
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1104
 
 
1105
func Setgid(gid int) (err error) {
 
1106
        _, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
 
1107
        if e1 != 0 {
 
1108
                err = errnoErr(e1)
 
1109
        }
 
1110
        return
 
1111
}
 
1112
 
 
1113
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1114
 
 
1115
func Setlogin(name string) (err error) {
 
1116
        var _p0 *byte
 
1117
        _p0, err = BytePtrFromString(name)
 
1118
        if err != nil {
 
1119
                return
 
1120
        }
 
1121
        _, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
1122
        use(unsafe.Pointer(_p0))
 
1123
        if e1 != 0 {
 
1124
                err = errnoErr(e1)
 
1125
        }
 
1126
        return
 
1127
}
 
1128
 
 
1129
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1130
 
 
1131
func Setpgid(pid int, pgid int) (err error) {
 
1132
        _, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
 
1133
        if e1 != 0 {
 
1134
                err = errnoErr(e1)
 
1135
        }
 
1136
        return
 
1137
}
 
1138
 
 
1139
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1140
 
 
1141
func Setpriority(which int, who int, prio int) (err error) {
 
1142
        _, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
 
1143
        if e1 != 0 {
 
1144
                err = errnoErr(e1)
 
1145
        }
 
1146
        return
 
1147
}
 
1148
 
 
1149
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1150
 
 
1151
func Setprivexec(flag int) (err error) {
 
1152
        _, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
 
1153
        if e1 != 0 {
 
1154
                err = errnoErr(e1)
 
1155
        }
 
1156
        return
 
1157
}
 
1158
 
 
1159
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1160
 
 
1161
func Setregid(rgid int, egid int) (err error) {
 
1162
        _, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
 
1163
        if e1 != 0 {
 
1164
                err = errnoErr(e1)
 
1165
        }
 
1166
        return
 
1167
}
 
1168
 
 
1169
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1170
 
 
1171
func Setreuid(ruid int, euid int) (err error) {
 
1172
        _, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
 
1173
        if e1 != 0 {
 
1174
                err = errnoErr(e1)
 
1175
        }
 
1176
        return
 
1177
}
 
1178
 
 
1179
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1180
 
 
1181
func Setrlimit(which int, lim *Rlimit) (err error) {
 
1182
        _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 
1183
        if e1 != 0 {
 
1184
                err = errnoErr(e1)
 
1185
        }
 
1186
        return
 
1187
}
 
1188
 
 
1189
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1190
 
 
1191
func Setsid() (pid int, err error) {
 
1192
        r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
 
1193
        pid = int(r0)
 
1194
        if e1 != 0 {
 
1195
                err = errnoErr(e1)
 
1196
        }
 
1197
        return
 
1198
}
 
1199
 
 
1200
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1201
 
 
1202
func Settimeofday(tp *Timeval) (err error) {
 
1203
        _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
 
1204
        if e1 != 0 {
 
1205
                err = errnoErr(e1)
 
1206
        }
 
1207
        return
 
1208
}
 
1209
 
 
1210
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1211
 
 
1212
func Setuid(uid int) (err error) {
 
1213
        _, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
 
1214
        if e1 != 0 {
 
1215
                err = errnoErr(e1)
 
1216
        }
 
1217
        return
 
1218
}
 
1219
 
 
1220
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1221
 
 
1222
func Stat(path string, stat *Stat_t) (err error) {
 
1223
        var _p0 *byte
 
1224
        _p0, err = BytePtrFromString(path)
 
1225
        if err != nil {
 
1226
                return
 
1227
        }
 
1228
        _, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 
1229
        use(unsafe.Pointer(_p0))
 
1230
        if e1 != 0 {
 
1231
                err = errnoErr(e1)
 
1232
        }
 
1233
        return
 
1234
}
 
1235
 
 
1236
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1237
 
 
1238
func Statfs(path string, stat *Statfs_t) (err error) {
 
1239
        var _p0 *byte
 
1240
        _p0, err = BytePtrFromString(path)
 
1241
        if err != nil {
 
1242
                return
 
1243
        }
 
1244
        _, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 
1245
        use(unsafe.Pointer(_p0))
 
1246
        if e1 != 0 {
 
1247
                err = errnoErr(e1)
 
1248
        }
 
1249
        return
 
1250
}
 
1251
 
 
1252
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1253
 
 
1254
func Symlink(path string, link string) (err error) {
 
1255
        var _p0 *byte
 
1256
        _p0, err = BytePtrFromString(path)
 
1257
        if err != nil {
 
1258
                return
 
1259
        }
 
1260
        var _p1 *byte
 
1261
        _p1, err = BytePtrFromString(link)
 
1262
        if err != nil {
 
1263
                return
 
1264
        }
 
1265
        _, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
1266
        use(unsafe.Pointer(_p0))
 
1267
        use(unsafe.Pointer(_p1))
 
1268
        if e1 != 0 {
 
1269
                err = errnoErr(e1)
 
1270
        }
 
1271
        return
 
1272
}
 
1273
 
 
1274
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1275
 
 
1276
func Sync() (err error) {
 
1277
        _, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
 
1278
        if e1 != 0 {
 
1279
                err = errnoErr(e1)
 
1280
        }
 
1281
        return
 
1282
}
 
1283
 
 
1284
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1285
 
 
1286
func Truncate(path string, length int64) (err error) {
 
1287
        var _p0 *byte
 
1288
        _p0, err = BytePtrFromString(path)
 
1289
        if err != nil {
 
1290
                return
 
1291
        }
 
1292
        _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
 
1293
        use(unsafe.Pointer(_p0))
 
1294
        if e1 != 0 {
 
1295
                err = errnoErr(e1)
 
1296
        }
 
1297
        return
 
1298
}
 
1299
 
 
1300
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1301
 
 
1302
func Umask(newmask int) (oldmask int) {
 
1303
        r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
 
1304
        oldmask = int(r0)
 
1305
        return
 
1306
}
 
1307
 
 
1308
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1309
 
 
1310
func Undelete(path string) (err error) {
 
1311
        var _p0 *byte
 
1312
        _p0, err = BytePtrFromString(path)
 
1313
        if err != nil {
 
1314
                return
 
1315
        }
 
1316
        _, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
1317
        use(unsafe.Pointer(_p0))
 
1318
        if e1 != 0 {
 
1319
                err = errnoErr(e1)
 
1320
        }
 
1321
        return
 
1322
}
 
1323
 
 
1324
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1325
 
 
1326
func Unlink(path string) (err error) {
 
1327
        var _p0 *byte
 
1328
        _p0, err = BytePtrFromString(path)
 
1329
        if err != nil {
 
1330
                return
 
1331
        }
 
1332
        _, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
1333
        use(unsafe.Pointer(_p0))
 
1334
        if e1 != 0 {
 
1335
                err = errnoErr(e1)
 
1336
        }
 
1337
        return
 
1338
}
 
1339
 
 
1340
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1341
 
 
1342
func Unmount(path string, flags int) (err error) {
 
1343
        var _p0 *byte
 
1344
        _p0, err = BytePtrFromString(path)
 
1345
        if err != nil {
 
1346
                return
 
1347
        }
 
1348
        _, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 
1349
        use(unsafe.Pointer(_p0))
 
1350
        if e1 != 0 {
 
1351
                err = errnoErr(e1)
 
1352
        }
 
1353
        return
 
1354
}
 
1355
 
 
1356
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1357
 
 
1358
func write(fd int, p []byte) (n int, err error) {
 
1359
        var _p0 unsafe.Pointer
 
1360
        if len(p) > 0 {
 
1361
                _p0 = unsafe.Pointer(&p[0])
 
1362
        } else {
 
1363
                _p0 = unsafe.Pointer(&_zero)
 
1364
        }
 
1365
        r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 
1366
        n = int(r0)
 
1367
        if e1 != 0 {
 
1368
                err = errnoErr(e1)
 
1369
        }
 
1370
        return
 
1371
}
 
1372
 
 
1373
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1374
 
 
1375
func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
 
1376
        r0, _, e1 := Syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 
1377
        ret = uintptr(r0)
 
1378
        if e1 != 0 {
 
1379
                err = errnoErr(e1)
 
1380
        }
 
1381
        return
 
1382
}
 
1383
 
 
1384
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1385
 
 
1386
func munmap(addr uintptr, length uintptr) (err error) {
 
1387
        _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
 
1388
        if e1 != 0 {
 
1389
                err = errnoErr(e1)
 
1390
        }
 
1391
        return
 
1392
}
 
1393
 
 
1394
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1395
 
 
1396
func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 
1397
        r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 
1398
        n = int(r0)
 
1399
        if e1 != 0 {
 
1400
                err = errnoErr(e1)
 
1401
        }
 
1402
        return
 
1403
}
 
1404
 
 
1405
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1406
 
 
1407
func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 
1408
        r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 
1409
        n = int(r0)
 
1410
        if e1 != 0 {
 
1411
                err = errnoErr(e1)
 
1412
        }
 
1413
        return
 
1414
}
 
1415
 
 
1416
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1417
 
 
1418
func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
 
1419
        r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
 
1420
        sec = int64(r0)
 
1421
        usec = int32(r1)
 
1422
        if e1 != 0 {
 
1423
                err = errnoErr(e1)
 
1424
        }
 
1425
        return
 
1426
}