syscall, cmd/go/internal/lockedfile: remove Flock syscall for aix/ppc64

AIX doesn't provide flock() syscall, it was previously emulated by fcntl
calls. However, there are some differences between a flock() syscall and
a flock() using fcntl. Therefore, it's safer to remove it and just
provide FcntlFlock.

Thus, lockedfile implementation must be moved to use FcntlFlock on aix/ppc64.

Updates #29065.
Fixes #29084.

Change-Id: Ic48fd9f315f24c2acdf09b91d917da131a1f2dd5
Reviewed-on: https://go-review.googlesource.com/c/152397
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>

diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_solaris.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_fcntl.go
similarity index 97%
rename from src/cmd/go/internal/lockedfile/internal/filelock/filelock_solaris.go
rename to src/cmd/go/internal/lockedfile/internal/filelock/filelock_fcntl.go
index b03d5f893e9331d4b7509ff0b8077bb57dba3b9d..2831975c0c69ef386bf9fdcdc8bf608d536d2f8e 100644 (file)
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_solaris.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_fcntl.go
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build aix solaris
+
 // This code implements the filelock API using POSIX 'fcntl' locks, which attach
 // to an (inode, process) pair rather than a file descriptor. To avoid unlocking
 // files prematurely when the same file is opened through different descriptors,
@@ -13,8 +15,8 @@
 //
 // TODO(bcmills): If we add a build tag for Illumos (see golang.org/issue/20603)
 // then Illumos should use F_OFD_SETLK, and the resulting code would be as
-// simple as filelock_unix.go. We will still need the code in this file as long
-// as Oracle Solaris provides only F_SETLK.
+// simple as filelock_unix.go. We will still need the code in this file for AIX
+// or as long as Oracle Solaris provides only F_SETLK.
 
 package filelock
 

diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_other.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_other.go
index 7d60160f909ff6c7e2c5013d1a3908deacd102d1..107611e1ce85f63b56d103ee7fec7456c6891a11 100644 (file)
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_other.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_other.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!plan9,!solaris,!windows
+// +build !aix,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!plan9,!solaris,!windows
 
 package filelock
 

diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go
index 0ccee07ceebd5fe6214d78be322894f863d4d062..aa67093a48aad68cb7adff8dc99c718a3032d88f 100644 (file)
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go
@@ -159,7 +159,7 @@ func TestRLockExcludesOnlyLock(t *testing.T) {
        f2 := mustOpen(t, f.Name())
        defer f2.Close()
 
-       if runtime.GOOS == "solaris" {
+       if runtime.GOOS == "solaris" || runtime.GOOS == "aix" {
                // When using POSIX locks (as on Solaris), we can't safely read-lock the
                // same inode through two different descriptors at the same time: when the
                // first descriptor is closed, the second descriptor would still be open but
@@ -176,7 +176,7 @@ func TestRLockExcludesOnlyLock(t *testing.T) {
        lockOther := mustBlock(t, "Lock", other)
 
        unlock(t, f2)
-       if runtime.GOOS != "solaris" {
+       if runtime.GOOS != "solaris" && runtime.GOOS != "aix" {
                unlock(t, f)
        }
        lockOther(t)

diff --git a/src/syscall/flock_aix.go b/src/syscall/flock_aix.go
index 9745236dcb8a6d632f01140ddbb7522a33c29fe3..c9eab43b6bc2f168bfdc80de24d329a1f81d5a36 100644 (file)
--- a/src/syscall/flock_aix.go
+++ b/src/syscall/flock_aix.go
@@ -6,36 +6,13 @@ package syscall
 
 import "unsafe"
 
-// On AIX, there is no flock() system call, we emulate it.
-// Moreover, we can't call the default fcntl syscall because the arguments
-// must be integer and it's not possible to transform a pointer (lk)
-// to a int value.
-// It's easier to call syscall6 than to transform fcntl for every GOOS.
-func fcntlFlock(fd, cmd int, lk *Flock_t) (err error) {
+// On AIX, there is no flock() system call.
+
+// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
+func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) (err error) {
        _, _, e1 := syscall6(uintptr(unsafe.Pointer(&libc_fcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(lk)), 0, 0, 0)
        if e1 != 0 {
                err = errnoErr(e1)
        }
        return
 }
-
-func Flock(fd int, op int) (err error) {
-       lk := &Flock_t{}
-       if (op & LOCK_UN) != 0 {
-               lk.Type = F_UNLCK
-       } else if (op & LOCK_EX) != 0 {
-               lk.Type = F_WRLCK
-       } else if (op & LOCK_SH) != 0 {
-               lk.Type = F_RDLCK
-       } else {
-               return nil
-       }
-       if (op & LOCK_NB) != 0 {
-               err = fcntlFlock(fd, F_SETLK, lk)
-               if err != nil && (err == EAGAIN || err == EACCES) {
-                       return EWOULDBLOCK
-               }
-               return err
-       }
-       return fcntlFlock(fd, F_SETLKW, lk)
-}