From 24bc95bfc45224a3314e0af64584b96fec4af43b Mon Sep 17 00:00:00 2001 From: Kevin Krakauer Date: Thu, 18 Mar 2021 15:38:13 -0700 Subject: Fix alignment issue with 64-bit atomics on 32 bit machines --- pkg/tcpip/BUILD | 2 ++ pkg/tcpip/aligned.go | 61 ++++++++++++++++++++++++++++++++++ pkg/tcpip/aligned_unsafe.go | 80 +++++++++++++++++++++++++++++++++++++++++++++ pkg/tcpip/socketops.go | 8 ++--- pkg/tcpip/tcpip.go | 7 ++-- 5 files changed, 150 insertions(+), 8 deletions(-) create mode 100644 pkg/tcpip/aligned.go create mode 100644 pkg/tcpip/aligned_unsafe.go diff --git a/pkg/tcpip/BUILD b/pkg/tcpip/BUILD index f979d22f0..f71a805bf 100644 --- a/pkg/tcpip/BUILD +++ b/pkg/tcpip/BUILD @@ -18,6 +18,8 @@ go_template_instance( go_library( name = "tcpip", srcs = [ + "aligned.go", + "aligned_unsafe.go", "errors.go", "sock_err_list.go", "socketops.go", diff --git a/pkg/tcpip/aligned.go b/pkg/tcpip/aligned.go new file mode 100644 index 000000000..ea22c101f --- /dev/null +++ b/pkg/tcpip/aligned.go @@ -0,0 +1,61 @@ +// Copyright 2021 The gVisor Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build !arm,!386 + +package tcpip + +import "sync/atomic" + +// AlignedAtomicInt64 is an atomic int64 that is guaranteed to be 64-bit +// aligned, even on 32-bit systems. On 64-bit machines, it's just a regular +// int64. +// +// See aligned_unsafe.go in this directory for justification. +type AlignedAtomicInt64 struct { + value int64 +} + +func (aa *AlignedAtomicInt64) Load() int64 { + return atomic.LoadInt64(&aa.value) +} + +func (aa *AlignedAtomicInt64) Store(v int64) { + atomic.StoreInt64(&aa.value, v) +} + +func (aa *AlignedAtomicInt64) Add(v int64) int64 { + return atomic.AddInt64(&aa.value, v) +} + +// AlignedAtomicUint64 is an atomic uint64 that is guaranteed to be 64-bit +// aligned, even on 32-bit systems. On 64-bit machines, it's just a regular +// uint64. +// +// See aligned_unsafe.go in this directory for justification. +type AlignedAtomicUint64 struct { + value uint64 +} + +func (aa *AlignedAtomicUint64) Load() uint64 { + return atomic.LoadUint64(&aa.value) +} + +func (aa *AlignedAtomicUint64) Store(v uint64) { + atomic.StoreUint64(&aa.value, v) +} + +func (aa *AlignedAtomicUint64) Add(v uint64) uint64 { + return atomic.AddUint64(&aa.value, v) +} diff --git a/pkg/tcpip/aligned_unsafe.go b/pkg/tcpip/aligned_unsafe.go new file mode 100644 index 000000000..35e869453 --- /dev/null +++ b/pkg/tcpip/aligned_unsafe.go @@ -0,0 +1,80 @@ +// Copyright 2021 The gVisor Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build arm 386 + +package tcpip + +import ( + "sync/atomic" + "unsafe" +) + +// AlignedAtomicInt64 is an atomic int64 that is guaranteed to be 64-bit +// aligned, even on 32-bit systems. +// +// Per https://golang.org/pkg/sync/atomic/#pkg-note-BUG: +// +// "On ARM, 386, and 32-bit MIPS, it is the caller's responsibility to arrange +// for 64-bit alignment of 64-bit words accessed atomically. The first word in +// a variable or in an allocated struct, array, or slice can be relied upon to +// be 64-bit aligned." +type AlignedAtomicInt64 struct { + value [15]byte +} + +func (aa *AlignedAtomicInt64) ptr() *int64 { + return (*int64)(unsafe.Pointer((uintptr(unsafe.Pointer(&aa.value)) + 7) &^ 7)) +} + +func (aa *AlignedAtomicInt64) Load() int64 { + return atomic.LoadInt64(aa.ptr()) +} + +func (aa *AlignedAtomicInt64) Store(v int64) { + atomic.StoreInt64(aa.ptr(), v) +} + +func (aa *AlignedAtomicInt64) Add(v int64) int64 { + return atomic.AddInt64(aa.ptr(), v) +} + +// AlignedAtomicUint64 is an atomic uint64 that is guaranteed to be 64-bit +// aligned, even on 32-bit systems. +// +// Per https://golang.org/pkg/sync/atomic/#pkg-note-BUG: +// +// "On ARM, 386, and 32-bit MIPS, it is the caller's responsibility to arrange +// for 64-bit alignment of 64-bit words accessed atomically. The first word in +// a variable or in an allocated struct, array, or slice can be relied upon to +// be 64-bit aligned." +type AlignedAtomicUint64 struct { + value [15]byte +} + +func (aa *AlignedAtomicUint64) ptr() *uint64 { + return (*uint64)(unsafe.Pointer((uintptr(unsafe.Pointer(&aa.value)) + 7) &^ 7)) +} + +func (aa *AlignedAtomicUint64) Load() uint64 { + return atomic.LoadUint64(aa.ptr()) +} + +func (aa *AlignedAtomicUint64) Store(v uint64) { + atomic.StoreUint64(aa.ptr(), v) +} + +func (aa *AlignedAtomicUint64) Add(v uint64) uint64 { + return atomic.AddUint64(aa.ptr(), v) +} diff --git a/pkg/tcpip/socketops.go b/pkg/tcpip/socketops.go index dc37e61a4..9ce5f231b 100644 --- a/pkg/tcpip/socketops.go +++ b/pkg/tcpip/socketops.go @@ -205,7 +205,7 @@ type SocketOptions struct { getSendBufferLimits GetSendBufferLimits `state:"manual"` // sendBufferSize determines the send buffer size for this socket. - sendBufferSize int64 + sendBufferSize AlignedAtomicInt64 // mu protects the access to the below fields. mu sync.Mutex `state:"nosave"` @@ -595,7 +595,7 @@ func (so *SocketOptions) SetBindToDevice(bindToDevice int32) Error { // GetSendBufferSize gets value for SO_SNDBUF option. func (so *SocketOptions) GetSendBufferSize() int64 { - return atomic.LoadInt64(&so.sendBufferSize) + return so.sendBufferSize.Load() } // SetSendBufferSize sets value for SO_SNDBUF option. notify indicates if the @@ -604,7 +604,7 @@ func (so *SocketOptions) SetSendBufferSize(sendBufferSize int64, notify bool) { v := sendBufferSize if !notify { - atomic.StoreInt64(&so.sendBufferSize, v) + so.sendBufferSize.Store(v) return } @@ -630,5 +630,5 @@ func (so *SocketOptions) SetSendBufferSize(sendBufferSize int64, notify bool) { // Notify endpoint about change in buffer size. newSz := so.handler.OnSetSendBufferSize(v) - atomic.StoreInt64(&so.sendBufferSize, newSz) + so.sendBufferSize.Store(newSz) } diff --git a/pkg/tcpip/tcpip.go b/pkg/tcpip/tcpip.go index 87ea09a5e..a2935d695 100644 --- a/pkg/tcpip/tcpip.go +++ b/pkg/tcpip/tcpip.go @@ -37,7 +37,6 @@ import ( "reflect" "strconv" "strings" - "sync/atomic" "time" "gvisor.dev/gvisor/pkg/sync" @@ -1204,7 +1203,7 @@ type NetworkProtocolNumber uint32 // A StatCounter keeps track of a statistic. type StatCounter struct { - count uint64 + count AlignedAtomicUint64 } // Increment adds one to the counter. @@ -1219,12 +1218,12 @@ func (s *StatCounter) Decrement() { // Value returns the current value of the counter. func (s *StatCounter) Value() uint64 { - return atomic.LoadUint64(&s.count) + return s.count.Load() } // IncrementBy increments the counter by v. func (s *StatCounter) IncrementBy(v uint64) { - atomic.AddUint64(&s.count, v) + s.count.Add(v) } func (s *StatCounter) String() string { -- cgit v1.2.3 From a36748e572014bb2269da1306862bd14369f1f81 Mon Sep 17 00:00:00 2001 From: Kevin Krakauer Date: Fri, 19 Mar 2021 13:44:26 -0700 Subject: Moved to atomicbitops and renamed files --- pkg/atomicbitops/BUILD | 2 + pkg/atomicbitops/aligned_32bit_unsafe.go | 80 ++++++++++++++++++++++++++++++++ pkg/atomicbitops/aligned_64bit.go | 61 ++++++++++++++++++++++++ pkg/tcpip/BUILD | 3 +- pkg/tcpip/aligned.go | 61 ------------------------ pkg/tcpip/aligned_unsafe.go | 80 -------------------------------- pkg/tcpip/socketops.go | 3 +- pkg/tcpip/stack/BUILD | 1 + pkg/tcpip/stack/stack.go | 5 +- pkg/tcpip/tcpip.go | 3 +- 10 files changed, 152 insertions(+), 147 deletions(-) create mode 100644 pkg/atomicbitops/aligned_32bit_unsafe.go create mode 100644 pkg/atomicbitops/aligned_64bit.go delete mode 100644 pkg/tcpip/aligned.go delete mode 100644 pkg/tcpip/aligned_unsafe.go diff --git a/pkg/atomicbitops/BUILD b/pkg/atomicbitops/BUILD index 1a30f6967..11072d4de 100644 --- a/pkg/atomicbitops/BUILD +++ b/pkg/atomicbitops/BUILD @@ -5,6 +5,8 @@ package(licenses = ["notice"]) go_library( name = "atomicbitops", srcs = [ + "aligned_32bit_unsafe.go", + "aligned_64bit.go", "atomicbitops.go", "atomicbitops_amd64.s", "atomicbitops_arm64.s", diff --git a/pkg/atomicbitops/aligned_32bit_unsafe.go b/pkg/atomicbitops/aligned_32bit_unsafe.go new file mode 100644 index 000000000..1d71a0641 --- /dev/null +++ b/pkg/atomicbitops/aligned_32bit_unsafe.go @@ -0,0 +1,80 @@ +// Copyright 2021 The gVisor Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build arm 386 + +package atomicbitops + +import ( + "sync/atomic" + "unsafe" +) + +// AlignedAtomicInt64 is an atomic int64 that is guaranteed to be 64-bit +// aligned, even on 32-bit systems. +// +// Per https://golang.org/pkg/sync/atomic/#pkg-note-BUG: +// +// "On ARM, 386, and 32-bit MIPS, it is the caller's responsibility to arrange +// for 64-bit alignment of 64-bit words accessed atomically. The first word in +// a variable or in an allocated struct, array, or slice can be relied upon to +// be 64-bit aligned." +type AlignedAtomicInt64 struct { + value [15]byte +} + +func (aa *AlignedAtomicInt64) ptr() *int64 { + return (*int64)(unsafe.Pointer((uintptr(unsafe.Pointer(&aa.value)) + 7) &^ 7)) +} + +func (aa *AlignedAtomicInt64) Load() int64 { + return atomic.LoadInt64(aa.ptr()) +} + +func (aa *AlignedAtomicInt64) Store(v int64) { + atomic.StoreInt64(aa.ptr(), v) +} + +func (aa *AlignedAtomicInt64) Add(v int64) int64 { + return atomic.AddInt64(aa.ptr(), v) +} + +// AlignedAtomicUint64 is an atomic uint64 that is guaranteed to be 64-bit +// aligned, even on 32-bit systems. +// +// Per https://golang.org/pkg/sync/atomic/#pkg-note-BUG: +// +// "On ARM, 386, and 32-bit MIPS, it is the caller's responsibility to arrange +// for 64-bit alignment of 64-bit words accessed atomically. The first word in +// a variable or in an allocated struct, array, or slice can be relied upon to +// be 64-bit aligned." +type AlignedAtomicUint64 struct { + value [15]byte +} + +func (aa *AlignedAtomicUint64) ptr() *uint64 { + return (*uint64)(unsafe.Pointer((uintptr(unsafe.Pointer(&aa.value)) + 7) &^ 7)) +} + +func (aa *AlignedAtomicUint64) Load() uint64 { + return atomic.LoadUint64(aa.ptr()) +} + +func (aa *AlignedAtomicUint64) Store(v uint64) { + atomic.StoreUint64(aa.ptr(), v) +} + +func (aa *AlignedAtomicUint64) Add(v uint64) uint64 { + return atomic.AddUint64(aa.ptr(), v) +} diff --git a/pkg/atomicbitops/aligned_64bit.go b/pkg/atomicbitops/aligned_64bit.go new file mode 100644 index 000000000..21043c53d --- /dev/null +++ b/pkg/atomicbitops/aligned_64bit.go @@ -0,0 +1,61 @@ +// Copyright 2021 The gVisor Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build !arm,!386 + +package atomicbitops + +import "sync/atomic" + +// AlignedAtomicInt64 is an atomic int64 that is guaranteed to be 64-bit +// aligned, even on 32-bit systems. On 64-bit machines, it's just a regular +// int64. +// +// See aligned_unsafe.go in this directory for justification. +type AlignedAtomicInt64 struct { + value int64 +} + +func (aa *AlignedAtomicInt64) Load() int64 { + return atomic.LoadInt64(&aa.value) +} + +func (aa *AlignedAtomicInt64) Store(v int64) { + atomic.StoreInt64(&aa.value, v) +} + +func (aa *AlignedAtomicInt64) Add(v int64) int64 { + return atomic.AddInt64(&aa.value, v) +} + +// AlignedAtomicUint64 is an atomic uint64 that is guaranteed to be 64-bit +// aligned, even on 32-bit systems. On 64-bit machines, it's just a regular +// uint64. +// +// See aligned_unsafe.go in this directory for justification. +type AlignedAtomicUint64 struct { + value uint64 +} + +func (aa *AlignedAtomicUint64) Load() uint64 { + return atomic.LoadUint64(&aa.value) +} + +func (aa *AlignedAtomicUint64) Store(v uint64) { + atomic.StoreUint64(&aa.value, v) +} + +func (aa *AlignedAtomicUint64) Add(v uint64) uint64 { + return atomic.AddUint64(&aa.value, v) +} diff --git a/pkg/tcpip/BUILD b/pkg/tcpip/BUILD index f71a805bf..eac18028d 100644 --- a/pkg/tcpip/BUILD +++ b/pkg/tcpip/BUILD @@ -18,8 +18,6 @@ go_template_instance( go_library( name = "tcpip", srcs = [ - "aligned.go", - "aligned_unsafe.go", "errors.go", "sock_err_list.go", "socketops.go", @@ -29,6 +27,7 @@ go_library( ], visibility = ["//visibility:public"], deps = [ + "//pkg/atomicbitops", "//pkg/sync", "//pkg/tcpip/buffer", "//pkg/waiter", diff --git a/pkg/tcpip/aligned.go b/pkg/tcpip/aligned.go deleted file mode 100644 index ea22c101f..000000000 --- a/pkg/tcpip/aligned.go +++ /dev/null @@ -1,61 +0,0 @@ -// Copyright 2021 The gVisor Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// +build !arm,!386 - -package tcpip - -import "sync/atomic" - -// AlignedAtomicInt64 is an atomic int64 that is guaranteed to be 64-bit -// aligned, even on 32-bit systems. On 64-bit machines, it's just a regular -// int64. -// -// See aligned_unsafe.go in this directory for justification. -type AlignedAtomicInt64 struct { - value int64 -} - -func (aa *AlignedAtomicInt64) Load() int64 { - return atomic.LoadInt64(&aa.value) -} - -func (aa *AlignedAtomicInt64) Store(v int64) { - atomic.StoreInt64(&aa.value, v) -} - -func (aa *AlignedAtomicInt64) Add(v int64) int64 { - return atomic.AddInt64(&aa.value, v) -} - -// AlignedAtomicUint64 is an atomic uint64 that is guaranteed to be 64-bit -// aligned, even on 32-bit systems. On 64-bit machines, it's just a regular -// uint64. -// -// See aligned_unsafe.go in this directory for justification. -type AlignedAtomicUint64 struct { - value uint64 -} - -func (aa *AlignedAtomicUint64) Load() uint64 { - return atomic.LoadUint64(&aa.value) -} - -func (aa *AlignedAtomicUint64) Store(v uint64) { - atomic.StoreUint64(&aa.value, v) -} - -func (aa *AlignedAtomicUint64) Add(v uint64) uint64 { - return atomic.AddUint64(&aa.value, v) -} diff --git a/pkg/tcpip/aligned_unsafe.go b/pkg/tcpip/aligned_unsafe.go deleted file mode 100644 index 35e869453..000000000 --- a/pkg/tcpip/aligned_unsafe.go +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright 2021 The gVisor Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// +build arm 386 - -package tcpip - -import ( - "sync/atomic" - "unsafe" -) - -// AlignedAtomicInt64 is an atomic int64 that is guaranteed to be 64-bit -// aligned, even on 32-bit systems. -// -// Per https://golang.org/pkg/sync/atomic/#pkg-note-BUG: -// -// "On ARM, 386, and 32-bit MIPS, it is the caller's responsibility to arrange -// for 64-bit alignment of 64-bit words accessed atomically. The first word in -// a variable or in an allocated struct, array, or slice can be relied upon to -// be 64-bit aligned." -type AlignedAtomicInt64 struct { - value [15]byte -} - -func (aa *AlignedAtomicInt64) ptr() *int64 { - return (*int64)(unsafe.Pointer((uintptr(unsafe.Pointer(&aa.value)) + 7) &^ 7)) -} - -func (aa *AlignedAtomicInt64) Load() int64 { - return atomic.LoadInt64(aa.ptr()) -} - -func (aa *AlignedAtomicInt64) Store(v int64) { - atomic.StoreInt64(aa.ptr(), v) -} - -func (aa *AlignedAtomicInt64) Add(v int64) int64 { - return atomic.AddInt64(aa.ptr(), v) -} - -// AlignedAtomicUint64 is an atomic uint64 that is guaranteed to be 64-bit -// aligned, even on 32-bit systems. -// -// Per https://golang.org/pkg/sync/atomic/#pkg-note-BUG: -// -// "On ARM, 386, and 32-bit MIPS, it is the caller's responsibility to arrange -// for 64-bit alignment of 64-bit words accessed atomically. The first word in -// a variable or in an allocated struct, array, or slice can be relied upon to -// be 64-bit aligned." -type AlignedAtomicUint64 struct { - value [15]byte -} - -func (aa *AlignedAtomicUint64) ptr() *uint64 { - return (*uint64)(unsafe.Pointer((uintptr(unsafe.Pointer(&aa.value)) + 7) &^ 7)) -} - -func (aa *AlignedAtomicUint64) Load() uint64 { - return atomic.LoadUint64(aa.ptr()) -} - -func (aa *AlignedAtomicUint64) Store(v uint64) { - atomic.StoreUint64(aa.ptr(), v) -} - -func (aa *AlignedAtomicUint64) Add(v uint64) uint64 { - return atomic.AddUint64(aa.ptr(), v) -} diff --git a/pkg/tcpip/socketops.go b/pkg/tcpip/socketops.go index 9ce5f231b..5f8f2abe1 100644 --- a/pkg/tcpip/socketops.go +++ b/pkg/tcpip/socketops.go @@ -18,6 +18,7 @@ import ( "math" "sync/atomic" + "gvisor.dev/gvisor/pkg/atomicbitops" "gvisor.dev/gvisor/pkg/sync" ) @@ -205,7 +206,7 @@ type SocketOptions struct { getSendBufferLimits GetSendBufferLimits `state:"manual"` // sendBufferSize determines the send buffer size for this socket. - sendBufferSize AlignedAtomicInt64 + sendBufferSize atomicbitops.AlignedAtomicInt64 // mu protects the access to the below fields. mu sync.Mutex `state:"nosave"` diff --git a/pkg/tcpip/stack/BUILD b/pkg/tcpip/stack/BUILD index 49362333a..485f226b2 100644 --- a/pkg/tcpip/stack/BUILD +++ b/pkg/tcpip/stack/BUILD @@ -71,6 +71,7 @@ go_library( ], visibility = ["//visibility:public"], deps = [ + "//pkg/atomicbitops", "//pkg/ilist", "//pkg/log", "//pkg/rand", diff --git a/pkg/tcpip/stack/stack.go b/pkg/tcpip/stack/stack.go index 11ff65bf2..b3c96f4c9 100644 --- a/pkg/tcpip/stack/stack.go +++ b/pkg/tcpip/stack/stack.go @@ -29,6 +29,7 @@ import ( "time" "golang.org/x/time/rate" + "gvisor.dev/gvisor/pkg/atomicbitops" "gvisor.dev/gvisor/pkg/rand" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" @@ -366,10 +367,10 @@ type ResumableEndpoint interface { } // uniqueIDGenerator is a default unique ID generator. -type uniqueIDGenerator uint64 +type uniqueIDGenerator atomicbitops.AlignedAtomicUint64 func (u *uniqueIDGenerator) UniqueID() uint64 { - return atomic.AddUint64((*uint64)(u), 1) + return ((*atomicbitops.AlignedAtomicUint64)(u)).Add(1) } // Stack is a networking stack, with all supported protocols, NICs, and route diff --git a/pkg/tcpip/tcpip.go b/pkg/tcpip/tcpip.go index a2935d695..9f15eb0d9 100644 --- a/pkg/tcpip/tcpip.go +++ b/pkg/tcpip/tcpip.go @@ -39,6 +39,7 @@ import ( "strings" "time" + "gvisor.dev/gvisor/pkg/atomicbitops" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/waiter" ) @@ -1203,7 +1204,7 @@ type NetworkProtocolNumber uint32 // A StatCounter keeps track of a statistic. type StatCounter struct { - count AlignedAtomicUint64 + count atomicbitops.AlignedAtomicUint64 } // Increment adds one to the counter. -- cgit v1.2.3 From f10d89ade6e9715332cc15d163acd00b9816c0e3 Mon Sep 17 00:00:00 2001 From: Kevin Krakauer Date: Fri, 19 Mar 2021 14:19:16 -0700 Subject: Added comments --- pkg/atomicbitops/aligned_32bit_unsafe.go | 6 ++++++ pkg/atomicbitops/aligned_64bit.go | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/pkg/atomicbitops/aligned_32bit_unsafe.go b/pkg/atomicbitops/aligned_32bit_unsafe.go index 1d71a0641..a5c762f67 100644 --- a/pkg/atomicbitops/aligned_32bit_unsafe.go +++ b/pkg/atomicbitops/aligned_32bit_unsafe.go @@ -38,14 +38,17 @@ func (aa *AlignedAtomicInt64) ptr() *int64 { return (*int64)(unsafe.Pointer((uintptr(unsafe.Pointer(&aa.value)) + 7) &^ 7)) } +// Load is analagous to atomic.LoadInt64. func (aa *AlignedAtomicInt64) Load() int64 { return atomic.LoadInt64(aa.ptr()) } +// Store is analagous to atomic.StoreInt64. func (aa *AlignedAtomicInt64) Store(v int64) { atomic.StoreInt64(aa.ptr(), v) } +// Add is analagous to atomic.AddInt64. func (aa *AlignedAtomicInt64) Add(v int64) int64 { return atomic.AddInt64(aa.ptr(), v) } @@ -67,14 +70,17 @@ func (aa *AlignedAtomicUint64) ptr() *uint64 { return (*uint64)(unsafe.Pointer((uintptr(unsafe.Pointer(&aa.value)) + 7) &^ 7)) } +// Load is analagous to atomic.LoadUint64. func (aa *AlignedAtomicUint64) Load() uint64 { return atomic.LoadUint64(aa.ptr()) } +// Store is analagous to atomic.StoreUint64. func (aa *AlignedAtomicUint64) Store(v uint64) { atomic.StoreUint64(aa.ptr(), v) } +// Add is analagous to atomic.AddUint64. func (aa *AlignedAtomicUint64) Add(v uint64) uint64 { return atomic.AddUint64(aa.ptr(), v) } diff --git a/pkg/atomicbitops/aligned_64bit.go b/pkg/atomicbitops/aligned_64bit.go index 21043c53d..5898653d8 100644 --- a/pkg/atomicbitops/aligned_64bit.go +++ b/pkg/atomicbitops/aligned_64bit.go @@ -27,14 +27,17 @@ type AlignedAtomicInt64 struct { value int64 } +// Load is analagous to atomic.LoadInt64. func (aa *AlignedAtomicInt64) Load() int64 { return atomic.LoadInt64(&aa.value) } +// Store is analagous to atomic.StoreInt64. func (aa *AlignedAtomicInt64) Store(v int64) { atomic.StoreInt64(&aa.value, v) } +// Add is analagous to atomic.AddInt64. func (aa *AlignedAtomicInt64) Add(v int64) int64 { return atomic.AddInt64(&aa.value, v) } @@ -48,14 +51,17 @@ type AlignedAtomicUint64 struct { value uint64 } +// Load is analagous to atomic.LoadUint64. func (aa *AlignedAtomicUint64) Load() uint64 { return atomic.LoadUint64(&aa.value) } +// Store is analagous to atomic.StoreUint64. func (aa *AlignedAtomicUint64) Store(v uint64) { atomic.StoreUint64(&aa.value, v) } +// Add is analagous to atomic.AddUint64. func (aa *AlignedAtomicUint64) Add(v uint64) uint64 { return atomic.AddUint64(&aa.value, v) } -- cgit v1.2.3