x/sys/unix: Solaris lacks Flock (plus related constants)

[calmh]

Primarily needed by Bolt which currently builds on "everything" except Solaris.

# github.com/boltdb/bolt
./bolt_unix.go:24: undefined: syscall.LOCK_SH
./bolt_unix.go:26: undefined: syscall.LOCK_EX
./bolt_unix.go:30: undefined: syscall.Flock
./bolt_unix.go:30: undefined: syscall.LOCK_NB
./bolt_unix.go:44: undefined: syscall.Flock
./bolt_unix.go:44: undefined: syscall.LOCK_UN
./bolt_unix.go:61: undefined: syscall.Mmap
./bolt_unix.go:86: undefined: syscall.Munmap
./bolt_unix.go:95: undefined: syscall.SYS_MADVISE

[minux]

Have you tried golang.org/x/sys/unix? (The issue subject mentions x/sys, but your code still references the syscall pakage)

[calmh]

Yes, it seems not implemented there either, unless I'm missing it.

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) $ 

(similar for Flock; hits, but not in something that looks like it would build on Solaris)

[4ad]

We can fix this trivially in x/sys, but it still won't solve your problem, as bolt has to be changed as well to start using x/sys instead of syscall.

[calmh]

That's not a problem though. Bolt I can fix, but I'm not sure of the changes necessary in x/sys.

[binarycrusader]

The Solaris OS itself does not currently support flock(); could you use FcntlFlock() instead?

[calmh]

It compiles and doesn't return an error... Although I didn't perform any deeper testing of it.

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:~ $ 

Nevertheless that's the least important part of it, as you note there are other ways to do locking anyway.

[binarycrusader]

I was referring to Solaris, not OpenSolaris derivatives such as SmartOS.

Solaris had an flock method historically but it was not semantically compatible with Linux and was removed from later versions of Solaris.

Since the Solaris port of Go is targeted to both Solaris and OpenSolaris-based derivatives, flock is not supportable on Solaris for Go for now.

I also think the precise semantics of whatever version of flock available on SmartOS are would need to be verified to be the same as other OS' given what I know about the original sources.

[akolb-imd]

I have a working implementation for locking using fcntl() interface that is currently used by etcd. I made version for bolt as well.

[akolb1]

// 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)
}

[ksedgwic]

@akolb-imd Thanks! I'm working on boltdb for Solaris as well.

I think I have a patch to x/sys/unix which fixes the build and provides mmap ... is this of interest?

-- Ken

[akolb1]

@ksedgwic Yes, please. I am especially interested in your mmap fix. I hacked golfing to provide mmap, but fixing it in bolt is definitely better.

BTW, why bolt uses mmap? It is very OS-specific and in many cases isn't even faster. Would be better to avoid it altogether.