jb@syno:~/src/golang.org/x/sys (master) $ git grep 'func Mmap'
unix/syscall_bsd.go:func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
unix/syscall_linux.go:func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
jb@syno:~/src/golang.org/x/sys (master) $ 

jb@zlogin4:~ $ uname -a
SunOS zlogin4.nym.se 5.11 joyent_20150709T171818Z i86pc i386 i86pc Solaris
jb@zlogin4:~ $ cat test.c 
#include <sys/file.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    FILE *fp;
    fp = fopen("test.c", "r");
    if (fp == NULL) {
        perror("fopen");
        exit(1);
    }
    if (flock(fileno(fp), LOCK_EX) != 0) {
        perror("flock");
        exit(1);
    }
    printf("test.c locked\n");
    return 0;
}

jb@zlogin4:~ $ gcc -o test test.c
jb@zlogin4:~ $ ./test 
test.c locked
jb@zlogin4:~ $ 

// flock acquires an advisory lock on a file descriptor.
func flock(f *os.File, exclusive bool, timeout time.Duration) error {
    var t time.Time
    for {
        // If we're beyond our timeout then return an error.
        // This can only occur after we've attempted a flock once.
        if t.IsZero() {
            t = time.Now()
        } else if timeout > 0 && time.Since(t) > timeout {
            return ErrTimeout
        }
        var lock syscall.Flock_t
        lock.Start = 0
        lock.Len = 0
        lock.Pid = 0
        lock.Whence = 0
        lock.Pid = 0
        if exclusive {
            lock.Type = syscall.F_WRLCK
        } else {
            lock.Type = syscall.F_RDLCK
        }
        err := syscall.FcntlFlock(f.Fd(), syscall.F_SETLK, &lock)
        if err == nil {
            return nil
        } else if err != syscall.EAGAIN {
            return err
        }

        // Wait for a bit and try again.
        time.Sleep(50 * time.Millisecond)
    }
}

// funlock releases an advisory lock on a file descriptor.
func funlock(f *os.File) error {
    var lock syscall.Flock_t
    lock.Start = 0
    lock.Len = 0
    lock.Type = syscall.F_UNLCK
    lock.Whence = 0
    return syscall.FcntlFlock(uintptr(f.Fd()), syscall.F_SETLK, &lock)
}

--- a/src/syscall/syscall_solaris.go
+++ b/src/syscall/syscall_solaris.go
@@ -526,3 +526,17 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
        }
        return
 }
+
+var mapper = &mmapper{
+       active: make(map[*byte][]byte),
+       mmap:   mmap,
+       munmap: munmap,
+}
+
+func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error
+       return mapper.Mmap(fd, offset, length, prot, flags)
+}
+
+func Munmap(b []byte) (err error) {
+       return mapper.Munmap(b)
+}

 http://build.golang.org/?repo=golang.org%2fx%2fsys

diff --git a/unix/mksyscall_solaris.pl b/unix/mksyscall_solaris.pl
index e81edb9..9ec19e0 100755
--- a/unix/mksyscall_solaris.pl
+++ b/unix/mksyscall_solaris.pl
@@ -269,7 +269,10 @@ print <<EOF;

 package $package

-import "unsafe"
+import (
+       "syscall"
+       "unsafe"
+)
 EOF

 print "import \"golang.org/x/sys/unix\"\n" if $package ne "unix";
diff --git a/unix/syscall_solaris.go b/unix/syscall_solaris.go
index ea5ac78..d5886ee 100644
--- a/unix/syscall_solaris.go
+++ b/unix/syscall_solaris.go
@@ -527,3 +527,17 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
        }
        return
 }
+
+var mapper = &mmapper{
+       active: make(map[*byte][]byte),
+       mmap:   mmap,
+       munmap: munmap,
+}
+
+func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
+       return mapper.Mmap(fd, offset, length, prot, flags)
+}
+
+func Munmap(b []byte) (err error) {
+       return mapper.Munmap(b)
+}
diff --git a/unix/zsyscall_solaris_amd64.go b/unix/zsyscall_solaris_amd64.go
index 4c2f8bf..a05befa 100644
--- a/unix/zsyscall_solaris_amd64.go
+++ b/unix/zsyscall_solaris_amd64.go
@@ -5,92 +5,96 @@

 package unix

-import "unsafe"
+import (
+       "syscall"
+       "unsafe"
+)

 var (
-       modlibc      = syscall.newLazySO("libc.so")
-       modlibsocket = syscall.newLazySO("libsocket.so")
-
-       procgetgroups    = modlibc.NewProc("getgroups")
-       procsetgroups    = modlibc.NewProc("setgroups")
-       procfcntl        = modlibc.NewProc("fcntl")
-       procaccept       = modlibsocket.NewProc("accept")
-       procsendmsg      = modlibsocket.NewProc("sendmsg")
-       procAccess       = modlibc.NewProc("access")
-       procAdjtime      = modlibc.NewProc("adjtime")
-       procChdir        = modlibc.NewProc("chdir")
-       procChmod        = modlibc.NewProc("chmod")
-       procChown        = modlibc.NewProc("chown")
-       procChroot       = modlibc.NewProc("chroot")
-       procClose        = modlibc.NewProc("close")
-       procDup          = modlibc.NewProc("dup")
-       procExit         = modlibc.NewProc("exit")
-       procFchdir       = modlibc.NewProc("fchdir")
-       procFchmod       = modlibc.NewProc("fchmod")
-       procFchown       = modlibc.NewProc("fchown")
-       procFpathconf    = modlibc.NewProc("fpathconf")
-       procFstat        = modlibc.NewProc("fstat")
-       procGetdents     = modlibc.NewProc("getdents")
-       procGetgid       = modlibc.NewProc("getgid")
-       procGetpid       = modlibc.NewProc("getpid")
-       procGeteuid      = modlibc.NewProc("geteuid")
-       procGetegid      = modlibc.NewProc("getegid")
-       procGetppid      = modlibc.NewProc("getppid")
-       procGetpriority  = modlibc.NewProc("getpriority")
-       procGetrlimit    = modlibc.NewProc("getrlimit")
+       modlibc = newLazySO("libc.so")
+       modlibsocket = newLazySO("libsocket.so")
+
+       procgetgroups = modlibc.NewProc("getgroups")
+       procsetgroups = modlibc.NewProc("setgroups")
+       procfcntl = modlibc.NewProc("fcntl")
+       procaccept = modlibsocket.NewProc("accept")
+       procsendmsg = modlibsocket.NewProc("sendmsg")
+       procAccess = modlibc.NewProc("access")
+       procAdjtime = modlibc.NewProc("adjtime")
+       procChdir = modlibc.NewProc("chdir")
+       procChmod = modlibc.NewProc("chmod")
+       procChown = modlibc.NewProc("chown")
+       procChroot = modlibc.NewProc("chroot")
+       procClose = modlibc.NewProc("close")
+       procDup = modlibc.NewProc("dup")
+       procExit = modlibc.NewProc("exit")
+       procFchdir = modlibc.NewProc("fchdir")
+       procFchmod = modlibc.NewProc("fchmod")
+       procFchown = modlibc.NewProc("fchown")
+       procFpathconf = modlibc.NewProc("fpathconf")
+       procFstat = modlibc.NewProc("fstat")
+       procGetdents = modlibc.NewProc("getdents")
+       procGetgid = modlibc.NewProc("getgid")
+       procGetpid = modlibc.NewProc("getpid")
+       procGeteuid = modlibc.NewProc("geteuid")
+       procGetegid = modlibc.NewProc("getegid")
+       procGetppid = modlibc.NewProc("getppid")
+       procGetpriority = modlibc.NewProc("getpriority")
+       procGetrlimit = modlibc.NewProc("getrlimit")
        procGettimeofday = modlibc.NewProc("gettimeofday")
-       procGetuid       = modlibc.NewProc("getuid")
-       procKill         = modlibc.NewProc("kill")
-       procLchown       = modlibc.NewProc("lchown")
-       procLink         = modlibc.NewProc("link")
-       proclisten       = modlibsocket.NewProc("listen")
-       procLstat        = modlibc.NewProc("lstat")
-       procMkdir        = modlibc.NewProc("mkdir")
-       procMknod        = modlibc.NewProc("mknod")
-       procNanosleep    = modlibc.NewProc("nanosleep")
-       procOpen         = modlibc.NewProc("open")
-       procPathconf     = modlibc.NewProc("pathconf")
-       procPread        = modlibc.NewProc("pread")
-       procPwrite       = modlibc.NewProc("pwrite")
-       procread         = modlibc.NewProc("read")
-       procReadlink     = modlibc.NewProc("readlink")
-       procRename       = modlibc.NewProc("rename")
-       procRmdir        = modlibc.NewProc("rmdir")
-       proclseek        = modlibc.NewProc("lseek")
-       procSetegid      = modlibc.NewProc("setegid")
-       procSeteuid      = modlibc.NewProc("seteuid")
-       procSetgid       = modlibc.NewProc("setgid")
-       procSetpgid      = modlibc.NewProc("setpgid")
-       procSetpriority  = modlibc.NewProc("setpriority")
-       procSetregid     = modlibc.NewProc("setregid")
-       procSetreuid     = modlibc.NewProc("setreuid")
-       procSetrlimit    = modlibc.NewProc("setrlimit")
-       procSetsid       = modlibc.NewProc("setsid")
-       procSetuid       = modlibc.NewProc("setuid")
-       procshutdown     = modlibsocket.NewProc("shutdown")
-       procStat         = modlibc.NewProc("stat")
-       procSymlink      = modlibc.NewProc("symlink")
-       procSync         = modlibc.NewProc("sync")
-       procTruncate     = modlibc.NewProc("truncate")
-       procFsync        = modlibc.NewProc("fsync")
-       procFtruncate    = modlibc.NewProc("ftruncate")
-       procUmask        = modlibc.NewProc("umask")
-       procUnlink       = modlibc.NewProc("unlink")
-       procUtimes       = modlibc.NewProc("utimes")
-       procbind         = modlibsocket.NewProc("bind")
-       procconnect      = modlibsocket.NewProc("connect")
-       procmmap         = modlibc.NewProc("mmap")
-       procmunmap       = modlibc.NewProc("munmap")
-       procsendto       = modlibsocket.NewProc("sendto")
-       procsocket       = modlibsocket.NewProc("socket")
-       procsocketpair   = modlibsocket.NewProc("socketpair")
-       procwrite        = modlibc.NewProc("write")
-       procgetsockopt   = modlibsocket.NewProc("getsockopt")
-       procgetpeername  = modlibsocket.NewProc("getpeername")
-       procgetsockname  = modlibsocket.NewProc("getsockname")
-       procsetsockopt   = modlibsocket.NewProc("setsockopt")
-       procrecvfrom     = modlibsocket.NewProc("recvfrom")
-       procrecvmsg      = modlibsocket.NewProc("recvmsg")
+       procGetuid = modlibc.NewProc("getuid")
+       procKill = modlibc.NewProc("kill")
+       procLchown = modlibc.NewProc("lchown")
+       procLink = modlibc.NewProc("link")
+       proclisten = modlibsocket.NewProc("listen")
+       procLstat = modlibc.NewProc("lstat")
+       procMkdir = modlibc.NewProc("mkdir")
+       procMknod = modlibc.NewProc("mknod")
+       procNanosleep = modlibc.NewProc("nanosleep")
+       procOpen = modlibc.NewProc("open")
+       procPathconf = modlibc.NewProc("pathconf")
+       procPread = modlibc.NewProc("pread")
+       procPwrite = modlibc.NewProc("pwrite")
+       procread = modlibc.NewProc("read")
+       procReadlink = modlibc.NewProc("readlink")
+       procRename = modlibc.NewProc("rename")
+       procRmdir = modlibc.NewProc("rmdir")
+       proclseek = modlibc.NewProc("lseek")
+       procSetegid = modlibc.NewProc("setegid")
+       procSeteuid = modlibc.NewProc("seteuid")
+       procSetgid = modlibc.NewProc("setgid")
+       procSetpgid = modlibc.NewProc("setpgid")
+       procSetpriority = modlibc.NewProc("setpriority")
+       procSetregid = modlibc.NewProc("setregid")
+       procSetreuid = modlibc.NewProc("setreuid")
+       procSetrlimit = modlibc.NewProc("setrlimit")
+       procSetsid = modlibc.NewProc("setsid")
+       procSetuid = modlibc.NewProc("setuid")
+       procshutdown = modlibsocket.NewProc("shutdown")
+       procStat = modlibc.NewProc("stat")
+       procSymlink = modlibc.NewProc("symlink")
+       procSync = modlibc.NewProc("sync")
+       procTruncate = modlibc.NewProc("truncate")
+       procFsync = modlibc.NewProc("fsync")
+       procFtruncate = modlibc.NewProc("ftruncate")
+       procUmask = modlibc.NewProc("umask")
+       procUnlink = modlibc.NewProc("unlink")
+       procUtimes = modlibc.NewProc("utimes")
+       procbind = modlibsocket.NewProc("bind")
+       procconnect = modlibsocket.NewProc("connect")
+       procmmap = modlibc.NewProc("mmap")
+       procmunmap = modlibc.NewProc("munmap")
+       procsendto = modlibsocket.NewProc("sendto")
+       procsocket = modlibsocket.NewProc("socket")
+       procsocketpair = modlibsocket.NewProc("socketpair")
+       procwrite = modlibc.NewProc("write")
+       procgetsockopt = modlibsocket.NewProc("getsockopt")
+       procgetpeername = modlibsocket.NewProc("getpeername")
+       procgetsockname = modlibsocket.NewProc("getsockname")
+       procsetsockopt = modlibsocket.NewProc("setsockopt")
+       procrecvfrom = modlibsocket.NewProc("recvfrom")
+       procrecvmsg = modlibsocket.NewProc("recvmsg")
+
 )

 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
@@ -906,3 +910,5 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
        }
        return
 }
+
+

--- a/src/syscall/zsysnum_solaris_amd64.go
+++ b/src/syscall/zsysnum_solaris_amd64.go
@@ -8,6 +8,7 @@ package syscall

 // TODO(aram): remove these before Go 1.3.
 const (
+        SYS_IOCTL          = 54  // { int sys_ioctl(int fd, \
        SYS_EXECVE = 59
        SYS_FCNTL  = 62
 )

long
lx_flock(uintptr_t p1, uintptr_t p2)
{
        int                     fd = (int)p1;
        int                     operation = (int)p2;
        struct flock            fl;
        int                     cmd;
        int                     ret;

        if (operation & LX_LOCK_NB) {
                cmd = F_FLOCK;
                operation &= ~LX_LOCK_NB; /* turn off this bit */
        } else {
                cmd = F_FLOCKW;
        }

        switch (operation) {
                case LX_LOCK_UN:
                        fl.l_type = F_UNLCK;
                        break;
                case LX_LOCK_SH:
                        fl.l_type = F_RDLCK;
                        break;
                case LX_LOCK_EX:
                        fl.l_type = F_WRLCK;
                        break;
                default:
                        return (-EINVAL);
        }

        fl.l_whence = 0;
        fl.l_start = 0;
        fl.l_len = 0;
        fl.l_sysid = 0;
        fl.l_pid = 0;

        ret = fcntl(fd, cmd, &fl);

        return ((ret == -1) ? -errno : ret);
}

       Two types of file locks are supported: POSIX-style and OFD-style. OFD-
       style locks are associated with the open file description (not
       descriptor) instead of with a process. Either type is advisory by
       default, but POSIX-style locks can be mandatory if, and only if,
       mandatory locking has been enabled on the file being locked.  Each type
       of lock may be created through two different interfaces. POSIX-style
       locks are created via the F_SETLK, F_SETLK64, F_SETLKW, or F_SETLKW64
       commands to this system call or by use of the lockf(3C) routine. There
       is no difference between locks created via one mechanism or the other.
       Likewise, OFD-style locks are created via the F_OFD_SETLK,
       F_OFD_SETLK64, F_OFD_SETLKW, or F_OFD_SETLKW64 commands to this system
       call or by use of the Linux/BSD-compatible flock(3C) routine. Note that
       this system call supports the creation of range-specified OFD-style
       file locks, while flock(3C) does not. However, the current
       implementation of OFD-style locking is limited to locking the entire
       file. This limitation might be removed in the future.


       The essential distinction between POSIX-style locks and OFD-style locks
       lie in how ownership of a lock is scoped. POSIX locks are scoped to a
       process. All POSIX locks associated with a file for a given process are
       removed when any file descriptor for that file is closed by that
       process or the process holding that file descriptor terminates. POSIX-
       style locks are not inherited by a child process created using fork(2).
       An OFD-style lock is scoped to the file description for a file, not the
       process or open file descriptor. Thus all file descriptors referring to
       the same description (i.e. those created via the F_DUPFD, F_DUP2FD,
       F_DUPFD_CLOEXEC, or F_DUP2FD_CLOEXEC commands to the fcntl(2) system
       call, or those created via the dup(2) system call, or those inherited
       by a child process created via fork(2)) reference the same lock, but a
       file descriptor obtained via a separate open(2) call on the same file
       will reference a different lock.  A lock is removed only on the last
       close(2) of the description, or when the lock is explicitly unlocked.


       Locks of both styles are compatible. A file that has been locked with
       one style of lock will be regarded as locked when creation of a lock of
       either style is attempted, and information about the lock will be
       provided via any of the F_GETLK, F_GETLK64, F_OFD_GETLK, or
       F_OFD_GETLK64 commands to this system call if that lock would conflict
       with an attempt to create the specified lock regardless of whether the
       specified lock is of the same style as the conflicting extant lock.
       Because ownership of OFD-style locks is scoped to the open description
       rather than the calling process, the l_pid field of a lock descriptor
       for any such lock will always be set to -1.


       When a shared lock is set on a segment of a file, other callers
       (regardless of whether in the same or different process and of whether
       referenced via the same open file) will be able to set shared locks on
       that segment or a portion of it. A POSIX-style shared lock prevents any
       other process from setting an exclusive lock on any portion of the
       protected area. A OFD-style shared lock prevents any caller (even
       callers in the same process) from setting an exclusive lock on any
       portion of the protected area, unless the caller makes the request
       against a file descriptor referencing the same open file against which
       the shared lock was created, in which case the lock will be downgraded
       to a shared lock with respect to the specified region. A request for a
       shared lock of either style will fail if the file descriptor was not
       opened with read access.