← 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_solaris_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_solaris_amd64.go
 
1
// mksyscall_solaris.pl syscall_solaris.go syscall_solaris_amd64.go
 
2
// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
 
3
 
 
4
// +build amd64,solaris
 
5
 
 
6
package unix
 
7
 
 
8
import "unsafe"
 
9
 
 
10
var (
 
11
        modlibc      = syscall.newLazySO("libc.so")
 
12
        modlibsocket = syscall.newLazySO("libsocket.so")
 
13
 
 
14
        procgetgroups    = modlibc.NewProc("getgroups")
 
15
        procsetgroups    = modlibc.NewProc("setgroups")
 
16
        procfcntl        = modlibc.NewProc("fcntl")
 
17
        procaccept       = modlibsocket.NewProc("accept")
 
18
        procsendmsg      = modlibsocket.NewProc("sendmsg")
 
19
        procAccess       = modlibc.NewProc("access")
 
20
        procAdjtime      = modlibc.NewProc("adjtime")
 
21
        procChdir        = modlibc.NewProc("chdir")
 
22
        procChmod        = modlibc.NewProc("chmod")
 
23
        procChown        = modlibc.NewProc("chown")
 
24
        procChroot       = modlibc.NewProc("chroot")
 
25
        procClose        = modlibc.NewProc("close")
 
26
        procDup          = modlibc.NewProc("dup")
 
27
        procExit         = modlibc.NewProc("exit")
 
28
        procFchdir       = modlibc.NewProc("fchdir")
 
29
        procFchmod       = modlibc.NewProc("fchmod")
 
30
        procFchown       = modlibc.NewProc("fchown")
 
31
        procFpathconf    = modlibc.NewProc("fpathconf")
 
32
        procFstat        = modlibc.NewProc("fstat")
 
33
        procGetdents     = modlibc.NewProc("getdents")
 
34
        procGetgid       = modlibc.NewProc("getgid")
 
35
        procGetpid       = modlibc.NewProc("getpid")
 
36
        procGeteuid      = modlibc.NewProc("geteuid")
 
37
        procGetegid      = modlibc.NewProc("getegid")
 
38
        procGetppid      = modlibc.NewProc("getppid")
 
39
        procGetpriority  = modlibc.NewProc("getpriority")
 
40
        procGetrlimit    = modlibc.NewProc("getrlimit")
 
41
        procGettimeofday = modlibc.NewProc("gettimeofday")
 
42
        procGetuid       = modlibc.NewProc("getuid")
 
43
        procKill         = modlibc.NewProc("kill")
 
44
        procLchown       = modlibc.NewProc("lchown")
 
45
        procLink         = modlibc.NewProc("link")
 
46
        proclisten       = modlibsocket.NewProc("listen")
 
47
        procLstat        = modlibc.NewProc("lstat")
 
48
        procMkdir        = modlibc.NewProc("mkdir")
 
49
        procMknod        = modlibc.NewProc("mknod")
 
50
        procNanosleep    = modlibc.NewProc("nanosleep")
 
51
        procOpen         = modlibc.NewProc("open")
 
52
        procPathconf     = modlibc.NewProc("pathconf")
 
53
        procPread        = modlibc.NewProc("pread")
 
54
        procPwrite       = modlibc.NewProc("pwrite")
 
55
        procread         = modlibc.NewProc("read")
 
56
        procReadlink     = modlibc.NewProc("readlink")
 
57
        procRename       = modlibc.NewProc("rename")
 
58
        procRmdir        = modlibc.NewProc("rmdir")
 
59
        proclseek        = modlibc.NewProc("lseek")
 
60
        procSetegid      = modlibc.NewProc("setegid")
 
61
        procSeteuid      = modlibc.NewProc("seteuid")
 
62
        procSetgid       = modlibc.NewProc("setgid")
 
63
        procSetpgid      = modlibc.NewProc("setpgid")
 
64
        procSetpriority  = modlibc.NewProc("setpriority")
 
65
        procSetregid     = modlibc.NewProc("setregid")
 
66
        procSetreuid     = modlibc.NewProc("setreuid")
 
67
        procSetrlimit    = modlibc.NewProc("setrlimit")
 
68
        procSetsid       = modlibc.NewProc("setsid")
 
69
        procSetuid       = modlibc.NewProc("setuid")
 
70
        procshutdown     = modlibsocket.NewProc("shutdown")
 
71
        procStat         = modlibc.NewProc("stat")
 
72
        procSymlink      = modlibc.NewProc("symlink")
 
73
        procSync         = modlibc.NewProc("sync")
 
74
        procTruncate     = modlibc.NewProc("truncate")
 
75
        procFsync        = modlibc.NewProc("fsync")
 
76
        procFtruncate    = modlibc.NewProc("ftruncate")
 
77
        procUmask        = modlibc.NewProc("umask")
 
78
        procUnlink       = modlibc.NewProc("unlink")
 
79
        procUtimes       = modlibc.NewProc("utimes")
 
80
        procbind         = modlibsocket.NewProc("bind")
 
81
        procconnect      = modlibsocket.NewProc("connect")
 
82
        procmmap         = modlibc.NewProc("mmap")
 
83
        procmunmap       = modlibc.NewProc("munmap")
 
84
        procsendto       = modlibsocket.NewProc("sendto")
 
85
        procsocket       = modlibsocket.NewProc("socket")
 
86
        procsocketpair   = modlibsocket.NewProc("socketpair")
 
87
        procwrite        = modlibc.NewProc("write")
 
88
        procgetsockopt   = modlibsocket.NewProc("getsockopt")
 
89
        procgetpeername  = modlibsocket.NewProc("getpeername")
 
90
        procgetsockname  = modlibsocket.NewProc("getsockname")
 
91
        procsetsockopt   = modlibsocket.NewProc("setsockopt")
 
92
        procrecvfrom     = modlibsocket.NewProc("recvfrom")
 
93
        procrecvmsg      = modlibsocket.NewProc("recvmsg")
 
94
)
 
95
 
 
96
func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 
97
        r0, _, e1 := rawSysvicall6(procgetgroups.Addr(), 2, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0, 0, 0, 0)
 
98
        n = int(r0)
 
99
        if e1 != 0 {
 
100
                err = e1
 
101
        }
 
102
        return
 
103
}
 
104
 
 
105
func setgroups(ngid int, gid *_Gid_t) (err error) {
 
106
        _, _, e1 := rawSysvicall6(procsetgroups.Addr(), 2, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0, 0, 0, 0)
 
107
        if e1 != 0 {
 
108
                err = e1
 
109
        }
 
110
        return
 
111
}
 
112
 
 
113
func fcntl(fd int, cmd int, arg int) (val int, err error) {
 
114
        r0, _, e1 := sysvicall6(procfcntl.Addr(), 3, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
 
115
        val = int(r0)
 
116
        if e1 != 0 {
 
117
                err = e1
 
118
        }
 
119
        return
 
120
}
 
121
 
 
122
func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 
123
        r0, _, e1 := sysvicall6(procaccept.Addr(), 3, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
 
124
        fd = int(r0)
 
125
        if e1 != 0 {
 
126
                err = e1
 
127
        }
 
128
        return
 
129
}
 
130
 
 
131
func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
132
        r0, _, e1 := sysvicall6(procsendmsg.Addr(), 3, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
 
133
        n = int(r0)
 
134
        if e1 != 0 {
 
135
                err = e1
 
136
        }
 
137
        return
 
138
}
 
139
 
 
140
func Access(path string, mode uint32) (err error) {
 
141
        var _p0 *byte
 
142
        _p0, err = BytePtrFromString(path)
 
143
        if err != nil {
 
144
                return
 
145
        }
 
146
        _, _, e1 := sysvicall6(procAccess.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0, 0, 0, 0)
 
147
        use(unsafe.Pointer(_p0))
 
148
        if e1 != 0 {
 
149
                err = e1
 
150
        }
 
151
        return
 
152
}
 
153
 
 
154
func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
 
155
        _, _, e1 := sysvicall6(procAdjtime.Addr(), 2, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0, 0, 0, 0)
 
156
        if e1 != 0 {
 
157
                err = e1
 
158
        }
 
159
        return
 
160
}
 
161
 
 
162
func Chdir(path string) (err error) {
 
163
        var _p0 *byte
 
164
        _p0, err = BytePtrFromString(path)
 
165
        if err != nil {
 
166
                return
 
167
        }
 
168
        _, _, e1 := sysvicall6(procChdir.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0, 0, 0, 0)
 
169
        use(unsafe.Pointer(_p0))
 
170
        if e1 != 0 {
 
171
                err = e1
 
172
        }
 
173
        return
 
174
}
 
175
 
 
176
func Chmod(path string, mode uint32) (err error) {
 
177
        var _p0 *byte
 
178
        _p0, err = BytePtrFromString(path)
 
179
        if err != nil {
 
180
                return
 
181
        }
 
182
        _, _, e1 := sysvicall6(procChmod.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0, 0, 0, 0)
 
183
        use(unsafe.Pointer(_p0))
 
184
        if e1 != 0 {
 
185
                err = e1
 
186
        }
 
187
        return
 
188
}
 
189
 
 
190
func Chown(path string, uid int, gid int) (err error) {
 
191
        var _p0 *byte
 
192
        _p0, err = BytePtrFromString(path)
 
193
        if err != nil {
 
194
                return
 
195
        }
 
196
        _, _, e1 := sysvicall6(procChown.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), 0, 0, 0)
 
197
        use(unsafe.Pointer(_p0))
 
198
        if e1 != 0 {
 
199
                err = e1
 
200
        }
 
201
        return
 
202
}
 
203
 
 
204
func Chroot(path string) (err error) {
 
205
        var _p0 *byte
 
206
        _p0, err = BytePtrFromString(path)
 
207
        if err != nil {
 
208
                return
 
209
        }
 
210
        _, _, e1 := sysvicall6(procChroot.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0, 0, 0, 0)
 
211
        use(unsafe.Pointer(_p0))
 
212
        if e1 != 0 {
 
213
                err = e1
 
214
        }
 
215
        return
 
216
}
 
217
 
 
218
func Close(fd int) (err error) {
 
219
        _, _, e1 := sysvicall6(procClose.Addr(), 1, uintptr(fd), 0, 0, 0, 0, 0)
 
220
        if e1 != 0 {
 
221
                err = e1
 
222
        }
 
223
        return
 
224
}
 
225
 
 
226
func Dup(fd int) (nfd int, err error) {
 
227
        r0, _, e1 := sysvicall6(procDup.Addr(), 1, uintptr(fd), 0, 0, 0, 0, 0)
 
228
        nfd = int(r0)
 
229
        if e1 != 0 {
 
230
                err = e1
 
231
        }
 
232
        return
 
233
}
 
234
 
 
235
func Exit(code int) {
 
236
        sysvicall6(procExit.Addr(), 1, uintptr(code), 0, 0, 0, 0, 0)
 
237
        return
 
238
}
 
239
 
 
240
func Fchdir(fd int) (err error) {
 
241
        _, _, e1 := sysvicall6(procFchdir.Addr(), 1, uintptr(fd), 0, 0, 0, 0, 0)
 
242
        if e1 != 0 {
 
243
                err = e1
 
244
        }
 
245
        return
 
246
}
 
247
 
 
248
func Fchmod(fd int, mode uint32) (err error) {
 
249
        _, _, e1 := sysvicall6(procFchmod.Addr(), 2, uintptr(fd), uintptr(mode), 0, 0, 0, 0)
 
250
        if e1 != 0 {
 
251
                err = e1
 
252
        }
 
253
        return
 
254
}
 
255
 
 
256
func Fchown(fd int, uid int, gid int) (err error) {
 
257
        _, _, e1 := sysvicall6(procFchown.Addr(), 3, uintptr(fd), uintptr(uid), uintptr(gid), 0, 0, 0)
 
258
        if e1 != 0 {
 
259
                err = e1
 
260
        }
 
261
        return
 
262
}
 
263
 
 
264
func Fpathconf(fd int, name int) (val int, err error) {
 
265
        r0, _, e1 := sysvicall6(procFpathconf.Addr(), 2, uintptr(fd), uintptr(name), 0, 0, 0, 0)
 
266
        val = int(r0)
 
267
        if e1 != 0 {
 
268
                err = e1
 
269
        }
 
270
        return
 
271
}
 
272
 
 
273
func Fstat(fd int, stat *Stat_t) (err error) {
 
274
        _, _, e1 := sysvicall6(procFstat.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0, 0, 0, 0)
 
275
        if e1 != 0 {
 
276
                err = e1
 
277
        }
 
278
        return
 
279
}
 
280
 
 
281
func Getdents(fd int, buf []byte, basep *uintptr) (n int, err error) {
 
282
        var _p0 *byte
 
283
        if len(buf) > 0 {
 
284
                _p0 = &buf[0]
 
285
        }
 
286
        r0, _, e1 := sysvicall6(procGetdents.Addr(), 4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
 
287
        n = int(r0)
 
288
        if e1 != 0 {
 
289
                err = e1
 
290
        }
 
291
        return
 
292
}
 
293
 
 
294
func Getgid() (gid int) {
 
295
        r0, _, _ := rawSysvicall6(procGetgid.Addr(), 0, 0, 0, 0, 0, 0, 0)
 
296
        gid = int(r0)
 
297
        return
 
298
}
 
299
 
 
300
func Getpid() (pid int) {
 
301
        r0, _, _ := rawSysvicall6(procGetpid.Addr(), 0, 0, 0, 0, 0, 0, 0)
 
302
        pid = int(r0)
 
303
        return
 
304
}
 
305
 
 
306
func Geteuid() (euid int) {
 
307
        r0, _, _ := sysvicall6(procGeteuid.Addr(), 0, 0, 0, 0, 0, 0, 0)
 
308
        euid = int(r0)
 
309
        return
 
310
}
 
311
 
 
312
func Getegid() (egid int) {
 
313
        r0, _, _ := sysvicall6(procGetegid.Addr(), 0, 0, 0, 0, 0, 0, 0)
 
314
        egid = int(r0)
 
315
        return
 
316
}
 
317
 
 
318
func Getppid() (ppid int) {
 
319
        r0, _, _ := sysvicall6(procGetppid.Addr(), 0, 0, 0, 0, 0, 0, 0)
 
320
        ppid = int(r0)
 
321
        return
 
322
}
 
323
 
 
324
func Getpriority(which int, who int) (n int, err error) {
 
325
        r0, _, e1 := sysvicall6(procGetpriority.Addr(), 2, uintptr(which), uintptr(who), 0, 0, 0, 0)
 
326
        n = int(r0)
 
327
        if e1 != 0 {
 
328
                err = e1
 
329
        }
 
330
        return
 
331
}
 
332
 
 
333
func Getrlimit(which int, lim *Rlimit) (err error) {
 
334
        _, _, e1 := rawSysvicall6(procGetrlimit.Addr(), 2, uintptr(which), uintptr(unsafe.Pointer(lim)), 0, 0, 0, 0)
 
335
        if e1 != 0 {
 
336
                err = e1
 
337
        }
 
338
        return
 
339
}
 
340
 
 
341
func Gettimeofday(tv *Timeval) (err error) {
 
342
        _, _, e1 := rawSysvicall6(procGettimeofday.Addr(), 1, uintptr(unsafe.Pointer(tv)), 0, 0, 0, 0, 0)
 
343
        if e1 != 0 {
 
344
                err = e1
 
345
        }
 
346
        return
 
347
}
 
348
 
 
349
func Getuid() (uid int) {
 
350
        r0, _, _ := rawSysvicall6(procGetuid.Addr(), 0, 0, 0, 0, 0, 0, 0)
 
351
        uid = int(r0)
 
352
        return
 
353
}
 
354
 
 
355
func Kill(pid int, signum syscall.Signal) (err error) {
 
356
        _, _, e1 := sysvicall6(procKill.Addr(), 2, uintptr(pid), uintptr(signum), 0, 0, 0, 0)
 
357
        if e1 != 0 {
 
358
                err = e1
 
359
        }
 
360
        return
 
361
}
 
362
 
 
363
func Lchown(path string, uid int, gid int) (err error) {
 
364
        var _p0 *byte
 
365
        _p0, err = BytePtrFromString(path)
 
366
        if err != nil {
 
367
                return
 
368
        }
 
369
        _, _, e1 := sysvicall6(procLchown.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), 0, 0, 0)
 
370
        use(unsafe.Pointer(_p0))
 
371
        if e1 != 0 {
 
372
                err = e1
 
373
        }
 
374
        return
 
375
}
 
376
 
 
377
func Link(path string, link string) (err error) {
 
378
        var _p0 *byte
 
379
        _p0, err = BytePtrFromString(path)
 
380
        if err != nil {
 
381
                return
 
382
        }
 
383
        var _p1 *byte
 
384
        _p1, err = BytePtrFromString(link)
 
385
        if err != nil {
 
386
                return
 
387
        }
 
388
        _, _, e1 := sysvicall6(procLink.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0, 0, 0)
 
389
        use(unsafe.Pointer(_p0))
 
390
        use(unsafe.Pointer(_p1))
 
391
        if e1 != 0 {
 
392
                err = e1
 
393
        }
 
394
        return
 
395
}
 
396
 
 
397
func Listen(s int, backlog int) (err error) {
 
398
        _, _, e1 := sysvicall6(proclisten.Addr(), 2, uintptr(s), uintptr(backlog), 0, 0, 0, 0)
 
399
        if e1 != 0 {
 
400
                err = e1
 
401
        }
 
402
        return
 
403
}
 
404
 
 
405
func Lstat(path string, stat *Stat_t) (err error) {
 
406
        var _p0 *byte
 
407
        _p0, err = BytePtrFromString(path)
 
408
        if err != nil {
 
409
                return
 
410
        }
 
411
        _, _, e1 := sysvicall6(procLstat.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0, 0, 0, 0)
 
412
        use(unsafe.Pointer(_p0))
 
413
        if e1 != 0 {
 
414
                err = e1
 
415
        }
 
416
        return
 
417
}
 
418
 
 
419
func Mkdir(path string, mode uint32) (err error) {
 
420
        var _p0 *byte
 
421
        _p0, err = BytePtrFromString(path)
 
422
        if err != nil {
 
423
                return
 
424
        }
 
425
        _, _, e1 := sysvicall6(procMkdir.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0, 0, 0, 0)
 
426
        use(unsafe.Pointer(_p0))
 
427
        if e1 != 0 {
 
428
                err = e1
 
429
        }
 
430
        return
 
431
}
 
432
 
 
433
func Mknod(path string, mode uint32, dev int) (err error) {
 
434
        var _p0 *byte
 
435
        _p0, err = BytePtrFromString(path)
 
436
        if err != nil {
 
437
                return
 
438
        }
 
439
        _, _, e1 := sysvicall6(procMknod.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0, 0)
 
440
        use(unsafe.Pointer(_p0))
 
441
        if e1 != 0 {
 
442
                err = e1
 
443
        }
 
444
        return
 
445
}
 
446
 
 
447
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
 
448
        _, _, e1 := sysvicall6(procNanosleep.Addr(), 2, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0, 0, 0, 0)
 
449
        if e1 != 0 {
 
450
                err = e1
 
451
        }
 
452
        return
 
453
}
 
454
 
 
455
func Open(path string, mode int, perm uint32) (fd int, err error) {
 
456
        var _p0 *byte
 
457
        _p0, err = BytePtrFromString(path)
 
458
        if err != nil {
 
459
                return
 
460
        }
 
461
        r0, _, e1 := sysvicall6(procOpen.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0, 0)
 
462
        use(unsafe.Pointer(_p0))
 
463
        fd = int(r0)
 
464
        if e1 != 0 {
 
465
                err = e1
 
466
        }
 
467
        return
 
468
}
 
469
 
 
470
func Pathconf(path string, name int) (val int, err error) {
 
471
        var _p0 *byte
 
472
        _p0, err = BytePtrFromString(path)
 
473
        if err != nil {
 
474
                return
 
475
        }
 
476
        r0, _, e1 := sysvicall6(procPathconf.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0, 0, 0, 0)
 
477
        use(unsafe.Pointer(_p0))
 
478
        val = int(r0)
 
479
        if e1 != 0 {
 
480
                err = e1
 
481
        }
 
482
        return
 
483
}
 
484
 
 
485
func Pread(fd int, p []byte, offset int64) (n int, err error) {
 
486
        var _p0 *byte
 
487
        if len(p) > 0 {
 
488
                _p0 = &p[0]
 
489
        }
 
490
        r0, _, e1 := sysvicall6(procPread.Addr(), 4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), uintptr(offset), 0, 0)
 
491
        n = int(r0)
 
492
        if e1 != 0 {
 
493
                err = e1
 
494
        }
 
495
        return
 
496
}
 
497
 
 
498
func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 
499
        var _p0 *byte
 
500
        if len(p) > 0 {
 
501
                _p0 = &p[0]
 
502
        }
 
503
        r0, _, e1 := sysvicall6(procPwrite.Addr(), 4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), uintptr(offset), 0, 0)
 
504
        n = int(r0)
 
505
        if e1 != 0 {
 
506
                err = e1
 
507
        }
 
508
        return
 
509
}
 
510
 
 
511
func read(fd int, p []byte) (n int, err error) {
 
512
        var _p0 *byte
 
513
        if len(p) > 0 {
 
514
                _p0 = &p[0]
 
515
        }
 
516
        r0, _, e1 := sysvicall6(procread.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), 0, 0, 0)
 
517
        n = int(r0)
 
518
        if e1 != 0 {
 
519
                err = e1
 
520
        }
 
521
        return
 
522
}
 
523
 
 
524
func Readlink(path string, buf []byte) (n int, err error) {
 
525
        var _p0 *byte
 
526
        _p0, err = BytePtrFromString(path)
 
527
        if err != nil {
 
528
                return
 
529
        }
 
530
        var _p1 *byte
 
531
        if len(buf) > 0 {
 
532
                _p1 = &buf[0]
 
533
        }
 
534
        r0, _, e1 := sysvicall6(procReadlink.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(len(buf)), 0, 0, 0)
 
535
        use(unsafe.Pointer(_p0))
 
536
        n = int(r0)
 
537
        if e1 != 0 {
 
538
                err = e1
 
539
        }
 
540
        return
 
541
}
 
542
 
 
543
func Rename(from string, to string) (err error) {
 
544
        var _p0 *byte
 
545
        _p0, err = BytePtrFromString(from)
 
546
        if err != nil {
 
547
                return
 
548
        }
 
549
        var _p1 *byte
 
550
        _p1, err = BytePtrFromString(to)
 
551
        if err != nil {
 
552
                return
 
553
        }
 
554
        _, _, e1 := sysvicall6(procRename.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0, 0, 0)
 
555
        use(unsafe.Pointer(_p0))
 
556
        use(unsafe.Pointer(_p1))
 
557
        if e1 != 0 {
 
558
                err = e1
 
559
        }
 
560
        return
 
561
}
 
562
 
 
563
func Rmdir(path string) (err error) {
 
564
        var _p0 *byte
 
565
        _p0, err = BytePtrFromString(path)
 
566
        if err != nil {
 
567
                return
 
568
        }
 
569
        _, _, e1 := sysvicall6(procRmdir.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0, 0, 0, 0)
 
570
        use(unsafe.Pointer(_p0))
 
571
        if e1 != 0 {
 
572
                err = e1
 
573
        }
 
574
        return
 
575
}
 
576
 
 
577
func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
578
        r0, _, e1 := sysvicall6(proclseek.Addr(), 3, uintptr(fd), uintptr(offset), uintptr(whence), 0, 0, 0)
 
579
        newoffset = int64(r0)
 
580
        if e1 != 0 {
 
581
                err = e1
 
582
        }
 
583
        return
 
584
}
 
585
 
 
586
func Setegid(egid int) (err error) {
 
587
        _, _, e1 := rawSysvicall6(procSetegid.Addr(), 1, uintptr(egid), 0, 0, 0, 0, 0)
 
588
        if e1 != 0 {
 
589
                err = e1
 
590
        }
 
591
        return
 
592
}
 
593
 
 
594
func Seteuid(euid int) (err error) {
 
595
        _, _, e1 := rawSysvicall6(procSeteuid.Addr(), 1, uintptr(euid), 0, 0, 0, 0, 0)
 
596
        if e1 != 0 {
 
597
                err = e1
 
598
        }
 
599
        return
 
600
}
 
601
 
 
602
func Setgid(gid int) (err error) {
 
603
        _, _, e1 := rawSysvicall6(procSetgid.Addr(), 1, uintptr(gid), 0, 0, 0, 0, 0)
 
604
        if e1 != 0 {
 
605
                err = e1
 
606
        }
 
607
        return
 
608
}
 
609
 
 
610
func Setpgid(pid int, pgid int) (err error) {
 
611
        _, _, e1 := rawSysvicall6(procSetpgid.Addr(), 2, uintptr(pid), uintptr(pgid), 0, 0, 0, 0)
 
612
        if e1 != 0 {
 
613
                err = e1
 
614
        }
 
615
        return
 
616
}
 
617
 
 
618
func Setpriority(which int, who int, prio int) (err error) {
 
619
        _, _, e1 := sysvicall6(procSetpriority.Addr(), 3, uintptr(which), uintptr(who), uintptr(prio), 0, 0, 0)
 
620
        if e1 != 0 {
 
621
                err = e1
 
622
        }
 
623
        return
 
624
}
 
625
 
 
626
func Setregid(rgid int, egid int) (err error) {
 
627
        _, _, e1 := rawSysvicall6(procSetregid.Addr(), 2, uintptr(rgid), uintptr(egid), 0, 0, 0, 0)
 
628
        if e1 != 0 {
 
629
                err = e1
 
630
        }
 
631
        return
 
632
}
 
633
 
 
634
func Setreuid(ruid int, euid int) (err error) {
 
635
        _, _, e1 := rawSysvicall6(procSetreuid.Addr(), 2, uintptr(ruid), uintptr(euid), 0, 0, 0, 0)
 
636
        if e1 != 0 {
 
637
                err = e1
 
638
        }
 
639
        return
 
640
}
 
641
 
 
642
func Setrlimit(which int, lim *Rlimit) (err error) {
 
643
        _, _, e1 := rawSysvicall6(procSetrlimit.Addr(), 2, uintptr(which), uintptr(unsafe.Pointer(lim)), 0, 0, 0, 0)
 
644
        if e1 != 0 {
 
645
                err = e1
 
646
        }
 
647
        return
 
648
}
 
649
 
 
650
func Setsid() (pid int, err error) {
 
651
        r0, _, e1 := rawSysvicall6(procSetsid.Addr(), 0, 0, 0, 0, 0, 0, 0)
 
652
        pid = int(r0)
 
653
        if e1 != 0 {
 
654
                err = e1
 
655
        }
 
656
        return
 
657
}
 
658
 
 
659
func Setuid(uid int) (err error) {
 
660
        _, _, e1 := rawSysvicall6(procSetuid.Addr(), 1, uintptr(uid), 0, 0, 0, 0, 0)
 
661
        if e1 != 0 {
 
662
                err = e1
 
663
        }
 
664
        return
 
665
}
 
666
 
 
667
func Shutdown(s int, how int) (err error) {
 
668
        _, _, e1 := sysvicall6(procshutdown.Addr(), 2, uintptr(s), uintptr(how), 0, 0, 0, 0)
 
669
        if e1 != 0 {
 
670
                err = e1
 
671
        }
 
672
        return
 
673
}
 
674
 
 
675
func Stat(path string, stat *Stat_t) (err error) {
 
676
        var _p0 *byte
 
677
        _p0, err = BytePtrFromString(path)
 
678
        if err != nil {
 
679
                return
 
680
        }
 
681
        _, _, e1 := sysvicall6(procStat.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0, 0, 0, 0)
 
682
        use(unsafe.Pointer(_p0))
 
683
        if e1 != 0 {
 
684
                err = e1
 
685
        }
 
686
        return
 
687
}
 
688
 
 
689
func Symlink(path string, link string) (err error) {
 
690
        var _p0 *byte
 
691
        _p0, err = BytePtrFromString(path)
 
692
        if err != nil {
 
693
                return
 
694
        }
 
695
        var _p1 *byte
 
696
        _p1, err = BytePtrFromString(link)
 
697
        if err != nil {
 
698
                return
 
699
        }
 
700
        _, _, e1 := sysvicall6(procSymlink.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0, 0, 0)
 
701
        use(unsafe.Pointer(_p0))
 
702
        use(unsafe.Pointer(_p1))
 
703
        if e1 != 0 {
 
704
                err = e1
 
705
        }
 
706
        return
 
707
}
 
708
 
 
709
func Sync() (err error) {
 
710
        _, _, e1 := sysvicall6(procSync.Addr(), 0, 0, 0, 0, 0, 0, 0)
 
711
        if e1 != 0 {
 
712
                err = e1
 
713
        }
 
714
        return
 
715
}
 
716
 
 
717
func Truncate(path string, length int64) (err error) {
 
718
        var _p0 *byte
 
719
        _p0, err = BytePtrFromString(path)
 
720
        if err != nil {
 
721
                return
 
722
        }
 
723
        _, _, e1 := sysvicall6(procTruncate.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0, 0, 0, 0)
 
724
        use(unsafe.Pointer(_p0))
 
725
        if e1 != 0 {
 
726
                err = e1
 
727
        }
 
728
        return
 
729
}
 
730
 
 
731
func Fsync(fd int) (err error) {
 
732
        _, _, e1 := sysvicall6(procFsync.Addr(), 1, uintptr(fd), 0, 0, 0, 0, 0)
 
733
        if e1 != 0 {
 
734
                err = e1
 
735
        }
 
736
        return
 
737
}
 
738
 
 
739
func Ftruncate(fd int, length int64) (err error) {
 
740
        _, _, e1 := sysvicall6(procFtruncate.Addr(), 2, uintptr(fd), uintptr(length), 0, 0, 0, 0)
 
741
        if e1 != 0 {
 
742
                err = e1
 
743
        }
 
744
        return
 
745
}
 
746
 
 
747
func Umask(newmask int) (oldmask int) {
 
748
        r0, _, _ := sysvicall6(procUmask.Addr(), 1, uintptr(newmask), 0, 0, 0, 0, 0)
 
749
        oldmask = int(r0)
 
750
        return
 
751
}
 
752
 
 
753
func Unlink(path string) (err error) {
 
754
        var _p0 *byte
 
755
        _p0, err = BytePtrFromString(path)
 
756
        if err != nil {
 
757
                return
 
758
        }
 
759
        _, _, e1 := sysvicall6(procUnlink.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0, 0, 0, 0)
 
760
        use(unsafe.Pointer(_p0))
 
761
        if e1 != 0 {
 
762
                err = e1
 
763
        }
 
764
        return
 
765
}
 
766
 
 
767
func Utimes(path string, times *[2]Timeval) (err error) {
 
768
        var _p0 *byte
 
769
        _p0, err = BytePtrFromString(path)
 
770
        if err != nil {
 
771
                return
 
772
        }
 
773
        _, _, e1 := sysvicall6(procUtimes.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0, 0, 0, 0)
 
774
        use(unsafe.Pointer(_p0))
 
775
        if e1 != 0 {
 
776
                err = e1
 
777
        }
 
778
        return
 
779
}
 
780
 
 
781
func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
782
        _, _, e1 := sysvicall6(procbind.Addr(), 3, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
 
783
        if e1 != 0 {
 
784
                err = e1
 
785
        }
 
786
        return
 
787
}
 
788
 
 
789
func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
790
        _, _, e1 := sysvicall6(procconnect.Addr(), 3, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
 
791
        if e1 != 0 {
 
792
                err = e1
 
793
        }
 
794
        return
 
795
}
 
796
 
 
797
func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
 
798
        r0, _, e1 := sysvicall6(procmmap.Addr(), 6, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 
799
        ret = uintptr(r0)
 
800
        if e1 != 0 {
 
801
                err = e1
 
802
        }
 
803
        return
 
804
}
 
805
 
 
806
func munmap(addr uintptr, length uintptr) (err error) {
 
807
        _, _, e1 := sysvicall6(procmunmap.Addr(), 2, uintptr(addr), uintptr(length), 0, 0, 0, 0)
 
808
        if e1 != 0 {
 
809
                err = e1
 
810
        }
 
811
        return
 
812
}
 
813
 
 
814
func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
 
815
        var _p0 *byte
 
816
        if len(buf) > 0 {
 
817
                _p0 = &buf[0]
 
818
        }
 
819
        _, _, e1 := sysvicall6(procsendto.Addr(), 6, uintptr(s), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 
820
        if e1 != 0 {
 
821
                err = e1
 
822
        }
 
823
        return
 
824
}
 
825
 
 
826
func socket(domain int, typ int, proto int) (fd int, err error) {
 
827
        r0, _, e1 := sysvicall6(procsocket.Addr(), 3, uintptr(domain), uintptr(typ), uintptr(proto), 0, 0, 0)
 
828
        fd = int(r0)
 
829
        if e1 != 0 {
 
830
                err = e1
 
831
        }
 
832
        return
 
833
}
 
834
 
 
835
func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
 
836
        _, _, e1 := rawSysvicall6(procsocketpair.Addr(), 4, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 
837
        if e1 != 0 {
 
838
                err = e1
 
839
        }
 
840
        return
 
841
}
 
842
 
 
843
func write(fd int, p []byte) (n int, err error) {
 
844
        var _p0 *byte
 
845
        if len(p) > 0 {
 
846
                _p0 = &p[0]
 
847
        }
 
848
        r0, _, e1 := sysvicall6(procwrite.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), 0, 0, 0)
 
849
        n = int(r0)
 
850
        if e1 != 0 {
 
851
                err = e1
 
852
        }
 
853
        return
 
854
}
 
855
 
 
856
func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
 
857
        _, _, e1 := sysvicall6(procgetsockopt.Addr(), 5, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 
858
        if e1 != 0 {
 
859
                err = e1
 
860
        }
 
861
        return
 
862
}
 
863
 
 
864
func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
865
        _, _, e1 := rawSysvicall6(procgetpeername.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
 
866
        if e1 != 0 {
 
867
                err = e1
 
868
        }
 
869
        return
 
870
}
 
871
 
 
872
func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
873
        _, _, e1 := sysvicall6(procgetsockname.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
 
874
        if e1 != 0 {
 
875
                err = e1
 
876
        }
 
877
        return
 
878
}
 
879
 
 
880
func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
 
881
        _, _, e1 := sysvicall6(procsetsockopt.Addr(), 5, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 
882
        if e1 != 0 {
 
883
                err = e1
 
884
        }
 
885
        return
 
886
}
 
887
 
 
888
func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
 
889
        var _p0 *byte
 
890
        if len(p) > 0 {
 
891
                _p0 = &p[0]
 
892
        }
 
893
        r0, _, e1 := sysvicall6(procrecvfrom.Addr(), 6, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 
894
        n = int(r0)
 
895
        if e1 != 0 {
 
896
                err = e1
 
897
        }
 
898
        return
 
899
}
 
900
 
 
901
func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
902
        r0, _, e1 := sysvicall6(procrecvmsg.Addr(), 3, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
 
903
        n = int(r0)
 
904
        if e1 != 0 {
 
905
                err = e1
 
906
        }
 
907
        return
 
908
}