← Back to branch summary

~ubuntu-branches/ubuntu/vivid/juju-core/vivid-updates

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Curtis C. Hovey
  • Date: 2015-09-29 19:43:29 UTC
  • mfrom: (47.1.4 wily-proposed)
  • Revision ID: package-import@ubuntu.com-20150929194329-9y496tbic30hc7vp
Tags: 1.24.6-0ubuntu1~15.04.1
https://launchpad.net/bugs/1500916
https://launchpad.net/bugs/1497087
Backport of 1.24.6 from wily. (LP: #1500916, #1497087)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/gabriel-samfira/sys/unix/syscall_bsd.go
 
1
// 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
// +build darwin dragonfly freebsd netbsd openbsd
 
6
 
 
7
// BSD system call wrappers shared by *BSD based systems
 
8
// including OS X (Darwin) and FreeBSD.  Like the other
 
9
// syscall_*.go files it is compiled as Go code but also
 
10
// used as input to mksyscall which parses the //sys
 
11
// lines and generates system call stubs.
 
12
 
 
13
package unix
 
14
 
 
15
import (
 
16
        "runtime"
 
17
        "syscall"
 
18
        "unsafe"
 
19
)
 
20
 
 
21
/*
 
22
 * Wrapped
 
23
 */
 
24
 
 
25
//sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error)
 
26
//sysnb setgroups(ngid int, gid *_Gid_t) (err error)
 
27
 
 
28
func Getgroups() (gids []int, err error) {
 
29
        n, err := getgroups(0, nil)
 
30
        if err != nil {
 
31
                return nil, err
 
32
        }
 
33
        if n == 0 {
 
34
                return nil, nil
 
35
        }
 
36
 
 
37
        // Sanity check group count.  Max is 16 on BSD.
 
38
        if n < 0 || n > 1000 {
 
39
                return nil, EINVAL
 
40
        }
 
41
 
 
42
        a := make([]_Gid_t, n)
 
43
        n, err = getgroups(n, &a[0])
 
44
        if err != nil {
 
45
                return nil, err
 
46
        }
 
47
        gids = make([]int, n)
 
48
        for i, v := range a[0:n] {
 
49
                gids[i] = int(v)
 
50
        }
 
51
        return
 
52
}
 
53
 
 
54
func Setgroups(gids []int) (err error) {
 
55
        if len(gids) == 0 {
 
56
                return setgroups(0, nil)
 
57
        }
 
58
 
 
59
        a := make([]_Gid_t, len(gids))
 
60
        for i, v := range gids {
 
61
                a[i] = _Gid_t(v)
 
62
        }
 
63
        return setgroups(len(a), &a[0])
 
64
}
 
65
 
 
66
func ReadDirent(fd int, buf []byte) (n int, err error) {
 
67
        // Final argument is (basep *uintptr) and the syscall doesn't take nil.
 
68
        // 64 bits should be enough. (32 bits isn't even on 386). Since the
 
69
        // actual system call is getdirentries64, 64 is a good guess.
 
70
        // TODO(rsc): Can we use a single global basep for all calls?
 
71
        var base = (*uintptr)(unsafe.Pointer(new(uint64)))
 
72
        return Getdirentries(fd, buf, base)
 
73
}
 
74
 
 
75
// Wait status is 7 bits at bottom, either 0 (exited),
 
76
// 0x7F (stopped), or a signal number that caused an exit.
 
77
// The 0x80 bit is whether there was a core dump.
 
78
// An extra number (exit code, signal causing a stop)
 
79
// is in the high bits.
 
80
 
 
81
type WaitStatus uint32
 
82
 
 
83
const (
 
84
        mask  = 0x7F
 
85
        core  = 0x80
 
86
        shift = 8
 
87
 
 
88
        exited  = 0
 
89
        stopped = 0x7F
 
90
)
 
91
 
 
92
func (w WaitStatus) Exited() bool { return w&mask == exited }
 
93
 
 
94
func (w WaitStatus) ExitStatus() int {
 
95
        if w&mask != exited {
 
96
                return -1
 
97
        }
 
98
        return int(w >> shift)
 
99
}
 
100
 
 
101
func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 }
 
102
 
 
103
func (w WaitStatus) Signal() syscall.Signal {
 
104
        sig := syscall.Signal(w & mask)
 
105
        if sig == stopped || sig == 0 {
 
106
                return -1
 
107
        }
 
108
        return sig
 
109
}
 
110
 
 
111
func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
 
112
 
 
113
func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP }
 
114
 
 
115
func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP }
 
116
 
 
117
func (w WaitStatus) StopSignal() syscall.Signal {
 
118
        if !w.Stopped() {
 
119
                return -1
 
120
        }
 
121
        return syscall.Signal(w>>shift) & 0xFF
 
122
}
 
123
 
 
124
func (w WaitStatus) TrapCause() int { return -1 }
 
125
 
 
126
//sys   wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error)
 
127
 
 
128
func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
 
129
        var status _C_int
 
130
        wpid, err = wait4(pid, &status, options, rusage)
 
131
        if wstatus != nil {
 
132
                *wstatus = WaitStatus(status)
 
133
        }
 
134
        return
 
135
}
 
136
 
 
137
//sys   accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error)
 
138
//sys   bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
 
139
//sys   connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
 
140
//sysnb socket(domain int, typ int, proto int) (fd int, err error)
 
141
//sys   getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
 
142
//sys   setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error)
 
143
//sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
 
144
//sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
 
145
//sys   Shutdown(s int, how int) (err error)
 
146
 
 
147
func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
 
148
        if sa.Port < 0 || sa.Port > 0xFFFF {
 
149
                return nil, 0, EINVAL
 
150
        }
 
151
        sa.raw.Len = SizeofSockaddrInet4
 
152
        sa.raw.Family = AF_INET
 
153
        p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
 
154
        p[0] = byte(sa.Port >> 8)
 
155
        p[1] = byte(sa.Port)
 
156
        for i := 0; i < len(sa.Addr); i++ {
 
157
                sa.raw.Addr[i] = sa.Addr[i]
 
158
        }
 
159
        return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
 
160
}
 
161
 
 
162
func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
 
163
        if sa.Port < 0 || sa.Port > 0xFFFF {
 
164
                return nil, 0, EINVAL
 
165
        }
 
166
        sa.raw.Len = SizeofSockaddrInet6
 
167
        sa.raw.Family = AF_INET6
 
168
        p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
 
169
        p[0] = byte(sa.Port >> 8)
 
170
        p[1] = byte(sa.Port)
 
171
        sa.raw.Scope_id = sa.ZoneId
 
172
        for i := 0; i < len(sa.Addr); i++ {
 
173
                sa.raw.Addr[i] = sa.Addr[i]
 
174
        }
 
175
        return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
 
176
}
 
177
 
 
178
func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
 
179
        name := sa.Name
 
180
        n := len(name)
 
181
        if n >= len(sa.raw.Path) || n == 0 {
 
182
                return nil, 0, EINVAL
 
183
        }
 
184
        sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL
 
185
        sa.raw.Family = AF_UNIX
 
186
        for i := 0; i < n; i++ {
 
187
                sa.raw.Path[i] = int8(name[i])
 
188
        }
 
189
        return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
 
190
}
 
191
 
 
192
func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) {
 
193
        if sa.Index == 0 {
 
194
                return nil, 0, EINVAL
 
195
        }
 
196
        sa.raw.Len = sa.Len
 
197
        sa.raw.Family = AF_LINK
 
198
        sa.raw.Index = sa.Index
 
199
        sa.raw.Type = sa.Type
 
200
        sa.raw.Nlen = sa.Nlen
 
201
        sa.raw.Alen = sa.Alen
 
202
        sa.raw.Slen = sa.Slen
 
203
        for i := 0; i < len(sa.raw.Data); i++ {
 
204
                sa.raw.Data[i] = sa.Data[i]
 
205
        }
 
206
        return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil
 
207
}
 
208
 
 
209
func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) {
 
210
        switch rsa.Addr.Family {
 
211
        case AF_LINK:
 
212
                pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa))
 
213
                sa := new(SockaddrDatalink)
 
214
                sa.Len = pp.Len
 
215
                sa.Family = pp.Family
 
216
                sa.Index = pp.Index
 
217
                sa.Type = pp.Type
 
218
                sa.Nlen = pp.Nlen
 
219
                sa.Alen = pp.Alen
 
220
                sa.Slen = pp.Slen
 
221
                for i := 0; i < len(sa.Data); i++ {
 
222
                        sa.Data[i] = pp.Data[i]
 
223
                }
 
224
                return sa, nil
 
225
 
 
226
        case AF_UNIX:
 
227
                pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
 
228
                if pp.Len < 2 || pp.Len > SizeofSockaddrUnix {
 
229
                        return nil, EINVAL
 
230
                }
 
231
                sa := new(SockaddrUnix)
 
232
 
 
233
                // Some BSDs include the trailing NUL in the length, whereas
 
234
                // others do not. Work around this by subtracting the leading
 
235
                // family and len. The path is then scanned to see if a NUL
 
236
                // terminator still exists within the length.
 
237
                n := int(pp.Len) - 2 // subtract leading Family, Len
 
238
                for i := 0; i < n; i++ {
 
239
                        if pp.Path[i] == 0 {
 
240
                                // found early NUL; assume Len included the NUL
 
241
                                // or was overestimating.
 
242
                                n = i
 
243
                                break
 
244
                        }
 
245
                }
 
246
                bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
 
247
                sa.Name = string(bytes)
 
248
                return sa, nil
 
249
 
 
250
        case AF_INET:
 
251
                pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
 
252
                sa := new(SockaddrInet4)
 
253
                p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 
254
                sa.Port = int(p[0])<<8 + int(p[1])
 
255
                for i := 0; i < len(sa.Addr); i++ {
 
256
                        sa.Addr[i] = pp.Addr[i]
 
257
                }
 
258
                return sa, nil
 
259
 
 
260
        case AF_INET6:
 
261
                pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
 
262
                sa := new(SockaddrInet6)
 
263
                p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 
264
                sa.Port = int(p[0])<<8 + int(p[1])
 
265
                sa.ZoneId = pp.Scope_id
 
266
                for i := 0; i < len(sa.Addr); i++ {
 
267
                        sa.Addr[i] = pp.Addr[i]
 
268
                }
 
269
                return sa, nil
 
270
        }
 
271
        return nil, EAFNOSUPPORT
 
272
}
 
273
 
 
274
func Accept(fd int) (nfd int, sa Sockaddr, err error) {
 
275
        var rsa RawSockaddrAny
 
276
        var len _Socklen = SizeofSockaddrAny
 
277
        nfd, err = accept(fd, &rsa, &len)
 
278
        if err != nil {
 
279
                return
 
280
        }
 
281
        if runtime.GOOS == "darwin" && len == 0 {
 
282
                // Accepted socket has no address.
 
283
                // This is likely due to a bug in xnu kernels,
 
284
                // where instead of ECONNABORTED error socket
 
285
                // is accepted, but has no address.
 
286
                Close(nfd)
 
287
                return 0, nil, ECONNABORTED
 
288
        }
 
289
        sa, err = anyToSockaddr(&rsa)
 
290
        if err != nil {
 
291
                Close(nfd)
 
292
                nfd = 0
 
293
        }
 
294
        return
 
295
}
 
296
 
 
297
func Getsockname(fd int) (sa Sockaddr, err error) {
 
298
        var rsa RawSockaddrAny
 
299
        var len _Socklen = SizeofSockaddrAny
 
300
        if err = getsockname(fd, &rsa, &len); err != nil {
 
301
                return
 
302
        }
 
303
        // TODO(jsing): DragonFly has a "bug" (see issue 3349), which should be
 
304
        // reported upstream.
 
305
        if runtime.GOOS == "dragonfly" && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 {
 
306
                rsa.Addr.Family = AF_UNIX
 
307
                rsa.Addr.Len = SizeofSockaddrUnix
 
308
        }
 
309
        return anyToSockaddr(&rsa)
 
310
}
 
311
 
 
312
//sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
 
313
 
 
314
func GetsockoptByte(fd, level, opt int) (value byte, err error) {
 
315
        var n byte
 
316
        vallen := _Socklen(1)
 
317
        err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
 
318
        return n, err
 
319
}
 
320
 
 
321
func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) {
 
322
        vallen := _Socklen(4)
 
323
        err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
 
324
        return value, err
 
325
}
 
326
 
 
327
func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) {
 
328
        var value IPMreq
 
329
        vallen := _Socklen(SizeofIPMreq)
 
330
        err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
 
331
        return &value, err
 
332
}
 
333
 
 
334
func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) {
 
335
        var value IPv6Mreq
 
336
        vallen := _Socklen(SizeofIPv6Mreq)
 
337
        err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
 
338
        return &value, err
 
339
}
 
340
 
 
341
func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) {
 
342
        var value IPv6MTUInfo
 
343
        vallen := _Socklen(SizeofIPv6MTUInfo)
 
344
        err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
 
345
        return &value, err
 
346
}
 
347
 
 
348
func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) {
 
349
        var value ICMPv6Filter
 
350
        vallen := _Socklen(SizeofICMPv6Filter)
 
351
        err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
 
352
        return &value, err
 
353
}
 
354
 
 
355
//sys   recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
 
356
//sys   sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
 
357
//sys   recvmsg(s int, msg *Msghdr, flags int) (n int, err error)
 
358
 
 
359
func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
 
360
        var msg Msghdr
 
361
        var rsa RawSockaddrAny
 
362
        msg.Name = (*byte)(unsafe.Pointer(&rsa))
 
363
        msg.Namelen = uint32(SizeofSockaddrAny)
 
364
        var iov Iovec
 
365
        if len(p) > 0 {
 
366
                iov.Base = (*byte)(unsafe.Pointer(&p[0]))
 
367
                iov.SetLen(len(p))
 
368
        }
 
369
        var dummy byte
 
370
        if len(oob) > 0 {
 
371
                // receive at least one normal byte
 
372
                if len(p) == 0 {
 
373
                        iov.Base = &dummy
 
374
                        iov.SetLen(1)
 
375
                }
 
376
                msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
 
377
                msg.SetControllen(len(oob))
 
378
        }
 
379
        msg.Iov = &iov
 
380
        msg.Iovlen = 1
 
381
        if n, err = recvmsg(fd, &msg, flags); err != nil {
 
382
                return
 
383
        }
 
384
        oobn = int(msg.Controllen)
 
385
        recvflags = int(msg.Flags)
 
386
        // source address is only specified if the socket is unconnected
 
387
        if rsa.Addr.Family != AF_UNSPEC {
 
388
                from, err = anyToSockaddr(&rsa)
 
389
        }
 
390
        return
 
391
}
 
392
 
 
393
//sys   sendmsg(s int, msg *Msghdr, flags int) (n int, err error)
 
394
 
 
395
func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
 
396
        _, err = SendmsgN(fd, p, oob, to, flags)
 
397
        return
 
398
}
 
399
 
 
400
func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
 
401
        var ptr unsafe.Pointer
 
402
        var salen _Socklen
 
403
        if to != nil {
 
404
                ptr, salen, err = to.sockaddr()
 
405
                if err != nil {
 
406
                        return 0, err
 
407
                }
 
408
        }
 
409
        var msg Msghdr
 
410
        msg.Name = (*byte)(unsafe.Pointer(ptr))
 
411
        msg.Namelen = uint32(salen)
 
412
        var iov Iovec
 
413
        if len(p) > 0 {
 
414
                iov.Base = (*byte)(unsafe.Pointer(&p[0]))
 
415
                iov.SetLen(len(p))
 
416
        }
 
417
        var dummy byte
 
418
        if len(oob) > 0 {
 
419
                // send at least one normal byte
 
420
                if len(p) == 0 {
 
421
                        iov.Base = &dummy
 
422
                        iov.SetLen(1)
 
423
                }
 
424
                msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
 
425
                msg.SetControllen(len(oob))
 
426
        }
 
427
        msg.Iov = &iov
 
428
        msg.Iovlen = 1
 
429
        if n, err = sendmsg(fd, &msg, flags); err != nil {
 
430
                return 0, err
 
431
        }
 
432
        if len(oob) > 0 && len(p) == 0 {
 
433
                n = 0
 
434
        }
 
435
        return n, nil
 
436
}
 
437
 
 
438
//sys   kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error)
 
439
 
 
440
func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) {
 
441
        var change, event unsafe.Pointer
 
442
        if len(changes) > 0 {
 
443
                change = unsafe.Pointer(&changes[0])
 
444
        }
 
445
        if len(events) > 0 {
 
446
                event = unsafe.Pointer(&events[0])
 
447
        }
 
448
        return kevent(kq, change, len(changes), event, len(events), timeout)
 
449
}
 
450
 
 
451
//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
452
 
 
453
func Sysctl(name string) (value string, err error) {
 
454
        // Translate name to mib number.
 
455
        mib, err := nametomib(name)
 
456
        if err != nil {
 
457
                return "", err
 
458
        }
 
459
 
 
460
        // Find size.
 
461
        n := uintptr(0)
 
462
        if err = sysctl(mib, nil, &n, nil, 0); err != nil {
 
463
                return "", err
 
464
        }
 
465
        if n == 0 {
 
466
                return "", nil
 
467
        }
 
468
 
 
469
        // Read into buffer of that size.
 
470
        buf := make([]byte, n)
 
471
        if err = sysctl(mib, &buf[0], &n, nil, 0); err != nil {
 
472
                return "", err
 
473
        }
 
474
 
 
475
        // Throw away terminating NUL.
 
476
        if n > 0 && buf[n-1] == '\x00' {
 
477
                n--
 
478
        }
 
479
        return string(buf[0:n]), nil
 
480
}
 
481
 
 
482
func SysctlUint32(name string) (value uint32, err error) {
 
483
        // Translate name to mib number.
 
484
        mib, err := nametomib(name)
 
485
        if err != nil {
 
486
                return 0, err
 
487
        }
 
488
 
 
489
        // Read into buffer of that size.
 
490
        n := uintptr(4)
 
491
        buf := make([]byte, 4)
 
492
        if err = sysctl(mib, &buf[0], &n, nil, 0); err != nil {
 
493
                return 0, err
 
494
        }
 
495
        if n != 4 {
 
496
                return 0, EIO
 
497
        }
 
498
        return *(*uint32)(unsafe.Pointer(&buf[0])), nil
 
499
}
 
500
 
 
501
//sys   utimes(path string, timeval *[2]Timeval) (err error)
 
502
 
 
503
func Utimes(path string, tv []Timeval) (err error) {
 
504
        if len(tv) != 2 {
 
505
                return EINVAL
 
506
        }
 
507
        return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 
508
}
 
509
 
 
510
func UtimesNano(path string, ts []Timespec) error {
 
511
        // TODO: The BSDs can do utimensat with SYS_UTIMENSAT but it
 
512
        // isn't supported by darwin so this uses utimes instead
 
513
        if len(ts) != 2 {
 
514
                return EINVAL
 
515
        }
 
516
        // Not as efficient as it could be because Timespec and
 
517
        // Timeval have different types in the different OSes
 
518
        tv := [2]Timeval{
 
519
                NsecToTimeval(TimespecToNsec(ts[0])),
 
520
                NsecToTimeval(TimespecToNsec(ts[1])),
 
521
        }
 
522
        return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 
523
}
 
524
 
 
525
//sys   futimes(fd int, timeval *[2]Timeval) (err error)
 
526
 
 
527
func Futimes(fd int, tv []Timeval) (err error) {
 
528
        if len(tv) != 2 {
 
529
                return EINVAL
 
530
        }
 
531
        return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 
532
}
 
533
 
 
534
//sys   fcntl(fd int, cmd int, arg int) (val int, err error)
 
535
 
 
536
// TODO: wrap
 
537
//      Acct(name nil-string) (err error)
 
538
//      Gethostuuid(uuid *byte, timeout *Timespec) (err error)
 
539
//      Madvise(addr *byte, len int, behav int) (err error)
 
540
//      Mprotect(addr *byte, len int, prot int) (err error)
 
541
//      Msync(addr *byte, len int, flags int) (err error)
 
542
//      Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error)
 
543
 
 
544
var mapper = &mmapper{
 
545
        active: make(map[*byte][]byte),
 
546
        mmap:   mmap,
 
547
        munmap: munmap,
 
548
}
 
549
 
 
550
func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
 
551
        return mapper.Mmap(fd, offset, length, prot, flags)
 
552
}
 
553
 
 
554
func Munmap(b []byte) (err error) {
 
555
        return mapper.Munmap(b)
 
556
}